public void LargeArrayTest() { var ser = new BinarySerializer(); var data = new byte[65536 * sizeof(int) * 2]; ser.Deserialize<IntArray64K>(data); using (var ms = new MemoryStream(data)) { ser.Deserialize<IntArray64K>(ms); } }
private static void Main(string[] args) { var file = args[0]; using (var stream = new FileStream(file, FileMode.Open, FileAccess.Read)) { var serializer = new BinarySerializer(); serializer.MemberDeserialized += (sender, eventArgs) => Console.WriteLine(eventArgs.MemberName + " : " + eventArgs.Value); var iso = serializer.Deserialize<Iso9660.Iso9660>(stream); stream.Position = 0; var xmlSerializer = new XmlSerializer(typeof (Iso9660.Iso9660)); var outfilePath = Path.GetDirectoryName(file); var outfileName = Path.GetFileNameWithoutExtension(file) + ".xml"; var outfile = Path.Combine(outfilePath, outfileName); using (var xmlStream = new FileStream(outfile, FileMode.Create, FileAccess.Write)) { xmlSerializer.Serialize(xmlStream, iso); } Console.ReadKey(); } }
private void LoadState() { try { var ser = new BinarySerializer(); var stat = ser.Deserialize(StateFileName) as Dictionary<String, Object>; if (stat != null) { var w = (Int32)stat["Width"]; var h = (Int32)stat["Height"]; if (w > MinimumSize.Width) Width = w; if (h > MinimumSize.Height) Height = h; var x = (Int32)stat["X"]; var y = (Int32)stat["Y"]; if (x > 0 && y > 0) Location = new Point(x, y); foreach (var p in GetType().GetProperties()) { if (Attribute.IsDefined(p, typeof(StateItemAttribute))) p.SetValue(this, stat[p.Name], null); } } } catch { } }
public void Should_throw_exception_if_byte_array_is_null() { // Arrange var serializer = new BinarySerializer(); // Action var obj = serializer.Deserialize<Customer>(null); }
public void Deserialize_BytesProvided_ObjectDeserialized() { Tuple <int> value = new Tuple <int>(1); byte[] bytes = BinarySerializer.Serialize(value); Tuple <int> deserialized = BinarySerializer.Deserialize <Tuple <int> >(bytes); Assert.AreEqual(value.Item1, deserialized.Item1); }
public void Parse(byte[] data, Action callback = null) { var stream = new MemoryStream(data); var serializer = new BinarySerializer(); ZclPacket zclPacket = serializer.Deserialize <ZclPacket>(stream); Header = zclPacket.Header; Payload = zclPacket.Payload; }
private void OnTickDataReceive(byte[] msg) { var serializer = new BinarySerializer(); var marketTickData = serializer.Deserialize <MarketTickData>(msg); if (OnTickDataReceived != null) { OnTickDataReceived.Invoke(marketTickData); } }
public void Deserialize_OptionsNull_DefaultOptionsUsed() { Tuple <int> value = new Tuple <int>(1); BinarySerializer serializer = new BinarySerializer(); byte[] bytes = serializer.Serialize(value); Tuple <int> deserialized = serializer.Deserialize <Tuple <int> >(bytes); Assert.AreEqual(value.Item1, deserialized.Item1); }
void SessionFounder() { Random random = new Random(); while (sessionAwaitPlayers.Count > 1) { lock (sessionAwaitPlayers) { var p1 = sessionAwaitPlayers[random.Next(sessionAwaitPlayers.Count)]; sessionAwaitPlayers.Remove(p1); var p2 = sessionAwaitPlayers[random.Next(sessionAwaitPlayers.Count)]; sessionAwaitPlayers.Remove(p2); var session = new CardSessionServer.Session(new Position(8, 8), new Pair <Modifier, int>[] { new Pair <Modifier, int>(new DurableModifier(typeof(Destroyable), "DeltaHealth", new object[] { 10 }), 15), new Pair <Modifier, int>(new Modifier(typeof(Attacker), "DeltaAttack", new object[] { -10 }), 15) }); foreach (var f in p1.PlayerInfo.SharedPlayerInfo.CurrentSoliders) { var ser = Soliders.Find(q => q.Obj2 == f).Obj1; var o = BinarySerializer.Deserialize(BinarySerializer.Serialize(ser)); ((Container)o).SetOwner(p1.ControllerInfo); session.AddObject((Container)o); } foreach (var f in p1.PlayerInfo.SharedPlayerInfo.CurrentSpells) { var ser = Spells.Find(q => q.Obj2 == f).Obj1; var o = BinarySerializer.Deserialize(BinarySerializer.Serialize(ser)); ((Container)o).SetOwner(p1.ControllerInfo); session.AddObject((Container)o); } foreach (var f in p2.PlayerInfo.SharedPlayerInfo.CurrentSoliders) { var ser = Soliders.Find(q => q.Obj2 == f).Obj1; var o = BinarySerializer.Deserialize(BinarySerializer.Serialize(ser)); ((Container)o).SetOwner(p2.ControllerInfo); session.AddObject((Container)o); } foreach (var f in p2.PlayerInfo.SharedPlayerInfo.CurrentSpells) { var ser = Spells.Find(q => q.Obj2 == f).Obj1; var o = BinarySerializer.Deserialize(BinarySerializer.Serialize(ser)); ((Container)o).SetOwner(p2.ControllerInfo); session.AddObject((Container)o); } session.AddController(p1); session.AddController(p2); session.StartSession(); } } }
public void CerealTest() { var cereal = Cerealize(); using (var stream = new MemoryStream()) { _serializer.Serialize(stream, cereal); stream.Position = 0; Assert.Equal(BinarySerialization.Endianness.Big, _serializer.Endianness); //File.WriteAllBytes("c:\\temp\\out.bin", stream.ToArray()); var cereal2 = _serializer.Deserialize <Cereal>(stream); Assert.Equal("Cheeri", cereal2.Name); Assert.Equal(cereal.Manufacturer, cereal2.Manufacturer); Assert.Equal(cereal.NutritionalInformation.Fat, cereal2.NutritionalInformation.Fat); Assert.Equal(cereal.NutritionalInformation.Calories, cereal2.NutritionalInformation.Calories); Assert.Equal(cereal.NutritionalInformation.VitaminA, cereal2.NutritionalInformation.VitaminA); Assert.Equal(cereal.NutritionalInformation.VitaminB, cereal2.NutritionalInformation.VitaminB); Assert.True(cereal.NutritionalInformation.OtherNestedStuff.SequenceEqual( cereal2.NutritionalInformation.OtherNestedStuff)); Assert.True(cereal.NutritionalInformation.OtherNestedStuff2.SequenceEqual( cereal2.NutritionalInformation.OtherNestedStuff2)); Assert.True(cereal.NutritionalInformation.Toys.SequenceEqual(cereal2.NutritionalInformation.Toys)); Assert.IsAssignableFrom <Iron>(cereal.NutritionalInformation.Ingredients.MainIngredient); Assert.Equal(cereal2.DoubleField, cereal2.DoubleField); Assert.Contains("app", cereal2.OtherStuff); Assert.Contains("pea", cereal2.OtherStuff); Assert.Contains("ban", cereal2.OtherStuff); Assert.Equal(3, cereal2.OtherStuff.Count); Assert.Equal(cereal2.OtherStuff.Count, cereal2.OtherStuffCount); Assert.Equal(CerealShape.Circular, cereal2.Shape); Assert.Equal(CerealShape.Square, cereal2.DefinitelyNotTheShape); Assert.Null(cereal2.DontSerializeMe); Assert.Equal(cereal.SerializeMe, cereal2.SerializeMe); Assert.Equal(3, cereal2.ArrayOfInts.Length); Assert.Equal(1, cereal2.ArrayOfInts[0]); Assert.Equal(2, cereal2.ArrayOfInts[1]); Assert.Equal(3, cereal2.ArrayOfInts[2]); Assert.Equal(cereal.NutritionalInformation.WeirdOutlierLengthedField.Length / 2.0, cereal2.Outlier); Assert.True(cereal.ExplicitlyTerminatedList.SequenceEqual(cereal2.ExplicitlyTerminatedList)); Assert.True(cereal.ImplicitlyTerminatedList.SequenceEqual(cereal2.ImplicitlyTerminatedList)); var reader = new StreamReader(cereal2.Disclaimer); Assert.Equal(Disclaimer, reader.ReadToEnd()); } }
public void Test_Diff_Self_Ref() { TestSelfRefA a = new TestSelfRefA(); a.Self = a; byte[] data = BinarySerializer.Serialize(a); var b = BinarySerializer.Deserialize <DiffTestSelfRefA>(data); Assert.True(object.ReferenceEquals(b, b.Self)); }
public void Deserialize(BinaryReader reader) { ScriptHash = reader.ReadSerializable <UInt160>(); State = (Neo.VM.Types.Array)BinarySerializer.Deserialize( reader, ExecutionEngineLimits.Default, null); EventName = reader.ReadVarString(); InventoryHash = reader.ReadSerializable <UInt256>(); InventoryType = (InventoryType)reader.ReadByte(); }
protected T Deserialize <T>(Stream stream, object context = null) { #if TESTASYNC var task = Serializer.DeserializeAsync <T>(stream, context); task.ConfigureAwait(false); task.Wait(); return(task.Result); #else return(Serializer.Deserialize <T>(stream, context)); #endif }
public void ProtocolClassTest() { var bytes = new byte[] { 0xff, 0x0f }; BinarySerializer serializer = new BinarySerializer(); var protocol = serializer.Deserialize <ProtocolClass>(bytes); Assert.AreEqual(0x01, protocol.Header.ITEM1); Assert.AreEqual(0x7f, protocol.Header.ITEM2); Assert.AreEqual(0x01, protocol.Header.ITEM3); Assert.AreEqual(0x07, protocol.Header.ITEM4); }
static async Task Main(string[] args) { var serial = new BinarySerializer(); serial.Endianness = Endianness.Big; using (var file = File.Open(@"C:\Users\waelw.WAELS-PC\Desktop\farc\rslt_mik.farc", FileMode.Open)) { var archive = serial.Deserialize <FarcArchiveBin>(file); return; } }
public void Deserialize_OptionsBigEndian_ObjectDeserialized() { Tuple <int> value = new Tuple <int>(1); BinarySerializerOptions options = new BinarySerializerOptions(Endianness.BigEndian); byte[] bytes = BinarySerializer.Serialize(value, options); Tuple <int> deserialized = BinarySerializer.Deserialize <Tuple <int> >(bytes); Assert.AreEqual(value.Item1, deserialized.Item1); }
/// <summary> /// Deserialize body stream to object, This method is a part of <see cref="IMessageStream"/> implementation. /// </summary> /// <returns></returns> public object GetBody() { if (BodyStream == null) { return(null); } BodyStream.Position = 0; var ser = new BinarySerializer(); return(ser.Deserialize(BodyStream, true)); }
public void BinarySerializer_Deserialize_GivenValidReferenceType_ShouldReturnReferenceType() { var binarySerializer = new BinarySerializer(); var input = "test"; var serialized = binarySerializer.Serialize(input); var deserialized = binarySerializer.Deserialize <string>(serialized); Assert.IsNotNull(deserialized); Assert.AreEqual("test", deserialized); }
public void SerializeTest() { var testCommand = new TestCommand("originuserx", "originsystemx", Command.Actions.Add, "connectionidx", null, "clientidx") { TestProperty = "ZZZ" }; TestCommand actual = (TestCommand)BinarySerializer.Deserialize(BinarySerializer.Serialize(testCommand)); Assert.AreEqual(testCommand, actual); }
public void BinarySerializer_Deserialize_GivenValidValueType_ShouldReturnValueType() { var binarySerializer = new BinarySerializer(); var input = 123; var serialized = binarySerializer.Serialize(input); var deserialized = binarySerializer.Deserialize <int>(serialized); Assert.IsNotNull(deserialized); Assert.AreEqual(123, deserialized); }
protected T DeserializeBe <T>(Stream stream) { #if TESTASYNC var task = SerializerBe.DeserializeAsync <T>(stream); task.ConfigureAwait(false); task.Wait(); return(task.Result); #else return(SerializerBe.Deserialize <T>(stream)); #endif }
public void TestDeserialize() { var data = BinarySerializer.Serialize(((IInteroperable)origin).ToStackItem(null), 1024); var reader = new MemoryReader(data); HashIndexState dest = new HashIndexState(); ((IInteroperable)dest).FromStackItem(BinarySerializer.Deserialize(ref reader, ExecutionEngineLimits.Default, null)); dest.Hash.Should().Be(origin.Hash); dest.Index.Should().Be(origin.Index); }
public void TestPrematureStreamTermination() { var serializer = new BinarySerializer { Endianness = BinarySerialization.Endianness.Little }; var inBytes = new byte[] { 0x01, 0x00, 0x00, 0x00, 0x40, 0x34 }; using var stream = new MemoryStream(inBytes); var actualObj = serializer.Deserialize <LoadCarrierData>(stream); Assert.IsNull(actualObj); }
public void RoundTrip() { Type type = typeof(UserHeaderLabel); object obj1 = Activator.CreateInstance(type); string str1 = BinarySerializer.SerializeToString(obj1); object obj2 = BinarySerializer.Deserialize(type, str1); string str2 = BinarySerializer.SerializeToString(obj2); Console.WriteLine("'{0}'", str1); Console.WriteLine("'{0}'", str2); Assert.AreEqual(str1, str2); }
private static void SendRequest() { List <Detail> lst = new List <Detail> { new Detail("motor", 8, true), new Detail("transmission", 5, false), new Detail("brake", 4, false), new Detail("detail№4", 5, false), new Detail("detail№5", 7, false), }; for (int i = 0; i < lst.Count; i++) { if (!lst[i].have) { try { var ipHost = Dns.GetHostEntry("localhost"); var ipAddr = ipHost.AddressList[0]; var ipEndPoint = new IPEndPoint(ipAddr, Port); var sender = new Socket(ipAddr.AddressFamily, SocketType.Stream, ProtocolType.Tcp); sender.Connect(ipEndPoint); var detail = BinarySerializer <Detail> .Serialize(lst[i]); var lenDetail = BitConverter.GetBytes(detail.Length); sender.Send(lenDetail); sender.Send(detail); var inDetail = new byte[BitConverter.ToInt32(lenDetail, 0)]; sender.Receive(inDetail); Detail currentDetail = BinarySerializer <Detail> .Deserialize(inDetail); if (currentDetail.have) { lst[i].have = true; Console.WriteLine("Деталь " + lst[i].name + " Успешно доставлена"); installation(lst[i]); sender.Close(); } else { Console.WriteLine("Что-то пошло не так"); } } catch (Exception ex) { Console.WriteLine(ex); Console.ReadKey(); } } else { installation(lst[i]); } } }
public void Deserialize_SerializedInAnotherNamespaceWithoutCustomBincer_ThrowsInvalidCastException() { // (Binary is not very flexible unless a binder is used --> see next test) byte[] data = BinarySerializer.Serialize(_infoSaved); object target; Assert.Throws <InvalidCastException>( () => target = (PokerTell.Infrastructure.Tests.Serialization.OtherNameSpace.InfoToSaveClass) BinarySerializer.Deserialize(data)); }
public void TestMethodSimpleMessageSerialize() { BinarySerializer serializer = new BinarySerializer(new UnknowTestTypeResolver()); Communication.Common.GenericMessage msg = new Communication.Common.GenericMessage(); msg.Name = "Test"; byte[] result = serializer.Serialize(msg, null); IGenericMessage resultMsg = (IGenericMessage)serializer.Deserialize(result, null); Assert.Equal(msg.Name, resultMsg.Name); }
public void Deserialize(Stream s, Endianness endianness, BinarySerializationContext context) { var magic = DataStream.ReadUInt32(s); s.Position -= 4; var serial = new BinarySerializer(); switch (magic) { case 302121504: File = serial.Deserialize(s, typeof(DscFile)) as DscFile; break; case 0x43535650: serial.Endianness = Endianness.Big; File = serial.Deserialize(s, typeof(F2DscFile)) as F2DscFile; break; default: throw new Exception("invalid dsc file"); } }
public void Test() { BinarySerializer serializer = new BinarySerializer(); var message = new Tuple <string, string>("Name", "Cool"); string subject = serializer.GetObjectSubject(message); var array = serializer.Serialize(message); var messageDeserialized = serializer.Deserialize(subject, array.Array, array.Offset, array.Count); Assert.That(message.Equals(messageDeserialized)); }
public T ToObject <T>() where T : class { if (IsNull) { return(null); } using (var stream = new MemoryStream(bytes)) { var formatter = new BinarySerializer(); return(formatter.Deserialize(stream) as T); } }
public ActionResult Output(long queryId) { var context = new DataContext(false); var queryOutputRepos = new EFDataRepository <Domain.QueryOutput>(context); var output = queryOutputRepos.Query(o => o.QueryId == queryId).Last(); var dt = BinarySerializer.Deserialize <DataTable>(output.Data); return(View(new QueryOutputModel() { Data = dt })); }
public static ErrorInfo ToErrorInfo(this ApiException apiException) { ErrorInfo?result = null; if (apiException.Content != null) { if (apiException.ContentHeaders?.ContentType?.MediaType == BinarySerializer.MEDIA_TYPE) { if (apiException.ContentHeaders.ContentType.CharSet == BinarySerializer.DefaultEncoding.WebName) { result = BinaryConvert.Deserialize <ValidationResult>(apiException.Content); } else { var encoding = Encoding.GetEncoding(apiException.ContentHeaders.ContentType.CharSet); var serializer = new BinarySerializer(encoding); result = serializer.Deserialize <ValidationResult>(apiException.Content); } } else if (IsJson(apiException.ContentHeaders?.ContentType?.MediaType)) { var encoding = apiException.ContentHeaders?.ContentType?.CharSet != null? Encoding.GetEncoding(apiException.ContentHeaders.ContentType.CharSet) : Encoding.UTF8; var json = encoding.GetString(apiException.Content); if (apiException.StatusCode == System.Net.HttpStatusCode.BadRequest) { var apiValidation = System.Text.Json.JsonSerializer.Deserialize <FluentValidationResult>(json); result = new ValidationResult(apiValidation.title, apiValidation.errors) { ErrorCode = (int)apiException.StatusCode }; } else { result = System.Text.Json.JsonSerializer.Deserialize <ValidationResult>(json); } } } if (result == null) { result = new ErrorInfo(apiException.Message) { ErrorCode = (int)apiException.StatusCode }; } return(result); }
public StoreEngine(string fileName, bool createNew) { if (createNew) { _file = new FileStream(fileName, FileMode.CreateNew, FileAccess.ReadWrite); _header = new StoreHeader(); _header.VersionHi = 1; _header.VersionLo = 0; _header.MetaBegin = 1024; _header.MetaSize = 65536; byte[] buffer; byte[] dummy; buffer = MarshalHelper.StructToBuffer <StoreHeader>(_header); dummy = new byte[HeaderSize - buffer.Length]; _file.Write(buffer, 0, buffer.Length); _file.Write(dummy, 0, dummy.Length); _file.Flush(); _meta = new StoreMeta(); buffer = BinarySerializer.ToByteArray(_meta); dummy = new byte[MetaSize - buffer.Length]; _file.Write(buffer, 0, buffer.Length); _file.Write(dummy, 0, dummy.Length); _file.Flush(); _pageManager = StorePageManager.CreateNew(_file); } else { _file = new FileStream(fileName, FileMode.Open, FileAccess.ReadWrite); _header = MarshalHelper.StructFromStream <StoreHeader>(_file); _file.Seek(_header.MetaBegin, SeekOrigin.Begin); _meta = BinarySerializer.Deserialize <StoreMeta>(_file); _file.Seek(_header.DataBegin, SeekOrigin.Begin); _pageManager = StorePageManager.Open(_file); } // // read header // // read Meta // All Meta // Read PageIndex // Page Does'nt have cache }
private T Decrypt(Byte[] ciphertext, PinnedBuffer key, SymmetricAlgorithmSpecification algorithm) { using (var cipher = algorithm.ToCipher(RandomnessProvider)) { using (var pinnedCiphertext = new PinnedBuffer(ciphertext, false)) { using (var plaintext = cipher.Decrypt(pinnedCiphertext, key)) { return(BinarySerializer.Deserialize(plaintext)); } } } }
public static void TestBinarySerializing() { var bs = new BinarySerializer<Test<string>>(); using (var fileStream = File.Create(Path.Combine("save", "test.binx"))) { bs.Serialize(fileStream, Program.GetTest()); } using (var fileStream = File.OpenRead(Path.Combine("save", "test.binx"))) { var test = bs.Deserialize(fileStream); Debug.Assert(test.SequenceEqual(Program.GetTest())); } }
public void Can_serialize_object() { // Arrange var serializer = new BinarySerializer(); // Action var str = serializer.Serialize(new Customer { FullName = "Bunny", Title = "Mr" }); Customer obj = serializer.Deserialize<Customer>(str); // Asert Assert.AreEqual("Bunny", obj.FullName); Assert.AreEqual("Mr", obj.Title); }
private void LoadState() { try { var ser = new BinarySerializer(); var stat = ser.Deserialize(StateFileName) as Dictionary<String, Object>; if (stat != null) { foreach (var p in GetType().GetProperties()) { if (Attribute.IsDefined(p, typeof(StateItemAttribute))) p.SetValue(this, stat[p.Name], null); } } } catch { } }