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 { }
}
