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));
}
