public void CanCopy([Values] SerializationMethodType method) { var manager = CreateManager(method); var testObject = new SaveLoadTestObject() { listOfStrings = new List <string> { "one", "two" }, count = 10, }; var loadedObject = manager.Copy(testObject); Assert.NotNull(loadedObject); Assert.IsFalse(ReferenceEquals(testObject, loadedObject)); Assert.NotNull(loadedObject.listOfStrings); Assert.IsTrue(loadedObject.listOfStrings.Count == testObject.listOfStrings.Count); for (int i = 0; i < testObject.listOfStrings.Count; i++) { Assert.IsTrue(testObject.listOfStrings[i] == loadedObject.listOfStrings[i]); } Assert.IsTrue(testObject.count == loadedObject.count); Object.Destroy(manager); }
public void CanSave([Values] SerializationMethodType method) { var manager = CreateManager(method); var testObject = new SaveLoadTestObject() { listOfStrings = new List <string> { "one", "two" }, count = 10, }; const string filename = "Testfile"; manager.Save(testObject, filename); var filepath = $"{SaveLoadUtility.GetSavePath(SaveDirectory, BaseDirectory)}/{filename}"; Assert.IsTrue(File.Exists(filepath)); manager.DeleteSave(filename); Assert.IsFalse(File.Exists(filepath)); Object.Destroy(manager); }
private ISerializationMethod GetSerializationMethod(SerializationMethodType method) { switch (method) { case SerializationMethodType.Default: return(new SerializationMethodUnityJson()); case SerializationMethodType.Binary: return(new SerializationMethodBinary()); case SerializationMethodType.BinaryEncrypted: return(new SerializationMethodBinaryEncrypted(TestKey, TestSalt)); case SerializationMethodType.UnityJson: return(new SerializationMethodUnityJson()); case SerializationMethodType.UnityJsonEncrypted: return(new SerializationMethodUnityJsonEncrypted(TestKey, TestSalt)); case SerializationMethodType.JsonDotNet: return(new SerializationMethodJsonDotNet()); case SerializationMethodType.JsonDotNetEncrypted: return(new SerializationMethodJsonDotNetEncrypted(TestKey, TestSalt)); case SerializationMethodType.Custom: return(new SerializationMethodBinary()); default: throw new ArgumentOutOfRangeException(nameof(method), method, null); } }
public void CanSaveLoadUnityObject([Values] SerializationMethodType method) { const string filename = "Testfile"; var manager = CreateManager(method); var testObj = ScriptableObject.CreateInstance <SaveLoadTestUnityObject>(); var loadedTestObj = ScriptableObject.CreateInstance <SaveLoadTestUnityObject>(); testObj.textValue = "MyValue"; manager.SaveUnityObject(testObj, filename); var filepath = $"{SaveLoadUtility.GetSavePath(SaveDirectory, BaseDirectory)}/{filename}"; Assert.IsTrue(File.Exists(filepath)); //var loadedTestObj = manager.Load<SaveLoadTestUnityObject>(filename); //Assert.IsTrue(loadedTestObj != null); manager.LoadUnityObjectOverwrite(loadedTestObj, filename); Assert.IsTrue(loadedTestObj.textValue == testObj.textValue); manager.DeleteSave(filename); Assert.IsFalse(File.Exists(filepath)); Object.Destroy(testObj); Object.Destroy(loadedTestObj); Object.Destroy(manager); }
/// <summary> /// 根据类型得到序列化方法 /// </summary> /// <param name="type"></param> /// <param name="methodType"></param> /// <returns></returns> public static MethodInfo GetTypeMethod(Type type, SerializationMethodType methodType) { MethodInfo method = GetMethodByCache(type, methodType); if (method == null) { // 对于枚举类型:根据基础类型找到适当的序列化器方法 // 对于简单类型:找到对应的 IPrimitiveReader/IPrimitveWriter 方法 // 对于复杂类型:根据类型得到适当的序列化器方法 if (type.IsEnum) { method = GetMethodByEnum(type, methodType); } else { method = GetMethodBySimple(type, methodType); } if (method == null) { throw new NotImplementedException(string.Format("无法得到类型的DTOSerialize或DTODeserialize方法,类型: {0}", type.FullName)); } //更新方法缓存 _typeMethodsLock.Write(() => _typeMethods[methodType][type] = method); } return(method); }
public void CanCreateManager([Values] SerializationMethodType method) { var manager = CreateManager(method); Assert.IsTrue(manager != null); Object.Destroy(manager); }
/// <summary> /// 获取方法的拥有者在参数中的序号 /// </summary> /// <param name="method"></param> /// <param name="methodType"></param> /// <returns></returns> public static int GetParameterIndex(MethodInfo method, SerializationMethodType methodType) { string typeName = method.DeclaringType.Name; if (methodType == SerializationMethodType.Serialize) { if (typeName == typeof(DTObjectSerializer).Name) { return(SerializationArgs.SerializerIndex); } if (typeName == typeof(IDTOWriter).Name) { return(SerializationArgs.WriterIndex); } } else { if (typeName == typeof(DTObjectDeserializer).Name) { return(SerializationArgs.DeserializerIndex); } if (typeName == typeof(IDTOReader).Name) { return(SerializationArgs.ReaderIndex); } } throw new SerializationException("没有找到类型" + typeName + "对应的参数序号"); }
private ISerializationMethod GetSaveLoadMethod(SerializationMethodType methodType) { if (_methods == null) { _methods = new Dictionary <SerializationMethodType, ISerializationMethod>(); } if (_methods.TryGetValue(methodType, out var method)) { return(method); } //Create method if it did not yet exist switch (methodType) { case SerializationMethodType.Default: method = GetSaveLoadMethod(SerializationMethodType.UnityJson); break; case SerializationMethodType.Binary: method = new SerializationMethodBinary(); break; case SerializationMethodType.UnityJson: method = new SerializationMethodUnityJson(); break; case SerializationMethodType.BinaryEncrypted: method = new SerializationMethodBinaryEncrypted(key, salt); break; case SerializationMethodType.UnityJsonEncrypted: method = new SerializationMethodUnityJsonEncrypted(key, salt); break; #if JSON_DOT_NET case SerializationMethodType.JsonDotNet: method = new SerializationMethodJsonDotNet(); break; case SerializationMethodType.JsonDotNetEncrypted: method = new SerializationMethodJsonDotNetEncrypted(key, salt); break; #endif case SerializationMethodType.Custom: throw new Exception("SaveMethod is Custom but no custom serialization method has been set."); default: throw new ArgumentOutOfRangeException(nameof(methodType), methodType, "SaveLoadMethodType not supported"); } _methods[methodType] = method; return(method); }
private static SaveLoadManager CreateManager(SerializationMethodType method = SerializationMethodType.Default) { var manager = SaveLoadManager.Create(BaseDirectory, SaveDirectory, method, TestEncryptionKey, TestEncryptionSalt); if (method == SerializationMethodType.Custom) { manager.SetCustomSerializationMethod(new SerializationMethodUnityJson()); } return(manager); }
public void LoadReturnsNullWhenFileDoesnotExist([Values] SerializationMethodType method) { var manager = CreateManager(method); const string filename = "Testfile"; var loadedObject = manager.Load <SaveLoadTestObject>(filename); Assert.IsTrue(loadedObject == null); Object.Destroy(manager); }
private static MethodInfo GetMethodBySimple(Type type, SerializationMethodType methodType) { MethodInfo method = null; switch (methodType) { case SerializationMethodType.Serialize: if (type.Name.StartsWith("Nullable")) { Type[] typeArgs = new Type[] { typeof(string), type }; method = typeof(IDTOWriter).ResolveMethod("Write", typeArgs); } else { Type[] typeArgs = new Type[] { typeof(string), type }; method = typeof(IDTOWriter).ResolveMethod("Write", typeArgs); if ((method == null) && (type.IsPrimitive == false)) { //如果不是int、long等基础类型,而有可能是自定义类型,那么用以下代码得到方法 method = typeof(IDTOWriter).ResolveMethod("Write", _writeObjectArgs); } } break; case SerializationMethodType.Deserialize: if (type.Name.StartsWith("Nullable")) { Type[] targs = type.GetGenericArguments(); string methodName = string.Format("ReadNullable{0}", targs[0].Name); method = typeof(IDTOReader).ResolveMethod(methodName, _readArgs); } else { Type[] targs = type.GetGenericArguments(); string methodName = string.Format("Read{0}", type.Name); method = typeof(IDTOReader).ResolveMethod(methodName, _readArgs); } if ((method == null) && (type.IsPrimitive == false)) { //如果不是int、long等基础类型,而有可能是自定义类型,那么用以下代码得到方法 //IDTOWriter.ReadObject<T>(string name); method = typeof(IDTOReader).ResolveMethod("ReadObject", new Type[] { type }, MethodParameter.Create <string>()); } break; } if (method == null) { throw new DTOException("没有找到" + type.ResolveName() + "的dto序列化方法"); } return(method); }
public void CopyThrowsArgumentExceptionOnUnityObject([Values] SerializationMethodType method) { var manager = CreateManager(method); var testObj = ScriptableObject.CreateInstance <SaveLoadTestUnityObject>(); Assert.Throws <ArgumentException>(() => { manager.Copy(testObj); }); Object.Destroy(testObj); Object.Destroy(manager); }
private static MethodInfo GetMethodByCache(Type type, SerializationMethodType methodType) { MethodInfo method = null; Dictionary <Type, MethodInfo> methodTypeMethods = null; _typeMethodsLock.Read(() => { if (_typeMethods.TryGetValue(methodType, out methodTypeMethods)) { methodTypeMethods.TryGetValue(type, out method); } }); return(method); }
public void CanCopyUnityObject([Values] SerializationMethodType method) { var manager = CreateManager(method); var testObj = ScriptableObject.CreateInstance <SaveLoadTestUnityObject>(); var loadedTestObj = ScriptableObject.CreateInstance <SaveLoadTestUnityObject>(); testObj.textValue = "MyValue"; manager.CopyUnityObjectOverwrite(testObj, loadedTestObj); Assert.IsTrue(loadedTestObj.textValue == testObj.textValue); Object.Destroy(testObj); Object.Destroy(loadedTestObj); Object.Destroy(manager); }
public void CanSaveAndLoadDictionary([Values( SerializationMethodType.Binary, SerializationMethodType.BinaryEncrypted #if JSON_DOT_NET , SerializationMethodType.JsonDotNet, SerializationMethodType.JsonDotNetEncrypted #endif )] SerializationMethodType method) { var manager = CreateManager(method); var testObject = new SaveLoadDictionaryTestObject() { dict = new Dictionary <string, int> { { "one", 1 }, { "two", 2 } }, name = "Test", }; const string filename = "Testfile"; manager.Save(testObject, filename); var filepath = $"{SaveLoadUtility.GetSavePath(SaveDirectory, BaseDirectory)}/{filename}"; Assert.IsTrue(File.Exists(filepath)); var loadedObject = manager.Load <SaveLoadDictionaryTestObject>(filename); Assert.IsTrue(loadedObject.name == testObject.name); Assert.IsTrue(loadedObject.dict.Count == testObject.dict.Count); Assert.IsTrue(loadedObject.dict.ContainsKey("one")); Assert.IsTrue(loadedObject.dict.ContainsKey("two")); Assert.IsTrue(loadedObject.dict["one"] == 1); Assert.IsTrue(loadedObject.dict["two"] == 2); manager.DeleteSave(filename); Assert.IsFalse(File.Exists(filepath)); Object.Destroy(manager); }
public void SaveLoadAndDelete([Values] SerializationMethodType method) { var testSave = new SaveLoadTestObject() { testData = "SaveFileExists" }; var serializationMethod = GetSerializationMethod(method); var filename = "TestSave.sav"; SaveLoadUtility.Save(testSave, serializationMethod, filename); Assert.IsTrue(SaveLoadUtility.Exists(filename)); var loadedSave = (SaveLoadTestObject)SaveLoadUtility.Load(typeof(SaveLoadTestObject), serializationMethod, filename); Assert.NotNull(loadedSave); Assert.IsTrue(loadedSave.testData == testSave.testData); SaveLoadUtility.DeleteSavedFile(filename); Assert.IsFalse(SaveLoadUtility.Exists(filename)); }
/// <summary> /// Helper Method for constructing a new instance of SaveLoadManager which specific protected settings /// </summary> /// <param name="baseFolder">Base directory folder</param> /// <param name="defaultFolder">Default folder to save files to</param> /// <param name="saveMethod">Method to use to save and load files</param> /// <param name="key">Encryption key is required if using an encrypted method.</param> /// <param name="salt">Encryption salt is required if using an ecrypted method.</param> /// <returns>Newly created instance of SaveLoadManager</returns> public static SaveLoadManager Create(string baseFolder, string defaultFolder, SerializationMethodType saveMethod, string key = null, string salt = null) { var instance = CreateInstance <SaveLoadManager>(); instance.baseFolder = baseFolder; instance.defaultFolder = defaultFolder; instance.key = key; instance.salt = salt; instance.saveMethod = saveMethod; return(instance); }
/// <summary> /// Load object from file and specify the method of save/load /// </summary> /// <param name="methodType">Method to be used to save the file to disk.</param> /// <param name="filename">Name of file to be read from.</param> /// <param name="folder">Name of the folder containing the file.</param> /// <typeparam name="T">Type of object to be loaded from the file.</typeparam> /// <returns>Object instance loaded from file. Null if file does not exist or load failed.</returns> public object LoadWithMethod(SerializationMethodType methodType, Type type, string filename, string folder = null) { var saveLoadMethod = GetSaveLoadMethod(methodType); return(SaveLoadUtility.Load(type, saveLoadMethod, filename, folder)); }
/// <summary> /// Load object from file and specify the method of save/load /// </summary> /// <param name="methodType">Method to be used to save the file to disk.</param> /// <param name="filename">Name of file to be read from.</param> /// <param name="folder">Name of the folder containing the file.</param> /// <typeparam name="T">Type of object to be loaded from the file.</typeparam> /// <returns>Object instance loaded from file. Null if file does not exist or load failed.</returns> public object LoadWithMethod <T>(SerializationMethodType methodType, string filename, string folder = null) { return((T)LoadWithMethod(methodType, typeof(T), filename, folder)); }
/// <summary> /// Save object to file and specify the method of save/load /// </summary> /// <param name="methodType">Method to be used to save the file to disk.</param> /// <param name="obj">Object to be written to disk.</param> /// <param name="filename">Name of file to write to.</param> /// <param name="folder">Name of folder to save to. If null the default folder will be used.</param> public void SaveWithMethod(SerializationMethodType methodType, object obj, string filename, string folder = null) { var saveLoadMethod = GetSaveLoadMethod(methodType); SaveLoadUtility.Save(obj, saveLoadMethod, filename, folder); }
private static MethodInfo GetMethodByEnum(Type type, SerializationMethodType methodType) { return(GetTypeMethod(Enum.GetUnderlyingType(type), methodType)); }