PlayerPrefs实践小项目

反射知识补充

反射知识回顾

Type  用于获取 类的所有信息 字段 属性 方法 等

Assembly 用于获取程序集 通过程序集获取Type

Activator 用于快速实例化对象

判断一个类型的对象是否可以让另一个类型为自己分配空间

public class Father{}
public class Son:Father{}
//父类装子类
//是否可以从某一个类型的对象 为自己 分配空间
Type fatherType = typeof(Father);
Type sonType = typeof(Son);
 
//调用者 通过该方法进行判断 判断是否可以通过传入的类型为自己 分配空间
if(fatherType.IsAssignableFrom(sonType)){
    print("可以装");
    Father f = Activator.CreateInstance(sonType) as Father;
    print(f);
}
else
{
    print("不能装")
}

通过反射获取泛型类型

List<string> list = new List<string>();
Type listType = list.GetType();

Type[] types = listType.GetGenericArguments();
print(types[0]);

Dictionary<string, float> dic = new Dictionary<string, float>();
Type dicType = dic.GetType();

types = dicType.GetGenericArguments();
print(types[0]);
print(types[1]);

需求分析

项目实践

数据管理类创建

类的基本信息

//PlayerPrefs数据管理类 统一管理数据的存储和读取
public class PlayerPrefsDataMgr
{
    private static PlayerPrefsDataMgr instance = new PlayerPrefsDataMgr();
    public static PlayerPrefsDataMgr Instance
    {
        get { return instance; }
    }
    //私有构造，不让外部new
    private PlayerPrefsDataMgr() { }
}

存储数据函数定义

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

读取数据函数定义

/// <summary>
    /// 读取数据
    /// </summary>
    /// <param name="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的拼接规则 来进行数据的获取赋值 返回
        return null;
    }

反射存储数据

结合反射常用类型存储

定义PlayerInfo类以及脚本调用PlayerPrefsDataMgr

public class PlayerInfo
{
    public string name = "未命名";
    public int age = 10;
    public bool sex = true;
    public float height = 177.5f;
}
...
void Start()
    {
        PlayerInfo p = new PlayerInfo();
        //需要把这个数据对象的信息 存储到硬盘
        PlayerPrefsDataMgr.Instance.SaveData(p, "Player1");
    }

SaveData方法补充

public void SaveData(object data, string keyName)
    {
        //就是要通过 Type 得到传入数据对象的所有字段
        //然后结合 PlayerPrefs来进行存储
        #region 第一步 获取传入数据对象的所有字段
        Type dataType = data.GetType();
        FieldInfo[] infos =  dataType.GetFields();
        for(int i = 0; i < infos.Length; i++)
        {
            //因为没有继承monobehaivor，所以用debug
            Debug.Log(infos[i]);
        }
        #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;
            Debug.Log(saveKeyName);
            //得到key后 要按照规则
            //通过PlayerPrefs来进行存储
            //如何获取值
            //info.GetValue(data)
            //封装一个方法专门存储值
            SaveValue(info.GetValue(data), saveKeyName);
        }

SaveValue方法定义

 private void SaveValue(object value,string keyName)
    {
        //直接通过PlayerPrefs来进行存储
        //根据数据类型不同 决定调用哪个API来进行存储
        //PlayerPrefs只支持3种类型存储
        Type fieldType = value.GetType();
        
        //类型判断
        if(fieldType == typeof(int))
        {
            Debug.Log("存储int" + keyName);
            PlayerPrefs.SetInt(keyName, (int)value);
        }
        else if(fieldType == typeof(float))
        {
            Debug.Log("存储float" + keyName);
            PlayerPrefs.SetFloat(keyName, (float)value);
        }
        else if(fieldType == typeof(string))
        {
            Debug.Log("存储string" + keyName);
            PlayerPrefs.SetString(keyName, value.ToString());
        }
        else if(fieldType == typeof(bool))
        {
            Debug.Log("存储bool" + keyName);
            PlayerPrefs.SetInt(keyName, (bool)value ? 1 : 0);
        }
    }

结合反射List数据类型存储（不包含自定义类）

补充PlayerInfo

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

List继承IList，且IList不是泛型类型，因此可以使用父类装子类

只需要补充SaveValue方法

//如何判断 泛型类的类型
        //通过反射 判断 父子关系
        //相当于判断 字段是不是IList子类
        else if (typeof(IList).IsAssignableFrom(fieldType))
        {
            Debug.Log("存储List" + keyName);
            //父类装子类
            IList list = value as IList;
            //先存储 数量
            PlayerPrefs.SetInt(keyName, list.Count);
            int index = 0;
            foreach(object obj in list)
            {
                //存储具体的值
                SaveValue(obj, keyName + index);
                ++index;
            }
        }

结合反射存储Dictionary数据类型

补充PlayerInfo

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

补充SaveValue

 else if (typeof(IDictionary).IsAssignableFrom(fieldType))
        {
            Debug.Log("存储Dictionary" + keyName);
            //父类装子类
            IDictionary dic = value as IDictionary;
            //先存储 字典长度
            PlayerPrefs.SetInt(keyName, dic.Count);
            //遍历存储Dic里面的具体值
            int index = 0;
            foreach (object key in dic.Keys)
            {
                SaveValue(key, keyName + "_key_" + index);
                SaveValue(dic[key], keyName + "_value_" + index);
                ++index;
            }
        }

结合反射自定义类成员存储

定义自定义类ItemInfo

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

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

补充PlayerInfo

    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> dic2 = new Dictionary<int, ItemInfo>()
    {
        {3,new ItemInfo(3,22) },
        {4,new ItemInfo(4,33) }
    };

反射读取数据

结合反射读取常用数据类型

补充Test脚本

PlayerInfo p2 = PlayerPrefsDataMgr.Instance.LoadData(typeof(PlayerInfo), "Player1") as PlayerInfo;

补充LoadData方法

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];
            loadKeyName = keyName + "_" + type.Name + "_" 
                        + info.FieldType.Name + "_" + info.Name;
            Debug.Log("读取数据" + loadKeyName);
            //有key 就可以结合PlayerPrefs来读取数据
            //填充数据到data中
            //相当于LoadValue得到的数据 通过setvalue将info的值传入data
            info.SetValue(data, LoadValue(info.FieldType,loadKeyName));
        }
        return data;
    }

LoadValue方法定义

 /// <summary>
    /// 得到单个数据的方法
    /// </summary>
    /// <param name="fieldType">字段类型 用于判断 用哪个API来读取</param>
    /// <param name="keyName">用于获取具体数据</param>
    /// <returns></returns>
    public 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))
        {
            return PlayerPrefs.GetInt(keyName, 0) == 1 ? true : false;
        }
        return null;
    }

结合反射读取List数据类型

补充LoadValue

else if (typeof(IList).IsAssignableFrom(fieldType))
        {
            //得到长度
            int count = PlayerPrefs.GetInt(keyName, 0);
            //实例化一个List对象进行赋值
            //用了反射中双A中 Activator进行快速实例化
            IList list = Activator.CreateInstance(fieldType) as IList;
            for(int i = 0; i < count; i++)
            {
                //目的是要得到 List中泛型的类型
                list.Add(LoadValue(fieldType.GetGenericArguments()[0], keyName + i));
            }
            return list;
        }

结合反射读取Dictionary数据类型

补充LoadValue

else if (typeof(IDictionary).IsAssignableFrom(fieldType))
        {   
            //得到字典长度
            int count = PlayerPrefs.GetInt(keyName, 0);
            //实例化对象 父类装子类
            IDictionary dic = Activator.CreateInstance(fieldType) as IDictionary;
            Type[] kvType = fieldType.GetGenericArguments();
            for(int i = 0; i < count; i++)
            {
                dic.Add(LoadValue(kvType[0], keyName + "_key_" + i),
                    LoadValue(kvType[1],keyName+"_value_"+i));
            }
            return dic;
        }

结合反射读取自定义类数据类型

补充LoadValue

else
        {
            return LoadData(fieldType, keyName);
        }

最终测试

删除PlayInfo中数据初始化内容

更改Start()内容

先清空数据

PlayerPrefs.DeleteAll();

再补充

 void Start()
    {
        //读取数据
        PlayerInfo p = PlayerPrefsDataMgr.Instance.LoadData(typeof(PlayerInfo), "Player1") as PlayerInfo;

        //游戏逻辑中 会去 修改这个玩家的数据
        p.age = 18;
        p.name = "阿喆不想学习";
        p.height = 1.8f;
        p.sex = true;

        p.itemList.Add(new ItemInfo(1,99));
        p.itemList.Add(new ItemInfo(2, 199));

        p.itemDic.Add(3, new ItemInfo(3, 1));
        p.itemDic.Add(4, new ItemInfo(4, 2));

        //游戏数据存储
        PlayerPrefsDataMgr.Instance.SaveData(p, "Player1");
    }

补充SaveData

  //存储到本地
        PlayerPrefs.Save();

之后进行调试，会发现第一次执行p中信息都默认为0，存储后得到

加密思路

1.找不到

将内容用多层文件夹包夹，名字辨识度降低，但对于playerprefs不适用（位置固定）

2.看不懂

对key和value加密

3.解不出

不让别人获取加密规则

生成资源包

右键PlayerPrefsDataMgr选择Export package。