43.双面渲染的透明效果

8.反射读取常用成员数据

---

8.1 知识点

对应这存储的key，添加读取数据的逻辑

/// <summary>
/// 读取数据
/// </summary>
/// <param name="type">想要读取数据的 数据类型Type</param>
/// <param name="keyName">数据对象的唯一key 自己控制</param>
/// <returns></returns>
public object LoadData(Type type, string keyName)
{
    Log("读取自定义类型" + keyName);
    //不用object对象传入 而使用 Type传入
    //主要目的是节约一行代码（在外部）
    //假设现在你要 读取一个Player类型的数据 如果是传入object 你就必须在外部new一个对象传入
    //现在有Type的 你只用传入 一个Type typeof(Player) 然后我在内部动态创建一个对象给你返回出来
    //达到了 让你在外部 少写一行代码的作用

    //根据你传入的类型 和 keyName
    //依据你存储数据时  key的拼接规则 来进行数据的获取赋值 返回出去

    //根据传入的Type 创建一个对象 用于存储数据 要确保传进来的类型又无参构造
    object data = Activator.CreateInstance(type);

    //接下来的目的就是要往 这个new出来的对象中存储数据 填充数据

    //得到这个类所有字段的字段数组
    FieldInfo[] infos = type.GetFields();

    //用于拼接key的字符串
    string loadKeyName = "";

    //用于存储 单个字段信息的 对象 方便等一下遍历使用
    FieldInfo info;

    //遍历这个类的字段数组
    for (int i = 0; i < infos.Length; i++)
    {
        //获得单条字段
        info = infos[i];

        //key的拼接规则 一定是和存储时一模一样 这样才能找到对应数据
        loadKeyName = keyName + "_" + type.Name +
            "_" + info.FieldType.Name + "_" + info.Name;

        //有key 就可以结合 PlayerPrefs来读取数据
        //SetValue方法 赋值数据给对象 填充数据到data对象中 
        info.SetValue(data, LoadValue(info.FieldType, loadKeyName));
    }

    //返回填充完的data对象
    return data;
}

对应这存储的key，添加读取单个具体数据的逻辑

/// <summary>
/// 得到单个数据的方法
/// </summary>
/// <param name="fieldType">字段类型 用于判断 用哪个api来读取</param>
/// <param name="keyName">用于获取具体数据</param>
/// <returns></returns>
private object LoadValue(Type fieldType, string keyName)
{
    //根据 字段类型 来判断 用哪个API来读取
    if (fieldType == typeof(int))
    {
        return PlayerPrefs.GetInt(keyName, 0);
    }
    else if (fieldType == typeof(float))
    {
        return PlayerPrefs.GetFloat(keyName, 0);
    }
    else if (fieldType == typeof(string))
    {
        return PlayerPrefs.GetString(keyName, "");
    }
    else if (fieldType == typeof(bool))
    {
        //根据自定义存储bool的规则 来进行值的获取
        return PlayerPrefs.GetInt(keyName, 0) == 1 ? true : false;
    }

    return null;
}

在测试类调用读取逻辑测试

//读取数据 传入读取数据的类和唯一key
PlayerInfo p1 = PlayerPrefsDataMgr.Instance.LoadData(typeof(PlayerInfo), "Player1") as PlayerInfo;

---

8.2 知识点代码

PlayerPrefsDataMgr

using System;
using System.Collections;
using System.Collections.Generic;
using System.Reflection;
using UnityEngine;

/// <summary>
/// PlayerPrefs数据管理类 统一管理数据的存储和读取
/// </summary>
public class PlayerPrefsDataMgr
{
    private static PlayerPrefsDataMgr instance = new PlayerPrefsDataMgr();

    public static PlayerPrefsDataMgr Instance
    {
        get
        {
            return instance;
        }
    }

    private PlayerPrefsDataMgr()
    {

    }

    /// <summary>
    /// 存储数据
    /// </summary>
    /// <param name="data">数据对象</param>
    /// <param name="keyName">数据对象的唯一key 自己控制</param>
    public void SaveData(object data, string keyName)
    {
        //就是要通过 Type 得到传入数据对象的所有的 字段
        //然后结合 PlayerPrefs来进行存储

        #region 第一步 获取传入数据对象的所有字段
        Type dataType = data.GetType();
        //得到所有的字段
        FieldInfo[] infos = dataType.GetFields();
        #endregion

        #region 第二步 自己定义一个key的规则 进行数据存储
        //我们存储都是通过PlayerPrefs来进行存储的
        //保证key的唯一性 我们就需要自己定一个key的规则

        //我们自己定一个规则
        // keyName_数据类型_字段类型_字段名
        #endregion

        #region 第三步 遍历这些字段 进行数据存储
        string saveKeyName = "";
        FieldInfo info;
        for (int i = 0; i < infos.Length; i++)
        {
            //对每一个字段 进行数据存储
            //得到具体的字段信息
            info = infos[i];
            //通过FieldInfo可以直接获取到 字段的类型 和字段的名字
            //字段的类型 info.FieldType.Name
            //字段的名字 info.Name;

            //要根据我们定的key的拼接规则 来进行key的生成
            //Player1_PlayerInfo_Int32_age
            saveKeyName = keyName + "_" + dataType.Name +
                "_" + info.FieldType.Name + "_" + info.Name;

            //现在得到了Key 按照我们的规则
            //接下来就要来通过PlayerPrefs来进行存储
            //如何获取值
            //info.GetValue(data)
            //封装了一个方法 专门来存储值 
            SaveValue(info.GetValue(data), saveKeyName);
        }
        #endregion
    }

    private void SaveValue(object value, string keyName)
    {
        //直接通过PlayerPrefs来进行存储了
        //就是根据数据类型的不同 来决定使用哪一个API来进行存储
        //PlayerPrefs只支持3种类型存储 
        //判断 数据类型 是什么类型 然后调用具体的方法来存储
        Type fieldType = value.GetType();

        //类型判断
        //是不是int
        if (fieldType == typeof(int))
        {
            PlayerPrefs.SetInt(keyName, (int)value);
        }
        else if (fieldType == typeof(float))
        {
            PlayerPrefs.SetFloat(keyName, (float)value);
        }
        else if (fieldType == typeof(string))
        {
            PlayerPrefs.SetString(keyName, value.ToString());
        }
        else if (fieldType == typeof(bool))
        {
            //自己顶一个存储bool的规则
            PlayerPrefs.SetInt(keyName, (bool)value ? 1 : 0);
        }
        //如何判断 泛型类的类型呢
        //通过反射 判断 父子关系
        //这相当于是判断 字段是不是IList的子类
        else if (typeof(IList).IsAssignableFrom(fieldType))
        {
            //父类装子类
            IList list = value as IList;
            //先存储 数量 
            PlayerPrefs.SetInt(keyName, list.Count);
            int index = 0;
            foreach (object obj in list)
            {
                //存储具体的值
                SaveValue(obj, keyName + index);
                ++index;
            }
        }
        //判断是不是Dictionary类型 通过Dictionary的父类来判断
        else if (typeof(IDictionary).IsAssignableFrom(fieldType))
        {
            //父类装自来
            IDictionary dic = value as IDictionary;
            //先存字典长度
            PlayerPrefs.SetInt(keyName, dic.Count);
            //遍历存储Dic里面的具体值
            //用于区分 表示的 区分 key
            int index = 0;
            foreach (object key in dic.Keys)
            {
                SaveValue(key, keyName + "_key_" + index);
                SaveValue(dic[key], keyName + "_value_" + index);
                ++index;
            }
        }
        //基础数据类型都不是 那么可能就是自定义类型
        else
        {
            SaveData(value, keyName);
        }
    }

    /// <summary>
    /// 读取数据
    /// </summary>
    /// <param name="type">想要读取数据的 数据类型Type</param>
    /// <param name="keyName">数据对象的唯一key 自己控制</param>
    /// <returns></returns>
    public object LoadData(Type type, string keyName)
    {
        //不用object对象传入 而使用 Type传入
        //主要目的是节约一行代码（在外部）
        //假设现在你要 读取一个Player类型的数据 如果是object 你就必须在外部new一个对象传入
        //现在有Type的 你只用传入 一个Type typeof(Player) 然后我在内部动态创建一个对象给你返回出来
        //达到了 让你在外部 少写一行代码的作用

        //根据你传入的类型 和 keyName
        //依据你存储数据时  key的拼接规则 来进行数据的获取赋值 返回出去

        //根据传入的Type 创建一个对象 用于存储数据 要确保传进来的类型又无参构造
        object data = Activator.CreateInstance(type);

        //接下来的目的就是要往 这个new出来的对象中存储数据 填充数据
        
        //得到这个类所有字段的字段数组
        FieldInfo[] infos = type.GetFields();

        //用于拼接key的字符串
        string loadKeyName = "";

        //用于存储 单个字段信息的 对象 方便等一下遍历使用
        FieldInfo info;

        //遍历这个类的字段数组
        for (int i = 0; i < infos.Length; i++)
        {
            //获得单条字段
            info = infos[i];

            //key的拼接规则 一定是和存储时一模一样 这样才能找到对应数据
            loadKeyName = keyName + "_" + type.Name +
                "_" + info.FieldType.Name + "_" + info.Name;

            //有key 就可以结合 PlayerPrefs来读取数据
            //SetValue方法 赋值数据给对象 填充数据到data对象中 
            info.SetValue(data, LoadValue(info.FieldType, loadKeyName));
        }

        //返回填充完的data对象
        return data;
    }

    /// <summary>
    /// 得到单个数据的方法
    /// </summary>
    /// <param name="fieldType">字段类型 用于判断 用哪个api来读取</param>
    /// <param name="keyName">用于获取具体数据</param>
    /// <returns></returns>
    private object LoadValue(Type fieldType, string keyName)
    {
        //根据 字段类型 来判断 用哪个API来读取
        if (fieldType == typeof(int))
        {
            return PlayerPrefs.GetInt(keyName, 0);
        }
        else if (fieldType == typeof(float))
        {
            return PlayerPrefs.GetFloat(keyName, 0);
        }
        else if (fieldType == typeof(string))
        {
            return PlayerPrefs.GetString(keyName, "");
        }
        else if (fieldType == typeof(bool))
        {
            //根据自定义存储bool的规则 来进行值的获取
            return PlayerPrefs.GetInt(keyName, 0) == 1 ? true : false;
        }


        return null;
    }
}

Test

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class PlayerInfo
{
    public int age = 10;
    public string name = "未命名";
    public float height = 177.5f;
    public bool sex = true;

    public List<int> list = new List<int>() { 1, 2, 3, 4 };

    public Dictionary<int, string> dic = new Dictionary<int, string>()
    {
        { 1,"123"},
        { 2,"234"}
    };

    public ItemInfo itemInfo = new ItemInfo(3, 99);

    public List<ItemInfo> itemList = new List<ItemInfo>() {
        new ItemInfo(1, 10),
        new ItemInfo(2, 20),
    };

    public Dictionary<int, ItemInfo> itemDic = new Dictionary<int, ItemInfo>()
    {
        { 3, new ItemInfo(3, 22)},
        { 4, new ItemInfo(4, 33)},
    };
}

public class ItemInfo
{
    public int id;
    public int num;

    public ItemInfo()
    {

    }

    public ItemInfo(int id, int num)
    {
        this.id = id;
        this.num = num;
    }
}


public class Test : MonoBehaviour
{
    void Start()
    {
        PlayerInfo p = new PlayerInfo();
        //需要把这个数据对象的信息 存储到硬盘
        PlayerPrefsDataMgr.Instance.SaveData(p, "Player1");

        //读取数据
        PlayerInfo p2 = PlayerPrefsDataMgr.Instance.LoadData(typeof(PlayerInfo), "Player1") as PlayerInfo;

    }
}

---

---

转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论，也可以邮件至 785293209@qq.com