public List <Workout> GetAllWorkouts(string tablename) { if (!PersistentDataProvider.Current.allTableNames.Contains(tablename)) { MessageBox.Show($"Table {tablename} not found"); } try { SerializerService ser = new SerializerService(); using var con = new SQLiteConnection("Data Source=" + directory + databaseName); con.Open(); string stm = "SELECT * FROM " + tablename; using var cmd = new SQLiteCommand(stm, con); using SQLiteDataReader rdr = cmd.ExecuteReader(); List <Workout> result = new List <Workout>(); while (rdr.Read()) { Workout t = new Workout(); t.Date = Convert.ToDateTime(rdr.GetString(1)); t.ExerciseList = ser.Deserialize <ObservableCollection <ExerciseEntry> >(rdr.GetString(0)); result.Add(t); } return(result); } catch (System.Data.SQLite.SQLiteException) { MessageBox.Show("Table " + tablename + " not found!"); return(null); } }
protected override void Serialize(T file, Stream stream) { using TextWriter writer = new StreamWriter(stream); string json = SerializerService.Serialize(file); writer.Write(json); }
private static void TextEncodingRoundrip(Encoding encoding) { using var stream = new MemoryStream(); using (var writer = new ObjectWriter(stream, leaveOpen: true)) { SerializerService.WriteTo(encoding, writer, CancellationToken.None); } stream.Position = 0; using var reader = ObjectReader.TryGetReader(stream); Assert.NotNull(reader); var actualEncoding = (Encoding)SerializerService.ReadEncodingFrom(reader, CancellationToken.None).Clone(); var expectedEncoding = (Encoding)encoding.Clone(); // set the fallbacks to the same instance so that equality comparison does not take them into account: actualEncoding.EncoderFallback = EncoderFallback.ExceptionFallback; actualEncoding.DecoderFallback = DecoderFallback.ExceptionFallback; expectedEncoding.EncoderFallback = EncoderFallback.ExceptionFallback; expectedEncoding.DecoderFallback = DecoderFallback.ExceptionFallback; Assert.Equal(expectedEncoding.GetPreamble(), actualEncoding.GetPreamble()); Assert.Equal(expectedEncoding.CodePage, actualEncoding.CodePage); Assert.Equal(expectedEncoding.WebName, actualEncoding.WebName); Assert.Equal(expectedEncoding, actualEncoding); }
private static INetworkSerializationService BuildClientSerializer() { SerializerService serializer = new SerializerService(); GamePacketMetadataMarker .SerializableTypes .Concat(GamePacketMetadataMarker.GamePacketPayloadTypes) .Where(t => t != typeof(SMSG_CONTACT_LIST_PAYLOAD) && t != typeof(SMSG_SPELL_GO_Payload)) .ToList() .ForEach(t => serializer.RegisterType(t)); //Register all unimplemented stubs foreach (Type t in GamePacketStubMetadataMarker.GamePacketPayloadStubTypes.Where(t => GamePacketMetadataMarker.UnimplementedOperationCodes.Value.Contains(t.GetCustomAttribute <GamePayloadOperationCodeAttribute>().OperationCode))) { serializer.RegisterType(t); } //Also the header types serializer.RegisterType <ServerPacketHeader>(); serializer.RegisterType <OutgoingClientPacketHeader>(); serializer.RegisterType <SMSG_CONTACT_LIST_DTO_PROXY>(); serializer.RegisterType <SMSG_SPELL_GO_DTO_PROXY>(); serializer.Compile(); return(new FreecraftCoreGladNetSerializerAdapter(serializer)); }
public PropSheet(string fileName) { try { this.rows = new Dictionary <uint, Prop>(); uint index = 0; Dictionary <string, string> stringRows = SerializerService.DeserializeFile <Dictionary <string, string> >(fileName); foreach ((string key, string value) in stringRows) { string[] parts = value.Split(';', StringSplitOptions.RemoveEmptyEntries); (ushort modelSet, ushort modelBase, ushort modelVariant) = IItemConverter.SplitString(key); Prop prop = new Prop(); prop.Name = parts[0].Trim(); if (parts.Length == 2) { prop.Description = parts[1].Trim(); } prop.ModelBase = modelBase; prop.ModelVariant = modelVariant; prop.ModelSet = modelSet; this.rows.Add(index, prop); index++; } } catch (Exception ex) { throw new Exception($"Failed to load json data: {fileName}", ex); } }
public void Test_Can_Serialize_Type_With_Complex_Array_Ignored_And_SendSize_Array_Succedding(int[] intArray) { //arrange SerializerService serializer = new SerializerService(); serializer.RegisterType <TestComplexOptionalFieldWithDisable>(); serializer.Compile(); //act byte[] bytes = serializer.Serialize(new TestComplexOptionalFieldWithDisable(intArray)); TestComplexOptionalFieldWithDisable deserializerData = serializer.Deserialize <TestComplexOptionalFieldWithDisable>(bytes); //assert Assert.NotNull(bytes); Assert.True(bytes.Length != 0); //Check it's sizeof the element * length + the sendsize Assert.True(bytes.Length == intArray.Length * sizeof(int) + sizeof(int)); Assert.NotNull(deserializerData); for (int i = 0; i < intArray.Length; i++) { Assert.AreEqual(intArray[i], deserializerData.TestInts[i]); } }
public void Test_Can_Serialize_All_Concrete_Payloads(Type t) { //arrange SerializerService serializer = new SerializerService(); //Abstracts can't be created if (t.IsAbstract) //if it's unknown then it's probably default and thus unwritable { return; } TPayloadBaseType payload = (TPayloadBaseType)Activator.CreateInstance(t, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.CreateInstance, null, new object[0], null); //act Span <byte> buffer = new Span <byte>(new byte[62000]); int offset = 0; //We have to suppress these exceptions because some payloads have complex object graphs and //need more than default initialization to be serializable try { serializer.Write(payload, buffer, ref offset); //assert Assert.True(offset != 0); } catch (ArgumentNullException e) { } catch (Exception e) { Assert.Warn($"Type: {t.Name} may not be serializable. It's not determinable. This can happen if it has class/complex fields and should be ignored. \n\nException: {e.Message}"); } }
public override void Run() { string propsJson = File.ReadAllText(propsFilePath); Dictionary <string, string> props = SerializerService.Deserialize <Dictionary <string, string> >(propsJson); string equipmentJson = File.ReadAllText(equipmentFilePath); List <Equipment> equipment = SerializerService.Deserialize <List <Equipment> >(equipmentJson); foreach ((string key, string value) in props) { string[] parts = value.Split(';', StringSplitOptions.RemoveEmptyEntries); string name = parts[0].Trim(); string?desc = null; if (parts.Length == 2) { desc = parts[1].Trim(); } Equipment eq = new(); eq.Name = name; eq.Description = desc; eq.Id = key; eq.Slot = Equipment.FitsSlots.Weapons; equipment.Add(eq); } ///equipment.Sort((a, b) => a.Id.CompareTo(b.Id)); string json = SerializerService.Serialize(equipment); File.WriteAllText(equipmentFilePath, json); }
public static void Test_Can_Serializer_Then_Deserialize_Most_Complex_Test_Possible() { //arrange SerializerService serializer = new SerializerService(); TestEnum[] arrayOne = new TestEnum[] { TestEnum.Zero, TestEnum.One }; TestEnum[] arrayTwo = new TestEnum[3] { TestEnum.Two, TestEnum.One, TestEnum.Zero }; BasicWireDataContract WireDataContractNested = new BasicWireDataContract(8); //act serializer.RegisterType <VeryComplexType>(); serializer.Compile(); byte[] bytes = serializer.Serialize(new VeryComplexType(6, WireDataContractNested, arrayOne, arrayTwo)); Assert.NotNull(bytes); Assert.False(bytes.Length == 0); VeryComplexType message = serializer.Deserialize <VeryComplexType>(bytes); //assert Assert.NotNull(message); //check fields for (int i = 0; i < arrayOne.Length; i++) { Assert.AreEqual(arrayOne[i], message.testEnums[i], $"Failed for index {i}."); } for (int i = 0; i < arrayTwo.Length; i++) { Assert.AreEqual(arrayTwo[i], message.testEnumsAnother[i], $"Failed for index {i}."); } }
private async Task Run() { if (this.isRunning) { return; } this.isRunning = true; Random rnd = new Random(); while (this.IsVisible) { List <Entry> entries = SerializerService.DeserializeFile <List <Entry> >("Data/Images.json"); while (this.IsVisible && entries.Count > 0) { int index = rnd.Next(entries.Count); await this.Show(entries[index], rnd); entries.RemoveAt(index); await Task.Delay(5000); } } this.isRunning = false; }
public static void Test_Can_Deserialize_SeperatedCollection_Type() { Assert.Warn("TODO You must fix and reimplement seperated collection. It's not working fully as intended."); return; //arrange SerializerService serializer = new SerializerService(); serializer.RegisterType <TestSeperatedCollection>(); serializer.Compile(); //act byte[] bytes = serializer.Serialize(new TestSeperatedCollection("Hello meep56!", 123456, new[] { 55523, 90, 2445, 63432, 6969 })); TestSeperatedCollection deserialized = serializer.Deserialize <TestSeperatedCollection>(bytes); //assert Assert.NotNull(deserialized); Assert.NotNull(deserialized.IntsChars); Assert.AreEqual(5, deserialized.Size, "Expected the size to be the original collection size"); Assert.AreEqual(5, deserialized.IntsChars.Length, $"Expected the length of the collection to be the original length"); Assert.AreEqual("Hello meep56!", deserialized.TestString); Assert.AreEqual(123456, deserialized.AnotherValue); }
public static void Test_Can_Register_SeperatedCollection_Type() { //arrange SerializerService serializer = new SerializerService(); Assert.DoesNotThrow(() => serializer.RegisterType <TestSeperatedCollection>()); }
public static void Test_Can_Regiser_Multilevel_Polymorphic_Type() { //arrange SerializerService serializer = new SerializerService(); Assert.DoesNotThrow(() => serializer.RegisterType <TestBaseClass>()); }
protected override T Deserialize(Stream stream) { using TextReader reader = new StreamReader(stream); string json = reader.ReadToEnd(); return(SerializerService.Deserialize <T>(json)); }
private static void NewMethod(Stopwatch watch, SerializerService serializer) { watch.Start(); serializer.RegisterType <PlayerCharacterDataModel>(); serializer.Compile(); watch.Stop(); }
public void Test_Can_Serialize_Then_Deserializer_AuthSessionChallengeEvent_Vanilla_Payload() { //arrange SerializerService otherService = new SerializerService(); otherService.RegisterType <SessionAuthChallengeEvent>(); SerializerService serializer = new SerializerService(); serializer.RegisterType <SessionAuthChallengeEvent_Vanilla>(); serializer.Compile(); otherService.Compile(); SerializerService lastserializer = new SerializerService(); lastserializer.RegisterType <SessionAuthChallengeEvent_Vanilla>(); lastserializer.Compile(); //act byte[] bytes = lastserializer.Serialize(new SessionAuthChallengeEvent_Vanilla(new SessionAuthChallengeEventData(55, new byte[32]))); SessionAuthChallengeEvent_Vanilla payload = serializer.Deserialize <SessionAuthChallengeEvent_Vanilla>(bytes); //assert Assert.NotNull(bytes); }
public static void SaveTemplate(SkeletonFile skeleton) { string name = "Generated_"; if (skeleton.ModelTypes != null) { for (int i = 0; i < skeleton.ModelTypes.Count; i++) { if (i > 0) { name += "_"; } name += skeleton.ModelTypes[i]; } } if (skeleton.Race != null) { name += "_" + skeleton.Race; } if (skeleton.Age != null) { name += "_" + skeleton.Age; } SerializerService.SerializeFile("Data/Skeletons/" + name + ".json", skeleton); BoneNameFiles.Add(skeleton); }
public void Test_Patching_Payload_Deserializes_To_Correct_Values() { //arrange SerializerService serializer = new SerializerService(); serializer.RegisterPolymorphicSerializer <PSOBBPatchPacketPayloadClient, PSOBBPatchPacketPayloadClient_AutoGeneratedTemplateSerializerStrategy>(); serializer.RegisterPolymorphicSerializer <PSOBBPatchPacketPayloadServer, PSOBBPatchPacketPayloadServer_AutoGeneratedTemplateSerializerStrategy>(); Span <byte> buffer = new Span <byte>(new byte[500]); PatchingWelcomePayload payload = new PatchingWelcomePayload("Patch Server. Copyright SonicTeam, LTD. 2001", 506953426, 214005626); //assert int offset = 0; serializer.Write(payload, buffer, ref offset); int size = offset; offset = 0; PatchingWelcomePayload deserializedPayload = (PatchingWelcomePayload)serializer.Read <PSOBBPatchPacketPayloadServer>(buffer.Slice(0, size), ref offset); //assert Assert.AreEqual(payload.PatchCopyrightMessage, deserializedPayload.PatchCopyrightMessage); Assert.AreEqual(payload.ClientVector, deserializedPayload.ClientVector); Assert.AreEqual(payload.ServerVector, deserializedPayload.ServerVector); Assert.AreEqual(0x99, deserializedPayload.OperationCode); }
private SkeletonFile Load(string path) { SkeletonFile template = SerializerService.DeserializeFile <SkeletonFile>(path); BoneNameFiles.Add(template); if (template.BasedOn != null) { SkeletonFile baseTemplate = this.Load("Data/Skeletons/" + template.BasedOn); template.CopyBaseValues(baseTemplate); } // Validate that all bone names are unique if (template.BoneNames != null) { HashSet <string> boneNames = new HashSet <string>(); foreach ((string orignal, string name) in template.BoneNames) { if (boneNames.Contains(name)) { throw new Exception($"Duplicate bone name: {name} in skeleton file: {path}"); } boneNames.Add(name); } } return(template); }
public static void Test_Can_Register_Child_of_Expected_Runtime_BaseType() { //arrange SerializerService serivce = new SerializerService(); Assert.DoesNotThrow(() => serivce.RegisterType <ChildType>()); }
public void Test_Can_Deserialize_ReadToEnd_String_Type() { //arrange SerializerService serializer = new SerializerService(); serializer.RegisterType <ReadToEndStringType>(); serializer.Compile(); //act byte[] bytes = serializer.Serialize(new ReadToEndStringType(5, TestStrings)); ReadToEndStringType deserializer = serializer.Deserialize <ReadToEndStringType>(bytes); Assert.NotNull(deserializer); Assert.IsNotEmpty(deserializer.Strings); Assert.AreEqual(5, deserializer.I); Assert.AreEqual(TestStrings.Length, deserializer.Strings.Length); //Check that there are null terminators Assert.AreEqual(TestStrings.Length, bytes.Skip(4).Count(b => b == 0)); for (int i = 0; i < TestStrings.Length; i++) { Assert.AreEqual(TestStrings[i], deserializer.Strings[i]); } }
private void Generic_CanDeserialize_CaptureTest <TBasePayloadType>(PacketCaptureTestEntry entry) where TBasePayloadType : IPacketPayload, IOperationCodeable { //arrange SerializerService serializer = Serializer; TBasePayloadType payload; //act try { payload = serializer.Deserialize <TBasePayloadType>(entry.BinaryData); if (payload is IUnknownPayloadType) { Assert.Warn($"Encountered unimplemented OpCode: 0x{payload.OperationCode:X}."); return; } } catch (Exception e) { Assert.Fail($"Critical failure. Cannot deserialize File: {entry.FileName} FileSize: {entry.BinaryData.Length} \n\n Exception: {e.Message} Stack: {e.StackTrace}"); return; } finally { } //assert Assert.NotNull(payload, $"Resulting capture capture deserialization attempt null for File: {entry.FileName}"); //We should have deserialized it. We want to make sure the opcode matches Assert.AreEqual(entry.OpCode, payload.OperationCode, $"Mismatched {nameof(payload.OperationCode)} on packet capture File: {entry.FileName}. Expected: {entry.OpCode} Was: {payload.OperationCode}"); }
public async Task Search() { WebRequest req = WebRequest.Create(SearchUrl + "&json=true"); WebResponse response = await req.GetResponseAsync(); using StreamReader reader = new StreamReader(response.GetResponseStream()); string json = reader.ReadToEnd(); SearchResultWrapper result = SerializerService.Deserialize <SearchResultWrapper>(json); if (!result.Success) { throw new Exception("Did not succede"); } Application.Current.Dispatcher.Invoke(() => { this.PopularToday.Clear(); if (result.SearchResults != null) { foreach (SearchResult searchResult in result.SearchResults) { this.PopularToday.Add(searchResult); } } }); }
public override async Task Initialize() { await base.Initialize(); if (!File.Exists(settingsPath)) { this.FirstTimeUser = true; this.Settings = new Settings(); Save(); } else { this.FirstTimeUser = false; try { string json = File.ReadAllText(settingsPath); this.Settings = SerializerService.Deserialize <Settings>(json); } catch (Exception) { await GenericDialog.Show("Failed to load Settings. Your settings have been reset.", "Error", MessageBoxButton.OK); this.Settings = new Settings(); Save(); } } this.Settings.PropertyChanged += this.OnSettingsChanged; this.OnSettingsChanged(null, new PropertyChangedEventArgs(null)); }
public void Test_Can_Register_All_Concrete_Models(Type t) { //We have to do abit of a hack if it's a generic type //We need a closed generic. DBCs usually are generic if they have strings if (t.IsGenericTypeDefinition) { //TODO: Handle contraints better, causes throw and this is a hack to catch //TODO: Support closing multiple type arg generics //Assuming this can work, assuming all 1 generic param for now. try { t = t.MakeGenericType(typeof(StringDBCReference)); } catch (Exception e) { Assert.Inconclusive($"Cannot test Type: {t.Name} because closed generic could not be made. Maybe caused by constaints. Error: {e.Message}"); } } //arrange SerializerService serializer = new SerializerService(); //assert Assert.DoesNotThrow(() => serializer.RegisterType(t)); Assert.DoesNotThrow(() => serializer.Compile()); Assert.True(serializer.isTypeRegistered(t), $"Failed to register Type: {t.Name}"); }
public void Can_Deserialize_Captures_To_GamePacketPayloads(PacketCaptureTestEntry entry) { Console.WriteLine($"Entry Decompressed/Real Size: {entry.BinaryData.Length} OpCode: {entry.OpCode}"); //arrange SerializerService serializer = Serializer; GamePacketPayload payload; Stopwatch stopwatch = new Stopwatch(); stopwatch.Start(); //act try { payload = serializer.Read <GamePacketPayload>(new Span <byte>(entry.BinaryData), 0); } catch (Exception e) { Assert.Fail($"Critical failure. Cannot deserialize File: {entry.FileName} FileSize: {entry.BinaryData.Length} \n\n Exception: {e.Message} Stack: {e.StackTrace}"); return; } finally { stopwatch.Stop(); } Console.WriteLine($"Serialization time in ms: {stopwatch.ElapsedMilliseconds}"); //assert Assert.NotNull(payload, $"Resulting capture capture deserialization attempt null for File: {entry.FileName}"); //We should have deserialized it. We want to make sure the opcode matches Assert.AreEqual(entry.OpCode, payload.OperationCode, $"Mismatched {nameof(NetworkOperationCode)} on packet capture File: {entry.FileName}. Expected: {entry.OpCode} Was: {payload.OperationCode}"); }
public void Test_Can_Link_PatchingUpOneDir() { //arrange SerializerService serializer = new SerializerService(); serializer.Link <PatchingInformationPayload, PSOBBPatchPacketPayloadServer>(); serializer.Compile(); }
public void Test_Can_Register_PatchingLoginRequestPayload() { //arrange SerializerService serializer = new SerializerService(); serializer.RegisterType(typeof(PatchingLoginRequestPayload)); serializer.Compile(); }
public static void Test_Can_Register_ReverseFixedByteArray_Type() { //arrange SerializerService serializer = new SerializerService(); //assert Assert.DoesNotThrow(() => serializer.RegisterType <ReverseArrayByteTest>()); }
public static byte[] MemoryCompress(object obj, AcedCompressionLevel level) { byte[] objs = SerializerService.Serialize(obj); AcedDeflator instance = new AcedDeflator(); byte[] bytes = instance.Compress(objs, 0, objs.Length, level, 0, 0); return(bytes); }
public void Cleanup() { _service = null; }
public void Init() { _service = new SerializerService (); }