public static Kernel.Config.FieldLayout Read(IBinaryReader o, Kernel.Config.FieldLayout d)
{
if (o.ReadBoolean() == false)
{
return(null);
}
int type = o.ReadInt32();
switch (type)
{
case 1:
d = FieldLayoutOfConstSerializer.Read(o, d as Kernel.Config.FieldLayoutOfConst);
break;
case 2:
d = FieldLayoutOfIntKeySerializer.Read(o, d as Kernel.Config.FieldLayoutOfIntKey);
break;
case 3:
d = FieldLayoutOfStringKeySerializer.Read(o, d as Kernel.Config.FieldLayoutOfStringKey);
break;
}
return(d);
}
public static Config.ConfSettingConst Read(IBinaryReader o, Config.ConfSettingConst d)
{
if (o.ReadBoolean() == false)
{
return(null);
}
if (d == null)
{
d = new Config.ConfSettingConst();
}
d.Locale = StringSerializer.Read(o, d.Locale as string) as string;
d.UseAA = o.ReadBoolean();
d.Version = StringSerializer.Read(o, d.Version as string) as string;
return(d);
}
/** <inheritDoc /> */
public void ReadBinary(IBinaryReader reader)
{
Byte = reader.ReadByte("Byte");
ByteArray = reader.ReadByteArray("ByteArray");
Char = reader.ReadChar("Char");
CharArray = reader.ReadCharArray("CharArray");
Short = reader.ReadShort("Short");
ShortArray = reader.ReadShortArray("ShortArray");
Int = reader.ReadInt("Int");
IntArray = reader.ReadIntArray("IntArray");
Long = reader.ReadLong("Long");
LongArray = reader.ReadLongArray("LongArray");
Boolean = reader.ReadBoolean("Boolean");
BooleanArray = reader.ReadBooleanArray("BooleanArray");
Float = reader.ReadFloat("Float");
FloatArray = reader.ReadFloatArray("FloatArray");
Double = reader.ReadDouble("Double");
DoubleArray = reader.ReadDoubleArray("DoubleArray");
Decimal = reader.ReadDecimal("Decimal");
DecimalArray = reader.ReadDecimalArray("DecimalArray");
Date = reader.ReadTimestamp("Date");
DateArray = reader.ReadTimestampArray("DateArray");
String = reader.ReadString("String");
StringArray = reader.ReadStringArray("StringArray");
Guid = reader.ReadObject <Guid>("Guid");
GuidArray = reader.ReadGuidArray("GuidArray");
}
public static System.Collections.Generic.Dictionary <string, Config.ConfAction> Read(IBinaryReader o, System.Collections.Generic.Dictionary <string, Config.ConfAction> d)
{
if (o.ReadBoolean() == false)
{
return(null);
}
int size = o.ReadInt32();
if (d == null)
{
d = new System.Collections.Generic.Dictionary <string, Config.ConfAction>(size);
}
else
{
d.Clear();
}
for (int i = 0; i < size; ++i)
{
string key = StringSerializer.Read(o, default(string) as string);
Config.ConfAction value = ConfActionSerializer.Read(o, default(Config.ConfAction) as Config.ConfAction);
d.Add(key, value);
}
return(d);
}
public static System.Collections.Generic.Dictionary <int, Config.ConfHero> Read(IBinaryReader o, System.Collections.Generic.Dictionary <int, Config.ConfHero> d)
{
if (o.ReadBoolean() == false)
{
return(null);
}
int size = o.ReadInt32();
if (d == null)
{
d = new System.Collections.Generic.Dictionary <int, Config.ConfHero>(size, Int32EqualityComparer.Instance);
}
else
{
d.Clear();
}
for (int i = 0; i < size; ++i)
{
int key = o.ReadInt32();
Config.ConfHero value = ConfHeroSerializer.Read(o, default(Config.ConfHero) as Config.ConfHero);
d.Add(key, value);
}
return(d);
}
/// <summary>
/// Deserialize the message (assumes magic & type already read in)
/// </summary>
/// <param name="cin">Cin.</param>
public override void Deserialize(IBinaryReader cin)
{
ObjectId = cin.ReadInt32();
if (cin.ReadBoolean())
{
ClassName = cin.ReadString();
}
}
public void ReadBinary(IBinaryReader reader)
{
Assert.AreEqual(1, reader.ReadByte("Byte"));
Assert.AreEqual(new byte[] { 1 }, reader.ReadByteArray("ByteArray"));
Assert.AreEqual('1', reader.ReadChar("Char"));
Assert.AreEqual(new[] { '1' }, reader.ReadCharArray("CharArray"));
Assert.AreEqual(1, reader.ReadShort("Short"));
Assert.AreEqual(new short[] { 1 }, reader.ReadShortArray("ShortArray"));
Assert.AreEqual(1, reader.ReadInt("Int"));
Assert.AreEqual(new[] { 1 }, reader.ReadIntArray("IntArray"));
Assert.AreEqual(1, reader.ReadLong("Long"));
Assert.AreEqual(new long[] { 1 }, reader.ReadLongArray("LongArray"));
Assert.AreEqual(true, reader.ReadBoolean("Boolean"));
Assert.AreEqual(new[] { true }, reader.ReadBooleanArray("BooleanArray"));
Assert.AreEqual(1, reader.ReadFloat("Float"));
Assert.AreEqual(new float[] { 1 }, reader.ReadFloatArray("FloatArray"));
Assert.AreEqual(1, reader.ReadDouble("Double"));
Assert.AreEqual(new double[] { 1 }, reader.ReadDoubleArray("DoubleArray"));
Assert.AreEqual(1, reader.ReadDecimal("Decimal"));
Assert.AreEqual(new decimal?[] { 1 }, reader.ReadDecimalArray("DecimalArray"));
Assert.AreEqual(Date, reader.ReadTimestamp("Timestamp"));
Assert.AreEqual(new DateTime?[] { Date }, reader.ReadTimestampArray("TimestampArray"));
Assert.AreEqual("1", reader.ReadString("String"));
Assert.AreEqual(new[] { "1" }, reader.ReadStringArray("StringArray"));
Assert.AreEqual(Guid, reader.ReadGuid("Guid"));
Assert.AreEqual(new Guid?[] { Guid }, reader.ReadGuidArray("GuidArray"));
Assert.AreEqual(MyEnum.Bar, reader.ReadEnum <MyEnum>("Enum"));
Assert.AreEqual(new[] { MyEnum.Bar }, reader.ReadEnumArray <MyEnum>("EnumArray"));
var raw = reader.GetRawReader();
Assert.AreEqual(1, raw.ReadByte());
Assert.AreEqual(new byte[] { 1 }, raw.ReadByteArray());
Assert.AreEqual('1', raw.ReadChar());
Assert.AreEqual(new[] { '1' }, raw.ReadCharArray());
Assert.AreEqual(1, raw.ReadShort());
Assert.AreEqual(new short[] { 1 }, raw.ReadShortArray());
Assert.AreEqual(1, raw.ReadInt());
Assert.AreEqual(new[] { 1 }, raw.ReadIntArray());
Assert.AreEqual(1, raw.ReadLong());
Assert.AreEqual(new long[] { 1 }, raw.ReadLongArray());
Assert.AreEqual(true, raw.ReadBoolean());
Assert.AreEqual(new[] { true }, raw.ReadBooleanArray());
Assert.AreEqual(1, raw.ReadFloat());
Assert.AreEqual(new float[] { 1 }, raw.ReadFloatArray());
Assert.AreEqual(1, raw.ReadDouble());
Assert.AreEqual(new double[] { 1 }, raw.ReadDoubleArray());
Assert.AreEqual(1, raw.ReadDecimal());
Assert.AreEqual(new decimal?[] { 1 }, raw.ReadDecimalArray());
Assert.AreEqual(Date, raw.ReadTimestamp());
Assert.AreEqual(new DateTime?[] { Date }, raw.ReadTimestampArray());
Assert.AreEqual("1", raw.ReadString());
Assert.AreEqual(new[] { "1" }, raw.ReadStringArray());
Assert.AreEqual(Guid, raw.ReadGuid());
Assert.AreEqual(new Guid?[] { Guid }, raw.ReadGuidArray());
Assert.AreEqual(MyEnum.Bar, raw.ReadEnum <MyEnum>());
Assert.AreEqual(new[] { MyEnum.Bar }, raw.ReadEnumArray <MyEnum>());
}
/** <inheritdoc /> */
public void ReadBinary(IBinaryReader reader)
{
ThrowOnRead = reader.ReadBoolean("ThrowOnRead");
if (ThrowOnRead)
{
throw new Exception("Expected exception in CustomExceptionBinarizable.ReadBinary");
}
}
public static string Read(IBinaryReader o, string d)
{
if (o.ReadBoolean() == false)
{
return(null);
}
d = o.ReadString();
return(d);
}
internal override void Deserialize(IBinaryReader reader, AttributeInfo attributeInfo)
{
base.Deserialize(reader, attributeInfo);
int count = reader.ReadInt32();
for (int i = 0; i < count; i++)
{
_values.Add(reader.ReadBoolean());
}
}
/** <inheritdoc /> */
public void ReadBinary(IBinaryReader reader)
{
Prop = reader.ReadString("Prop");
ThrowOnRead = reader.ReadBoolean("ThrowOnRead");
if (ThrowOnRead)
{
throw new Exception("Expected exception in TestBinarizableClass.ReadBinary");
}
}
public void ReadBinary(IBinaryReader reader)
{
Age = reader.ReadInt("age1");
Name = reader.ReadString("name");
OrganizationId = reader.ReadInt("OrganizationId");
Address = reader.ReadObject <Address>("Address");
Birthday = reader.ReadTimestamp("Birthday");
AliasTest = reader.ReadInt("AliasTest");
Bool = reader.ReadBoolean("Bool");
}
IResourceData ReadResourceData(List <UserResourceType> userTypes, int size)
{
uint code = ReadUInt32(reader);
switch ((ResourceTypeCode)code)
{
case ResourceTypeCode.Null: return(resourceDataCreator.CreateNull());
case ResourceTypeCode.String: return(resourceDataCreator.Create(reader.ReadString()));
case ResourceTypeCode.Boolean: return(resourceDataCreator.Create(reader.ReadBoolean()));
case ResourceTypeCode.Char: return(resourceDataCreator.Create((char)reader.ReadUInt16()));
case ResourceTypeCode.Byte: return(resourceDataCreator.Create(reader.ReadByte()));
case ResourceTypeCode.SByte: return(resourceDataCreator.Create(reader.ReadSByte()));
case ResourceTypeCode.Int16: return(resourceDataCreator.Create(reader.ReadInt16()));
case ResourceTypeCode.UInt16: return(resourceDataCreator.Create(reader.ReadUInt16()));
case ResourceTypeCode.Int32: return(resourceDataCreator.Create(reader.ReadInt32()));
case ResourceTypeCode.UInt32: return(resourceDataCreator.Create(reader.ReadUInt32()));
case ResourceTypeCode.Int64: return(resourceDataCreator.Create(reader.ReadInt64()));
case ResourceTypeCode.UInt64: return(resourceDataCreator.Create(reader.ReadUInt64()));
case ResourceTypeCode.Single: return(resourceDataCreator.Create(reader.ReadSingle()));
case ResourceTypeCode.Double: return(resourceDataCreator.Create(reader.ReadDouble()));
case ResourceTypeCode.Decimal: return(resourceDataCreator.Create(reader.ReadDecimal()));
case ResourceTypeCode.DateTime: return(resourceDataCreator.Create(new DateTime(reader.ReadInt64())));
case ResourceTypeCode.TimeSpan: return(resourceDataCreator.Create(new TimeSpan(reader.ReadInt64())));
case ResourceTypeCode.ByteArray: return(resourceDataCreator.Create(reader.ReadBytes(reader.ReadInt32())));
case ResourceTypeCode.Stream: return(resourceDataCreator.CreateStream(reader.ReadBytes(reader.ReadInt32())));
default:
int userTypeIndex = (int)(code - (uint)ResourceTypeCode.UserTypes);
if (userTypeIndex < 0 || userTypeIndex >= userTypes.Count)
{
throw new ResourceReaderException(string.Format("Invalid resource data code: {0}", code));
}
return(resourceDataCreator.CreateSerialized(reader.ReadBytes(size)));
}
}
/// <summary>
/// Deserializes a value from input stream
///
///
/// <exception cref="SerializationException"></exception>
///
/// </summary>
/// <param name="reader">The reader to use in order to get value</param>
/// <returns>Deserializable value</returns>
public bool Deserialize(IBinaryReader reader)
{
try
{
return(reader.ReadBoolean());
}
catch (Exception exception)
{
Guard.Throw <SerializationException>(SerializerMessanger.UNEXPECTED_DESERIALIZATION_EXCEPTION_MESSAGE,
exception);
}
return(false);
}
public static Config.ConfAction Read(IBinaryReader o, Config.ConfAction d)
{
if (o.ReadBoolean() == false)
{
return(null);
}
if (d == null)
{
d = new Config.ConfAction();
}
d.ActionLength = o.ReadSingle();
d.ActionName = StringSerializer.Read(o, d.ActionName as string) as string;
return(d);
}
public static Config.ConfHeroSkin Read(IBinaryReader o, Config.ConfHeroSkin d)
{
if (o.ReadBoolean() == false)
{
return(null);
}
if (d == null)
{
d = new Config.ConfHeroSkin();
}
d.Desc = StringSerializer.Read(o, d.Desc as string) as string;
d.HeroId = o.ReadInt32();
d.Id = o.ReadInt32();
return(d);
}
public static Kernel.Config.FieldLayoutOfConst Read(IBinaryReader o, Kernel.Config.FieldLayoutOfConst d)
{
if (o.ReadBoolean() == false)
{
return(null);
}
if (d == null)
{
d = new Kernel.Config.FieldLayoutOfConst();
}
d.Mode = (Kernel.Config.ConfigFieldInfo.Mode)o.ReadInt32();
d.Offset = o.ReadInt32();
d.Size = o.ReadInt32();
return(d);
}
public static Kernel.Config.ConfigHeader Read(IBinaryReader o, Kernel.Config.ConfigHeader d)
{
if (o.ReadBoolean() == false)
{
return(null);
}
if (d == null)
{
d = new Kernel.Config.ConfigHeader();
}
d.BodySize = o.ReadInt32();
d.Contents = ArrayPoli_FieldLayoutSerializer.Read(o, d.Contents as Kernel.Config.FieldLayout[]);
d.HeaderSize = o.ReadInt32();
return(d);
}
public static Kernel.Config.FieldLayoutOfIntKey Read(IBinaryReader o, Kernel.Config.FieldLayoutOfIntKey d)
{
if (o.ReadBoolean() == false)
{
return(null);
}
if (d == null)
{
d = new Kernel.Config.FieldLayoutOfIntKey();
}
d.ElemOffset = Dictionary_Int32_Int32Serializer.Read(o, d.ElemOffset as System.Collections.Generic.Dictionary <int, int>);
d.Mode = (Kernel.Config.ConfigFieldInfo.Mode)o.ReadInt32();
d.Offset = o.ReadInt32();
d.Size = o.ReadInt32();
return(d);
}
public static Kernel.Config.FieldLayout[] Read(IBinaryReader o, Kernel.Config.FieldLayout[] d)
{
if (o.ReadBoolean() == false)
{
return(null);
}
int size = o.ReadInt32();
if (d == null || d.Length != size)
{
d = new Kernel.Config.FieldLayout[size];
}
for (int i = 0; i < size; ++i)
{
d[i] = Poli_FieldLayoutSerializer.Read(o, d[i] as Kernel.Config.FieldLayout);
}
return(d);
}
public static Kernel.Engine.Color[] Read(IBinaryReader o, Kernel.Engine.Color[] d)
{
if (o.ReadBoolean() == false)
{
return(null);
}
int size = o.ReadInt32();
if (d == null || d.Length != size)
{
d = new Kernel.Engine.Color[size];
}
for (int i = 0; i < size; ++i)
{
d[i] = ColorSerializer.Read(o, d[i]);
}
return(d);
}
internal void Deserialize(IBinaryReader reader)
{
Clear();
AttributesInfoList attributes = new AttributesInfoList();
// read attributes list
attributes.Deserialize(reader);
int count = reader.ReadInt32();
bool is64Bit = reader.ReadBoolean();
MatchParseContext context = new MatchParseContext(attributes, is64Bit);
for (int i = 0; i < count; i++)
{
Match match = new Match();
match.Deserialize(reader, context);
Add(match);
}
}
public virtual void ReadBinary(IBinaryReader reader)
{
foreach (var c in DbColumns)
{
if (c.Type == typeof(string))
{
SetValue(c.Name, reader.ReadString(c.Name));
}
else if (c.Type == typeof(Guid))
{
Guid?tmp = reader.ReadGuid(c.Name);
if (tmp.HasValue)
{
SetValue(c.Name, tmp.Value);
}
SetValue(c.Name, tmp);
}
else if (c.Type == typeof(byte))
{
SetValue(c.Name, reader.ReadByte(c.Name));
}
else if (c.Type == typeof(bool))
{
SetValue(c.Name, reader.ReadBoolean(c.Name));
}
else if (c.Type == typeof(DateTime))
{
DateTime?tmp = reader.ReadTimestamp(c.Name);
if (tmp.HasValue)
{
SetValue(c.Name, tmp.Value);
}
SetValue(c.Name, tmp);
}
else
{
throw new Exception(string.Format("Unknow type {0}", c.Type));
}
}
}
public static Config.ConfHero Read(IBinaryReader o, Config.ConfHero d)
{
if (o.ReadBoolean() == false)
{
return(null);
}
if (d == null)
{
d = new Config.ConfHero();
}
d.Attack = o.ReadSingle();
d.AvailableColors = ArrayColorSerializer.Read(o, d.AvailableColors as Kernel.Engine.Color[]);
d.BirthDay = TimeUtil.CTimeToUtcDate(o.ReadInt64());
d.Desc = StringSerializer.Read(o, d.Desc as string) as string;
d.Hp = o.ReadSingle();
d.Id = o.ReadInt32();
d.Name = StringSerializer.Read(o, d.Name as string) as string;
d.PrefabPath = StringSerializer.Read(o, d.PrefabPath as string) as string;
d.Quality = (Config.QualificationType)o.ReadInt32();
return(d);
}
/// <summary>
/// Reads a boolean value from a specified <see cref="T:ExitGames.IO.IBinaryReader"/>
/// </summary>
/// <param name="binaryReader">The <see cref="T:ExitGames.IO.IBinaryReader"/> to read from.</param>
/// <param name="result">When this method returns true, contains the value that was read from the <see cref="T:ExitGames.IO.IBinaryReader"/>.</param>
/// <returns>True if the value was successfully read; otherwise false.</returns>
public static bool ReadBool(IBinaryReader binaryReader, out object result)
{
result = binaryReader.ReadBoolean();
return(true);
}
/// <summary>
/// Reads a <see cref="Boolean"/> at offset <paramref name="offset"/>
/// </summary>
/// <param name="reader">this</param>
/// <param name="offset">Offset</param>
/// <returns>The <see cref="Boolean"/></returns>
public static bool ReadBooleanAt(this IBinaryReader reader, long offset)
{
reader.Position = offset;
return(reader.ReadBoolean());
}
private IResourceData ReadResourceData(List <UserResourceType> userTypes, int size)
{
var code = ReadUInt32(reader);
switch ((ResourceTypeCode)code)
{
case ResourceTypeCode.Null: return(resourceDataCreator.CreateNull());
case ResourceTypeCode.String: return(resourceDataCreator.Create(reader.ReadString()));
case ResourceTypeCode.Boolean: return(resourceDataCreator.Create(reader.ReadBoolean()));
case ResourceTypeCode.Char: return(resourceDataCreator.Create((char)reader.ReadUInt16()));
case ResourceTypeCode.Byte: return(resourceDataCreator.Create(reader.ReadByte()));
case ResourceTypeCode.SByte: return(resourceDataCreator.Create(reader.ReadSByte()));
case ResourceTypeCode.Int16: return(resourceDataCreator.Create(reader.ReadInt16()));
case ResourceTypeCode.UInt16: return(resourceDataCreator.Create(reader.ReadUInt16()));
case ResourceTypeCode.Int32: return(resourceDataCreator.Create(reader.ReadInt32()));
case ResourceTypeCode.UInt32: return(resourceDataCreator.Create(reader.ReadUInt32()));
case ResourceTypeCode.Int64: return(resourceDataCreator.Create(reader.ReadInt64()));
case ResourceTypeCode.UInt64: return(resourceDataCreator.Create(reader.ReadUInt64()));
case ResourceTypeCode.Single: return(resourceDataCreator.Create(reader.ReadSingle()));
case ResourceTypeCode.Double: return(resourceDataCreator.Create(reader.ReadDouble()));
case ResourceTypeCode.Decimal: return(resourceDataCreator.Create(reader.ReadDecimal()));
case ResourceTypeCode.DateTime: return(resourceDataCreator.Create(DateTime.FromBinary(reader.ReadInt64())));
case ResourceTypeCode.TimeSpan: return(resourceDataCreator.Create(new TimeSpan(reader.ReadInt64())));
case ResourceTypeCode.ByteArray: return(resourceDataCreator.Create(reader.ReadBytes(reader.ReadInt32())));
case ResourceTypeCode.Stream: return(resourceDataCreator.CreateStream(reader.ReadBytes(reader.ReadInt32())));
default:
var userTypeIndex = (int)(code - (uint)ResourceTypeCode.UserTypes);
if (userTypeIndex < 0 || userTypeIndex >= userTypes.Count)
{
throw new ResourceReaderException(string.Format("Invalid resource data code: {0}", code));
}
var userType = userTypes[userTypeIndex];
var serializedData = reader.ReadBytes(size);
if (createResourceDataDelegate != null)
{
var res = createResourceDataDelegate(resourceDataCreator, userType, serializedData);
if (res != null)
{
return(res);
}
}
return(resourceDataCreator.CreateSerialized(serializedData, userType));
}
}
/** <inheritDoc /> */
public void ReadBinary(IBinaryReader reader)
{
Byte = reader.ReadByte("Byte");
ByteArray = reader.ReadByteArray("ByteArray");
Char = reader.ReadChar("Char");
CharArray = reader.ReadCharArray("CharArray");
Short = reader.ReadShort("Short");
ShortArray = reader.ReadShortArray("ShortArray");
Int = reader.ReadInt("Int");
IntArray = reader.ReadIntArray("IntArray");
Long = reader.ReadLong("Long");
LongArray = reader.ReadLongArray("LongArray");
Boolean = reader.ReadBoolean("Boolean");
BooleanArray = reader.ReadBooleanArray("BooleanArray");
Float = reader.ReadFloat("Float");
FloatArray = reader.ReadFloatArray("FloatArray");
Double = reader.ReadDouble("Double");
DoubleArray = reader.ReadDoubleArray("DoubleArray");
Decimal = reader.ReadDecimal("Decimal");
DecimalArray = reader.ReadDecimalArray("DecimalArray");
Date = reader.ReadTimestamp("Date");
DateArray = reader.ReadTimestampArray("DateArray");
String = reader.ReadString("String");
StringArray = reader.ReadStringArray("StringArray");
Guid = reader.ReadObject<Guid>("Guid");
GuidArray = reader.ReadGuidArray("GuidArray");
}
public void ReadBinary(IBinaryReader reader)
{
Assert.AreEqual(1, reader.ReadByte("Byte"));
Assert.AreEqual(new byte[] {1}, reader.ReadByteArray("ByteArray"));
Assert.AreEqual('1', reader.ReadChar("Char"));
Assert.AreEqual(new[] {'1'}, reader.ReadCharArray("CharArray"));
Assert.AreEqual(1, reader.ReadShort("Short"));
Assert.AreEqual(new short[] {1}, reader.ReadShortArray("ShortArray"));
Assert.AreEqual(1, reader.ReadInt("Int"));
Assert.AreEqual(new[] {1}, reader.ReadIntArray("IntArray"));
Assert.AreEqual(1, reader.ReadLong("Long"));
Assert.AreEqual(new long[] {1}, reader.ReadLongArray("LongArray"));
Assert.AreEqual(true, reader.ReadBoolean("Boolean"));
Assert.AreEqual(new[] {true}, reader.ReadBooleanArray("BooleanArray"));
Assert.AreEqual(1, reader.ReadFloat("Float"));
Assert.AreEqual(new float[] {1}, reader.ReadFloatArray("FloatArray"));
Assert.AreEqual(1, reader.ReadDouble("Double"));
Assert.AreEqual(new double[] {1}, reader.ReadDoubleArray("DoubleArray"));
Assert.AreEqual(1, reader.ReadDecimal("Decimal"));
Assert.AreEqual(new decimal?[] {1}, reader.ReadDecimalArray("DecimalArray"));
Assert.AreEqual(Date, reader.ReadTimestamp("Timestamp"));
Assert.AreEqual(new DateTime?[] {Date}, reader.ReadTimestampArray("TimestampArray"));
Assert.AreEqual("1", reader.ReadString("String"));
Assert.AreEqual(new[] {"1"}, reader.ReadStringArray("StringArray"));
Assert.AreEqual(Guid, reader.ReadGuid("Guid"));
Assert.AreEqual(new Guid?[] {Guid}, reader.ReadGuidArray("GuidArray"));
Assert.AreEqual(MyEnum.Bar, reader.ReadEnum<MyEnum>("Enum"));
Assert.AreEqual(new[] {MyEnum.Bar}, reader.ReadEnumArray<MyEnum>("EnumArray"));
var raw = reader.GetRawReader();
Assert.AreEqual(1, raw.ReadByte());
Assert.AreEqual(new byte[] { 1 }, raw.ReadByteArray());
Assert.AreEqual('1', raw.ReadChar());
Assert.AreEqual(new[] { '1' }, raw.ReadCharArray());
Assert.AreEqual(1, raw.ReadShort());
Assert.AreEqual(new short[] { 1 }, raw.ReadShortArray());
Assert.AreEqual(1, raw.ReadInt());
Assert.AreEqual(new[] { 1 }, raw.ReadIntArray());
Assert.AreEqual(1, raw.ReadLong());
Assert.AreEqual(new long[] { 1 }, raw.ReadLongArray());
Assert.AreEqual(true, raw.ReadBoolean());
Assert.AreEqual(new[] { true }, raw.ReadBooleanArray());
Assert.AreEqual(1, raw.ReadFloat());
Assert.AreEqual(new float[] { 1 }, raw.ReadFloatArray());
Assert.AreEqual(1, raw.ReadDouble());
Assert.AreEqual(new double[] { 1 }, raw.ReadDoubleArray());
Assert.AreEqual(1, raw.ReadDecimal());
Assert.AreEqual(new decimal?[] { 1 }, raw.ReadDecimalArray());
Assert.AreEqual(Date, raw.ReadTimestamp());
Assert.AreEqual(new DateTime?[] { Date }, raw.ReadTimestampArray());
Assert.AreEqual("1", raw.ReadString());
Assert.AreEqual(new[] { "1" }, raw.ReadStringArray());
Assert.AreEqual(Guid, raw.ReadGuid());
Assert.AreEqual(new Guid?[] { Guid }, raw.ReadGuidArray());
Assert.AreEqual(MyEnum.Bar, raw.ReadEnum<MyEnum>());
Assert.AreEqual(new[] { MyEnum.Bar }, raw.ReadEnumArray<MyEnum>());
}
/** <inheritdoc /> */
public void ReadBinary(IBinaryReader reader)
{
ThrowInit = reader.ReadBoolean("ThrowInit");
TestProperty = reader.ReadInt("TestProp");
}
internal override void Deserialize(IBinaryReader reader, AttributeInfo attributeInfo)
{
base.Deserialize(reader, attributeInfo);
_value = reader.ReadBoolean();
}
