public void StrangeFormatTests() { var serializer = new fsSerializer(); DateTime time = DateTime.Now; serializer.TryDeserialize(new fsData("2016-01-22T12:06:57.503005Z"), ref time).AssertSuccessWithoutWarnings(); Assert.AreEqual(Convert.ToDateTime("2016-01-22T12:06:57.503005Z"), time); }
public void TestPopulateObject() { // This test verifies that when we pass in an existing object // instance that same instance is used to deserialize into, ie, // we can do the equivalent of Json.NET's PopulateObject SimpleModel model1 = new SimpleModel { A = 3, B = new List<int> { 1, 2, 3 } }; fsData data; var serializer = new fsSerializer(); Assert.IsTrue(serializer.TrySerialize(model1, out data).Succeeded); model1.A = 1; model1.B = new List<int> { 1 }; SimpleModel model2 = model1; Assert.AreEqual(1, model1.A); Assert.AreEqual(1, model2.A); CollectionAssert.AreEqual(new List<int> { 1 }, model1.B); CollectionAssert.AreEqual(new List<int> { 1 }, model2.B); Assert.IsTrue(serializer.TryDeserialize(data, ref model2).Succeeded); // If the same instance was not used, then model2.A will equal 1 Assert.AreEqual(3, model1.A); Assert.AreEqual(3, model2.A); CollectionAssert.AreEqual(new List<int> { 1, 2, 3 }, model1.B); CollectionAssert.AreEqual(new List<int> { 1, 2, 3 }, model2.B); Assert.IsTrue(ReferenceEquals(model1, model2)); }
static FullSerializerSerializer() { _serializer = new fsSerializer(); _serializer.AddConverter(new UnityObjectConverter()); #if !UNITY_4_3 _serializer.AddProcessor(new SerializationCallbackReceiverObjectProcessor()); #endif }
static FullSerializerBackend() { Serializer = new fsSerializer(); Serializer.AddConverter(new UnityObjectConverter()); Serializer.AddConverter(new MethodInfoConverter()); fsConfig.SerializeAttributes = VFWSerializationLogic.Instance.SerializeMember; fsConfig.IgnoreSerializeAttributes = VFWSerializationLogic.Instance.DontSerializeMember; }
static FullSerializerBackend() { Serializer = new fsSerializer(); Serializer.AddConverter(new UnityObjectConverter()); Serializer.AddConverter(new MethodInfoConverter()); fsConfig.SerializeAttributes = VFWSerializationLogic.Instance.Attributes.SerializeMember; fsConfig.IgnoreSerializeAttributes = VFWSerializationLogic.Instance.Attributes.DontSerializeMember; }
private static void DeserializeJson(fsSerializer serializer, string json, ref object instance, bool forceReflected) { using (ProfilingUtility.SampleBlock("DeserializeJson")) { fsResult result = DeserializeJsonUtil(serializer, json, ref instance, forceReflected); HandleResult("Deserialization", result, instance as UnityObject); } }
private static void GetJsonConverters(ref fsSerializer _serializer) { var converters = new List <fsConverter>(AllJsonConverters.GetAllJsonConverters()); foreach (var converter in converters) { _serializer.AddConverter(converter); } }
//string text = "Paste JSON here"; void OnGUI() { if (GUILayout.Button("Instantiate Ragdoll")) { guids = new Dictionary <string, UnityEngine.Object>(); fields = new Dictionary <Action <UnityEngine.Object>, string>(); string text = File.ReadAllText(@"C:\Program Files (x86)\Steam\SteamApps\common\Human Fall Flat\prefab.json"); var s = new fsSerializer(); fsData data = fsJsonParser.Parse(text); JGameObject instance = new JGameObject(); s.TryDeserialize <JGameObject>(data, ref instance); instance.Instantiate(null); foreach (var a in fields.Keys) { string g = fields[a]; if (guids.ContainsKey(g)) { a.Invoke(guids[g]); } else { Debug.Log("Missing GUID " + g); } } } if (GUILayout.Button("Instantiate Player")) { guids = new Dictionary <string, UnityEngine.Object>(); fields = new Dictionary <Action <UnityEngine.Object>, string>(); string text = File.ReadAllText(@"C:\Program Files (x86)\Steam\SteamApps\common\Human Fall Flat\playerPrefab.json"); var s = new fsSerializer(); fsData data = fsJsonParser.Parse(text); JGameObject instance = new JGameObject(); s.TryDeserialize <JGameObject>(data, ref instance); instance.Instantiate(null); foreach (var a in fields.Keys) { string g = fields[a]; if (guids.ContainsKey(g)) { a.Invoke(guids[g]); } else { Debug.Log("Missing GUID " + g); } } } //text = EditorGUILayout.TextArea(text); }
private static string DoSerialize <T>(T spell) { fsData data; fsSerializer serializer = new fsSerializer(); serializer.TrySerialize(typeof(T), spell, out data); string results = FullSerializer.fsJsonPrinter.PrettyJson(data); return(results); }
static JsonHelper() { serializer = new fsSerializer(); serializer.Config.EnablePropertySerialization = false; editorSerializer = new fsSerializer(); editorSerializer.AddConverter(new UnityObjectConverter()); editorSerializer.Config.SerializeEnumsAsInteger = true; editorSerializer.Config.EnablePropertySerialization = false; }
public void UpdateLevel() { var serializer = new fsSerializer(); if (endLevel >= maxLevel) { endLevel = maxLevel; } level = FileUtils.LoadJsonFile <Level>(serializer, "Levels/" + ((!isTestScene) ? endLevel : startLevel) /*endLevel*/); }
void LoadMetadata(string geoJsonData) { fsSerializer serializer = new fsSerializer(); fsData data = null; data = fsJsonParser.Parse(geoJsonData); // step 2: deserialize the data serializer.TryDeserialize(data, ref _tileMetadata).AssertSuccessWithoutWarnings(); Debug.Log(data); }
// Use this for initialization void Start () { fsSerializer serializer = new fsSerializer(); List<PairData> memoryCapacity = new List<PairData> () { new PairData(6, 16), new PairData(4, 8)}; List<PairData> hdd = new List<PairData> () { new PairData(4, 4), new PairData(4, 8)}; List<PairData> network = new List<PairData> () { new PairData(2, 10), new PairData(2, 1)}; List<string> gpu = new List<string> () { "GPU A", "GPU B", "GPU C"}; ModelData modelData = new ModelData("Test Model", true, 2, 4, 1000, 8, 1333, memoryCapacity, "RAID 0", hdd, network, gpu, 3, "Just a test", System.DateTime.Now); fsData data; serializer.TrySerialize(modelData.GetType(), modelData, out data); string dataString = fsJsonPrinter.PrettyJson(data); data = fsJsonParser.Parse(dataString); Debug.Log(dataString); Debug.Log(modelData.ToString()); object deserialized = null; serializer.TryDeserialize(data, typeof(ModelData), ref deserialized); ModelData newModelData = (ModelData) deserialized; Debug.Log(newModelData.ToString()); PersistanceManager.StoreLocalModelData("Test Model", dataString, null); }
public void save(string filename) { try { World world = this; // world.ui.setToMainMenu(); GraphicalMap.purge(); GraphicalSociety.purge(); world.map.world = null; //foreach (SocialGroup sg in map.socialGroups) //{ // if (sg is Society) // { // Society soc = (Society)sg; // soc.voteSession = null; // } //} fsSerializer _serializer = new fsSerializer(); fsData data; _serializer.TrySerialize(typeof(Map), map, out data).AssertSuccessWithoutWarnings(); // emit the data via JSON string saveString = fsJsonPrinter.CompressedJson(data); World.Log("Save exit point"); if (File.Exists(filename)) { World.Log("Overwriting old save: " + filename); File.Delete(filename); } File.WriteAllLines(filename, new string[] { saveString }); world.map.world = world; staticMap = map; world.prefabStore.popMsg("Game saved as: " + filename); //// step 1: parse the JSON data //fsData data = fsJsonParser.Parse(serializedState); //// step 2: deserialize the data //object deserialized = null; //_serializer.TryDeserialize(data, type, ref deserialized).AssertSuccessWithoutWarnings(); }catch (Exception e) { World.log(e.Message); World.log(e.StackTrace); prefabStore.popMsg("Failure to save"); prefabStore.popMsg("Exception: " + e.StackTrace); } }
public static string Serialize(Type type, object value) { fsSerializer _serializer = new fsSerializer(); // serialize the data fsData data; _serializer.TrySerialize(type, value, out data).AssertSuccessWithoutWarnings(); // emit the data via JSON return(fsJsonPrinter.CompressedJson(data)); }
public void TestDeserializeWriteOnlyProperty() { var data = fsData.CreateDictionary(); data.AsDictionary["Getter"] = new fsData(111); // not used, but somewhat verifies that we do not try to deserialize into a R/O property data.AsDictionary["Setter"] = new fsData(222); var model = default(Model); var serializer = new fsSerializer(); Assert.IsTrue(serializer.TryDeserialize(data, ref model).Succeeded); Assert.AreEqual(222, model._setValue); }
public void VerifyMinValueRoundTrips() { var serializer = new fsSerializer(); fsData data; serializer.TrySerialize(float.MinValue, out data).AssertSuccessWithoutWarnings(); Assert.AreEqual(((double)float.MinValue).ToString(System.Globalization.CultureInfo.InvariantCulture), fsJsonPrinter.PrettyJson(data)); float deserialized = 0f; serializer.TryDeserialize(data, ref deserialized).AssertSuccessWithoutWarnings(); Assert.AreEqual(float.MinValue, deserialized); }
public static fsSerializer GetSerializer(UnityObjectList objectReferences) { if (s_serializer == null) { s_serializer = new fsSerializer(); // would add converters here if we needed to } s_serializer.UnityReferences = objectReferences; return(s_serializer); }
public SerializationOperation() { objectReferences = new List <UnityObject>(); serializer = new fsSerializer(); serializer.AddConverter(new UnityObjectConverter()); serializer.AddConverter(new RayConverter()); serializer.AddConverter(new Ray2DConverter()); serializer.AddConverter(new NamespaceConverter()); serializer.AddConverter(new LooseAssemblyNameConverter()); serializer.Context.Set(objectReferences); }
public static Dictionary <T1, T2> Deserialize <T1, T2>(string json) { var fsData = fsJsonParser.Parse(json); //in JSON object deserializedRes = null; fsSerializer serializer = new fsSerializer(); serializer.TryDeserialize(fsData, typeof(Dictionary <T1, T2>), ref deserializedRes).AssertSuccess(); return((Dictionary <T1, T2>)deserializedRes); }
public void VerifyNegativeInfinityRoundTrips() { var serializer = new fsSerializer(); fsData data; serializer.TrySerialize(float.NegativeInfinity, out data).AssertSuccessWithoutWarnings(); Assert.AreEqual("-Infinity", fsJsonPrinter.PrettyJson(data)); float deserialized = 0f; serializer.TryDeserialize(data, ref deserialized).AssertSuccessWithoutWarnings(); Assert.AreEqual(float.NegativeInfinity, deserialized); }
/// <summary> /// Loads the specified json file. /// </summary> /// <param name="serializer">The FullSerializer serializer to use.</param> /// <param name="path">The json file path.</param> /// <typeparam name="T">The type of the data to load.</typeparam> /// <returns>The loaded json data.</returns> public static T LoadJsonFile <T>(fsSerializer serializer, string path) where T : class { var textAsset = Resources.Load <TextAsset>(path); Assert.IsNotNull((textAsset)); var data = fsJsonParser.Parse(textAsset.text); object deserialized = null; serializer.TryDeserialize(data, typeof(T), ref deserialized).AssertSuccessWithoutWarnings(); return(deserialized as T); }
protected void SaveJsonFile <T>(string path, T data) where T : class { fsData serializedData; var serializer = new fsSerializer(); serializer.TrySerialize(data, out serializedData).AssertSuccessWithoutWarnings(); var file = new StreamWriter(path); var json = fsJsonPrinter.PrettyJson(serializedData); file.WriteLine(json); file.Close(); }
public static string ToJSON(Dictionary <string, object> dict) { fsSerializer serializer = new fsSerializer(); serializer.AddConverter(new DictionaryConverter()); fsData data; serializer.TrySerialize <Dictionary <string, object> >(dict, out data).AssertSuccessWithoutWarnings(); return(fsJsonPrinter.CompressedJson(data)); }
public void VerifyNaNRoundTrips() { var serializer = new fsSerializer(); // todo: could definitely reduce duplication of tests in this file! fsData data; serializer.TrySerialize(float.NaN, out data).AssertSuccessWithoutWarnings(); Assert.AreEqual("NaN", fsJsonPrinter.PrettyJson(data)); float deserialized = 0f; serializer.TryDeserialize(data, ref deserialized).AssertSuccessWithoutWarnings(); Assert.AreEqual(float.NaN, deserialized); }
public static object Deserialize(Type type, string serializedState) { // step 1: parse the JSON data fsData data = fsJsonParser.Parse(serializedState); fsSerializer _serializer = new fsSerializer(); // step 2: deserialize the data object deserialized = null; _serializer.TryDeserialize(data, type, ref deserialized).AssertSuccessWithoutWarnings(); return(deserialized); }
public void ImportLegacyInheritance() { fsData data = fsData.CreateDictionary(); data.AsDictionary["Type"] = new fsData("System.Int32"); data.AsDictionary["Data"] = new fsData(32); object o = null; var serializer = new fsSerializer(); Assert.IsTrue(serializer.TryDeserialize(data, ref o).Succeeded); Assert.IsTrue(o.GetType() == typeof(int)); Assert.IsTrue((int)o == 32); }
public void TestSerializeReadOnlyProperty() { var model = new Model(); fsData data; var serializer = new fsSerializer(); Assert.IsTrue(serializer.TrySerialize(model, out data).Succeeded); var expected = fsData.CreateDictionary(); expected.AsDictionary["Getter"] = new fsData(model.Getter); Assert.AreEqual(expected, data); }
public static bool LoadFile(string fileName, fsSerializer serializer, out SaveFileInfo saveFileInfo) { LoadFileResult result = null; Thread loadThread = new Thread(() => result = LoadFileAsync(fileName, serializer), 1024 * 1024 * 3); loadThread.Start(); while (loadThread.IsAlive) { } saveFileInfo = result.success ? result.saveFileInfo : null; return(result.success); }
public void VerifyFloatSerializationDoesNotHaveJitter() { var serializer = new fsSerializer(); // We serialize w/o jitter fsData data; serializer.TrySerialize(0.1f, out data).AssertSuccessWithoutWarnings(); Assert.AreEqual("0.1", fsJsonPrinter.PrettyJson(data)); // We deserialize w/o jitter. float deserialized = 0f; serializer.TryDeserialize(data, ref deserialized).AssertSuccessWithoutWarnings(); Assert.AreEqual(0.1f, deserialized); }
public BetterSerializer() { serializer = new fsSerializer(); serializer.AddConverter <UnityObjectConverter>(); Logic = SerializationLogic.Default; fsSerializer.Config = new fsConfig( Logic.Attributes.SerializeMember, Logic.Attributes.DontSerializeMember, false, Debug.Log, true ); }
public string Export() { fsSerializer serializer = new fsSerializer(); serializer.AddConverter(new Vector3Converter()); serializer.AddConverter(new Vector2Converter()); serializer.AddConverter(new QuaternionConverter()); serializer.TrySerialize <BlueprintData>(this, out fsData data).AssertSuccessWithoutWarnings(); string json = fsJsonPrinter.CompressedJson(data); return(Convert.ToBase64String(Zip(json))); }
private static bool Serialize(ModSettingsConfiguration config) { fsSerializer fsSerializer = new fsSerializer(); fsData data; if (fsSerializer.TrySerialize(typeof(fsSerializer), config, out data).Succeeded) { File.WriteAllText(JsonPath, fsJsonPrinter.PrettyJson(data)); return(true); } return(false); }
private static bool Deserialize(ModSettingsConfiguration config) { fsSerializer fsSerializer = new fsSerializer(); if (File.Exists(JsonPath)) { string serializedData = File.ReadAllText(JsonPath); fsData data = fsJsonParser.Parse(serializedData); return(fsSerializer.TryDeserialize(data, ref config).Succeeded); } return(false); }
public void TestOptOutOfProperties() { var model = new Model(); fsData data; var serializer = new fsSerializer(); serializer.Config.EnablePropertySerialization = false; Assert.IsTrue( serializer.TrySerialize( model, out data ).Succeeded ); var expected = fsData.CreateDictionary(); // Should just be empty dictionary. Assert.AreEqual( expected, data ); }
private T Deserialize <T>(string json) { // Parse the json string to fsData fsData data = fsJsonParser.Parse(json); // Deserialize the data to the input type object deserialized = null; fsSerializer _serializer = new fsSerializer(); _serializer.TryDeserialize(data, typeof(T), ref deserialized); return((T)deserialized); }
public void VerifyMaxValueRoundTrips() { var serializer = new fsSerializer(); fsData data; serializer.TrySerialize(float.MaxValue, out data).AssertSuccessWithoutWarnings(); Assert.AreEqual(((double)float.MaxValue).ToString(System.Globalization.CultureInfo.InvariantCulture), fsJsonPrinter.PrettyJson(data)); float deserialized = 0f; serializer.TryDeserialize(data, ref deserialized).AssertSuccessWithoutWarnings(); Assert.AreEqual(float.MaxValue, deserialized); }
/// <summary> /// Serializes the user settings to the disk. /// </summary> /// <returns>true only if all the settings were saved to disk.</returns> public bool SerializePersistentSettings() { List <KeyValuePair <object, object> > strProperties = new List <KeyValuePair <object, object> >(); List <KeyValuePair <object, object> > metaProperties = new List <KeyValuePair <object, object> >(); foreach (object key in _dict.Keys) { if (key.GetType() == typeof(string)) { strProperties.Add(new KeyValuePair <object, object>(key, _dict[key])); } else if (key.GetType() == typeof(MetaProp)) { metaProperties.Add(new KeyValuePair <object, object>(key, _dict[key])); } } fsSerializer serializer = new fsSerializer(); fsData data; var items = new[] { new { List = (object)strProperties, Path = _pathHandler.DeveloperSettingFilePath }, new { List = (object)metaProperties, Path = _pathHandler.MetaSettingsFilePath } }; bool b_isSuccess = true; foreach (var item in items) { var result = serializer.TrySerialize(item.List.GetType(), item.List, out data); if (result.Failed) { return(false); } string text = fsJsonPrinter.PrettyJson(data); string old_text = TryReadTextFile(item.Path); if (text == old_text) { //avoid changing the file's timestamp (to prevent the service from syncing unnecessarily) //Debug.Log("Prevented serialising to disk"); continue; } if (TryWriteTextFile(item.Path, text)) { b_isSuccess = false; } } return(b_isSuccess); }
public void TestIgnoreIsInheritedForProperties() { var model = new InheritedIgnoredProperty(); fsData data; var serializer = new fsSerializer(); Assert.IsTrue(serializer.TrySerialize(model, out data).Succeeded); var expected = fsData.CreateDictionary(); // Should just be empty dictionary. Assert.AreEqual(expected, data); }
public void load(string filename) { try { if (map != null) { GraphicalMap.purge(); GraphicalSociety.purge(); map.world = null; map = null; } filename = saveFolder + filename; string fullFile = File.ReadAllText(filename); //string serializedState = fullFile.Substring(fullFile.IndexOf("\n"), fullFile.Length); int startIndex = fullFile.IndexOf(saveHeader) + saveHeader.Length; int endIndex = fullFile.Length - startIndex; string serializedState = fullFile.Substring(startIndex, endIndex); fsSerializer _serializer = new fsSerializer(); fsData data = fsJsonParser.Parse(serializedState); World.Log("Data parsed"); object deserialized = null; _serializer.TryDeserialize(data, typeof(Map), ref deserialized).AssertSuccessWithoutWarnings(); World.saveLog.takeLine("Finished deserial"); map = (Map)deserialized; map.world = this; staticMap = map; World.self.displayMessages = true; GraphicalMap.map = map; //ui.setToMainMenu(); //GraphicalMap.checkLoaded(); //GraphicalMap.checkData(); //graphicalMap.loadArea(0, 0); map.decompressFromSave(); prefabStore.popMsg("Loaded file: " + filename, true); World.Log("reached end of loading code"); // prefabStore.popMsg("Load may well have succeeded."); } catch (FileLoadException e) { Debug.Log(e); World.log(e.StackTrace); prefabStore.popMsg("Exception: " + e.StackTrace, true); } catch (Exception e2) { Debug.Log(e2); World.log(e2.StackTrace); prefabStore.popMsg("Exception: " + e2.StackTrace, true); } }
public void VerifyLargeDoubleRoundTrips() { double valueToTest = 500000000000000000.0; var serializer = new fsSerializer(); fsData data; serializer.TrySerialize(valueToTest, out data).AssertSuccessWithoutWarnings(); Assert.AreEqual(valueToTest.ToString(System.Globalization.CultureInfo.InvariantCulture), fsJsonPrinter.PrettyJson(data)); double deserialized = 0f; serializer.TryDeserialize(data, ref deserialized).AssertSuccessWithoutWarnings(); Assert.AreEqual(valueToTest, deserialized); }
public void ImportLegacyCycle() { fsData data = fsData.CreateDictionary(); data.AsDictionary["SourceId"] = new fsData("0"); data.AsDictionary["Data"] = fsData.CreateDictionary(); data.AsDictionary["Data"].AsDictionary["Value"] = new fsData(3); data.AsDictionary["Data"].AsDictionary["Ref"] = fsData.CreateDictionary(); data.AsDictionary["Data"].AsDictionary["Ref"].AsDictionary["ReferenceId"] = new fsData("0"); UnityEngine.Debug.Log(fsJsonPrinter.PrettyJson(data)); Cycle c = null; var serializer = new fsSerializer(); Assert.IsTrue(serializer.TryDeserialize(data, ref c).Succeeded); Assert.AreEqual(3, c.Value); Assert.AreEqual(c, c.Ref); }
public void VerifyConversion() { MyConverter.DidDeserialize = false; MyConverter.DidSerialize = false; var serializer = new fsSerializer(); fsData result; serializer.TrySerialize(new MyModel(), out result); Assert.IsTrue(MyConverter.DidSerialize); Assert.IsFalse(MyConverter.DidDeserialize); MyConverter.DidSerialize = false; object resultObj = null; serializer.TryDeserialize(result, typeof (MyModel), ref resultObj); Assert.IsFalse(MyConverter.DidSerialize); Assert.IsTrue(MyConverter.DidDeserialize); }
public void VerifyPropertyConverter() { MyConverter.DidDeserialize = false; MyConverter.DidSerialize = false; var serializer = new fsSerializer(); // Make sure to set |a| to some value, otherwise we will short-circuit serialize it to null. fsData result; serializer.TrySerialize(new ModelWithPropertyConverter { a = 3 }, out result); Assert.IsTrue(MyConverter.DidSerialize); Assert.IsFalse(MyConverter.DidDeserialize); MyConverter.DidSerialize = false; object resultObj = null; serializer.TryDeserialize(result, typeof(ModelWithPropertyConverter), ref resultObj); Assert.IsFalse(MyConverter.DidSerialize); Assert.IsTrue(MyConverter.DidDeserialize); }
public void TestOptIn() { var model1 = new SimpleModel { Serialized0 = 1, Serialized1 = 1, Serialized2 = 1, NotSerialized0 = 1 }; fsData data; var serializer = new fsSerializer(); Assert.IsTrue(serializer.TrySerialize(model1, out data).Succeeded); SimpleModel model2 = null; Assert.IsTrue(serializer.TryDeserialize(data, ref model2).Succeeded); Debug.Log(fsJsonPrinter.PrettyJson(data)); Assert.AreEqual(model1.Serialized0, model2.Serialized0); Assert.AreEqual(model1.Serialized1, model2.Serialized1); Assert.AreEqual(model1.Serialized2, model2.Serialized2); Assert.AreEqual(0, model2.NotSerialized0); }
public void MultistageMigration() { var serializer = new fsSerializer(); var model_v1 = new VersionedModel_v1 { A = 3 }; fsData serialized; serializer.TrySerialize(model_v1, out serialized).AssertSuccessWithoutWarnings(); var model_v2 = new VersionedModel_v2(); serializer.TryDeserialize(serialized, ref model_v2).AssertSuccessWithoutWarnings(); Assert.AreEqual(model_v1.A, model_v2.B); }
public object Deserialize(Stream fileStream, Type type) { var bytes = new byte[fileStream.Length]; var count = fileStream.Read(bytes, 0, bytes.Length); var jsonString = System.Text.Encoding.UTF8.GetString(bytes, 0, count); var data = fsJsonParser.Parse(jsonString); var serializer = new fsSerializer(); object refObject = null; serializer.TryDeserialize(data, type, ref refObject); return refObject; }
//private static readonly FullSerializer.fsSerializer _serializer = new FullSerializer.fsSerializer(); public void Serialize(Stream fileStream, object graph) { fsData data; var serializer = new fsSerializer(); serializer.TrySerialize(graph, out data); var jsonString = fsJsonPrinter.CompressedJson(data); fileStream.Write(System.Text.Encoding.UTF8.GetBytes(jsonString), 0, jsonString.Length); }
public void MultistageMigration() { var serializer = new fsSerializer(); var model_v1 = new VersionedModel_v1 { A = 3 }; fsData serialized; Assert.IsTrue(serializer.TrySerialize(model_v1, out serialized).Succeeded); var model_v2 = new VersionedModel_v2(); Assert.IsTrue(serializer.TryDeserialize(serialized, ref model_v2).Succeeded); Assert.AreEqual(model_v1.A, model_v2.B); }