public void Read(System.IO.BinaryReader reader)
{
this.IsNull = false;
catVersion = reader.ReadInt32();
listPrice = reader.ReadDecimal();
discountPlan = reader.ReadInt32();
}
private static string FormatAs(byte[] bytes, params string[] types)
{
var formatted = new List<string>();
using (var reader = new BinaryReader(new MemoryStream(bytes)))
{
foreach (var type in types)
{
switch (type.ToLower())
{
case "int32":
formatted.Add(reader.ReadInt32().ToString("0000000000"));
break;
case "single":
formatted.Add(reader.ReadSingle().ToString());
break;
case "double":
formatted.Add(reader.ReadDouble().ToString());
break;
case "decimal":
formatted.Add(reader.ReadDecimal().ToString());
break;
default:
throw new Exception();
}
}
}
return String.Join(" ", formatted);
}
public override object Read(BinaryReader buffer, Type resultType, TypeDescription typeDescriptor, byte code, BinaryJSONReader binaryJsonReader)
{
switch (code)
{
case BinaryValue.BYTE:
return Convert.ChangeType(buffer.ReadByte(), resultType);
case BinaryValue.SBYTE:
return Convert.ChangeType(buffer.ReadSByte(), resultType);
case BinaryValue.INT16:
return Convert.ChangeType(buffer.ReadInt16(), resultType);
case BinaryValue.UINT16:
return Convert.ChangeType(buffer.ReadUInt16(), resultType);
case BinaryValue.INT32:
return Convert.ChangeType(buffer.ReadInt32(), resultType);
case BinaryValue.UINT32:
return Convert.ChangeType(buffer.ReadUInt32(), resultType);
case BinaryValue.INT64:
return Convert.ChangeType(buffer.ReadInt64(), resultType);
case BinaryValue.UINT64:
return Convert.ChangeType(buffer.ReadUInt64(), resultType);
case BinaryValue.FLOAT:
return Convert.ChangeType(buffer.ReadSingle(), resultType);
case BinaryValue.BOOLEAN:
return Convert.ChangeType(buffer.ReadBoolean(), resultType);
case BinaryValue.DOUBLE:
return Convert.ChangeType(buffer.ReadDouble(), resultType);
case BinaryValue.DECIMAL:
return Convert.ChangeType(buffer.ReadDecimal(), resultType);
case BinaryValue.CHAR:
return Convert.ChangeType(buffer.ReadChar(), resultType);
}
return null;
}
public static List<Product> GetProducts()
{
// if the directory doesn't exist, create it
if (!Directory.Exists(dir))
Directory.CreateDirectory(dir);
// create the object for the input stream for a binary file
BinaryReader binaryIn =
new BinaryReader(
new FileStream(path, FileMode.OpenOrCreate, FileAccess.Read));
// create the array list
List<Product> products = new List<Product>();
// read the data from the file and store it in the List<Product>
while (binaryIn.PeekChar() != -1)
{
Product product = new Product();
product.Code = binaryIn.ReadString();
product.Description = binaryIn.ReadString();
product.Price = binaryIn.ReadDecimal();
products.Add(product);
}
// close the input stream for the binary file
binaryIn.Close();
return products;
}
private void ValidateDisposedExceptions(BinaryReader binaryReader)
{
byte[] byteBuffer = new byte[10];
char[] charBuffer = new char[10];
Assert.Throws<ObjectDisposedException>(() => binaryReader.PeekChar());
Assert.Throws<ObjectDisposedException>(() => binaryReader.Read());
Assert.Throws<ObjectDisposedException>(() => binaryReader.Read(byteBuffer, 0, 1));
Assert.Throws<ObjectDisposedException>(() => binaryReader.Read(charBuffer, 0, 1));
Assert.Throws<ObjectDisposedException>(() => binaryReader.ReadBoolean());
Assert.Throws<ObjectDisposedException>(() => binaryReader.ReadByte());
Assert.Throws<ObjectDisposedException>(() => binaryReader.ReadBytes(1));
Assert.Throws<ObjectDisposedException>(() => binaryReader.ReadChar());
Assert.Throws<ObjectDisposedException>(() => binaryReader.ReadChars(1));
Assert.Throws<ObjectDisposedException>(() => binaryReader.ReadDecimal());
Assert.Throws<ObjectDisposedException>(() => binaryReader.ReadDouble());
Assert.Throws<ObjectDisposedException>(() => binaryReader.ReadInt16());
Assert.Throws<ObjectDisposedException>(() => binaryReader.ReadInt32());
Assert.Throws<ObjectDisposedException>(() => binaryReader.ReadInt64());
Assert.Throws<ObjectDisposedException>(() => binaryReader.ReadSByte());
Assert.Throws<ObjectDisposedException>(() => binaryReader.ReadSingle());
Assert.Throws<ObjectDisposedException>(() => binaryReader.ReadString());
Assert.Throws<ObjectDisposedException>(() => binaryReader.ReadUInt16());
Assert.Throws<ObjectDisposedException>(() => binaryReader.ReadUInt32());
Assert.Throws<ObjectDisposedException>(() => binaryReader.ReadUInt64());
}
private static bool Load(BinaryReader reader, out Value value)
{
List<KeyValuePair<Value, Value>> array;
Value arrayKey;
Value arrayValue;
int count;
ValueContent type;
type = (ValueContent)reader.ReadInt32 ();
switch (type)
{
case ValueContent.Boolean:
value = reader.ReadBoolean () ? BooleanValue.True : BooleanValue.False;
break;
case ValueContent.Map:
count = reader.ReadInt32 ();
array = new List<KeyValuePair<Value, Value>> (count);
while (count-- > 0)
{
if (!ValueAccessor.Load (reader, out arrayKey) || !ValueAccessor.Load (reader, out arrayValue))
{
value = null;
return false;
}
array.Add (new KeyValuePair<Value, Value> (arrayKey, arrayValue));
}
value = array;
break;
case ValueContent.Number:
value = reader.ReadDecimal ();
break;
case ValueContent.String:
value = reader.ReadString ();
break;
case ValueContent.Void:
value = VoidValue.Instance;
break;
default:
value = null;
return false;
}
return true;
}
private static object ReadPrimitive(BinaryReader reader, Type type)
{
if (type == typeof (byte))
return reader.ReadByte();
if (type == typeof (float))
return reader.ReadSingle();
if (type == typeof (double))
return reader.ReadDouble();
if (type == typeof (decimal))
return reader.ReadDecimal();
if (type == typeof (int))
return reader.ReadInt32();
if (type == typeof (uint))
return reader.ReadUInt32();
if (type == typeof (short))
return reader.ReadInt16();
if (type == typeof (ushort))
return reader.ReadUInt16();
if (type == typeof (long))
return reader.ReadInt64();
if (type == typeof (ulong))
return reader.ReadUInt64();
if (type == typeof (bool))
return reader.ReadBoolean();
if (type == typeof (string))
return reader.ReadString();
if (type == typeof (char))
return reader.ReadChar();
if (type == typeof (Guid))
return new Guid(reader.ReadBytes(16));
if (type == typeof (DateTime))
return new DateTime(reader.ReadInt64());
throw new ArgumentException($"Failed to read '{type.FullName}', type not supported", nameof(type));
}
public static void Main(string[] args)
{
BinaryFile classObject = new BinaryFile();
try
{
using (BinaryWriter writerObject = new BinaryWriter(File.Open("file.bin", FileMode.OpenOrCreate)))
{
writerObject.Write(classObject._number);
writerObject.Write(classObject._sentence);
writerObject.Write(classObject._decimalNumber);
}
}
catch (IOException e)
{
Console.WriteLine(e);
}
try
{
using (BinaryReader readerObject = new BinaryReader(File.Open("file.bin", FileMode.OpenOrCreate)))
{
Console.WriteLine(readerObject.ReadInt32());
Console.WriteLine(readerObject.ReadString());
Console.WriteLine(readerObject.ReadDecimal());
}
}
catch (IOException e)
{
Console.WriteLine(e);
}
Console.ReadKey();
}
protected virtual Decimal DeserializeDecimal(ArraySegment<byte> value)
{
using (var stream = new MemoryStream(value.Array, value.Offset, value.Count)) {
using (var binaryReader = new BinaryReader(stream)) {
return binaryReader.ReadDecimal();
}
}
}
static int ReadDecimal(IntPtr L)
{
LuaScriptMgr.CheckArgsCount(L, 1);
System.IO.BinaryReader obj = (System.IO.BinaryReader)LuaScriptMgr.GetNetObjectSelf(L, 1, "System.IO.BinaryReader");
decimal o = obj.ReadDecimal();
LuaScriptMgr.PushValue(L, o);
return(1);
}
// very manual writer... but want to see how small I can get the data.
public static CompleteSignature ReadBinaryCompleteSignature(Stream s)
{
var sig = new CompleteSignature();
var l = new List<BlockSignature>();
var reader = new BinaryReader(s);
int numberOfEntries = reader.ReadInt32();
for (var i = 0; i < numberOfEntries; i++)
{
var entry = new BlockSignature();
// 8 bytes. offset
long offset = reader.ReadInt64();
// 4 bytes. size
int size = reader.ReadInt32();
// 4 bytes. Block Number;
int blockNumber = reader.ReadInt32();
// 4 bytes. Rolling Signature.
decimal sig1 = reader.ReadDecimal();
decimal sig2 = reader.ReadDecimal();
RollingSignature rollingSig = new RollingSignature() { Sig1 = sig1, Sig2 = sig2 };
// should be 16 bytes.
byte[] md5 = reader.ReadBytes(16);
entry.BlockNumber = (UInt32)blockNumber;
entry.RollingSig = (RollingSignature)rollingSig;
entry.MD5Signature = md5;
entry.Offset = offset;
entry.Size = (uint)size;
l.Add(entry);
}
sig.SignatureList = l.ToArray<BlockSignature>();
return sig;
}
public static decimal GetDecimalValue(this DatasourceRecord record)
{
ThrowExceptionOnInvalidConversion(record.DataType, DatasourceRecord.DataTypeEnum.Decimal);
using (var memoryStream = new MemoryStream(record.Value))
{
using (var binaryReader = new BinaryReader(memoryStream))
{
return binaryReader.ReadDecimal();
}
}
}
static public int ReadDecimal(IntPtr l)
{
try {
System.IO.BinaryReader self = (System.IO.BinaryReader)checkSelf(l);
var ret = self.ReadDecimal();
pushValue(l, true);
pushValue(l, ret);
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
public static decimal BytesToDecimal(byte[] buffer)
{
//if (buffer.Length == 1) return Decimal.Parse(((char)buffer[0]).ToString());
if (buffer.Length == 2) {
if (buffer[1] == 1) return decimal.MinValue;
else return decimal.MaxValue;
}
using (var ms = new MemoryStream(buffer)) {
using (var br = new BinaryReader(ms)) {
return br.ReadDecimal(); ;
}
}
}
/// <summary>
/// 使用 UserDefined 序列化格式
/// 通过 IBinarySerialize.Read 方法完全控制二进制格式。
/// 从用户定义类型 (UDT) 或用户定义聚合的二进制格式生成用户定义的类型或用户定义的聚合。
/// </summary>
/// <param name="r"></param>
public void Read(System.IO.BinaryReader r)
{
// 初始化数据.
dataList = new List <decimal>();
// 先读取总数量.
int size = r.ReadInt32();
// 依次读取数据，加入列表.
for (int i = 0; i < size; i++)
{
dataList.Add(r.ReadDecimal());
}
}
public static void RetrieveAndDisplayData(BinaryReader binReader)
{
// Read string data from the file
Console.WriteLine(binReader.ReadString());
// Read integer data from the file
for (int i = 0; i < 11; i++)
{
Console.WriteLine(binReader.ReadInt32());
}
// Read decimal data from the file
Console.WriteLine(binReader.ReadDecimal());
}
/// <summary>
/// Byte array to Decimal
/// </summary>
/// <param name="src">byte array</param>
/// <returns>decimal</returns>
public static Decimal BytesToDecimal(byte[] src)
{
if (src.Length == 1)
{
return(Decimal.Parse(((char)src[0]).ToString()));
}
using (System.IO.MemoryStream stream = new System.IO.MemoryStream(src))
{
using (System.IO.BinaryReader reader = new System.IO.BinaryReader(stream))
{
return(reader.ReadDecimal());
}
}
}
/// <summary>
/// Byte array to Decimal
/// </summary>
/// <param name="src">byte array</param>
/// <returns>decimal</returns>
public static Decimal BytesToDecimal(byte[] src)
{
if (src.Length == 1)
{
return Decimal.Parse(((char)src[0]).ToString());
}
using (System.IO.MemoryStream stream = new System.IO.MemoryStream(src))
{
using (System.IO.BinaryReader reader = new System.IO.BinaryReader(stream))
{
return reader.ReadDecimal();
}
}
}
public static object LoadKey(this DbColumnType keyType, io.BinaryReader reader)
{
switch (keyType)
{
case DbColumnType.Char:
//
return(reader.ReadChar());
case DbColumnType.Byte:
//
return(reader.ReadByte());
case DbColumnType.Int16:
//
return(reader.ReadInt16());
case DbColumnType.Int32:
//
return(reader.ReadInt32());
case DbColumnType.Int64:
//
return(reader.ReadInt64());
case DbColumnType.Single:
//
return(reader.ReadSingle());
case DbColumnType.Double:
//
return(reader.ReadDouble());
case DbColumnType.Decimal:
//
return(reader.ReadDecimal());
case DbColumnType.String:
//
var length = reader.ReadByte();
var chars = reader.ReadChars(length);
return(new string(chars));
default:
return(null);
}
}
public void WriteDecimal()
{
MemoryStream stream = new MemoryStream();
OutputChannel channel = new OutputChannel(new BinaryWriter(stream));
decimal dc = 12.34m;
channel.Write(dc);
stream.Seek(0, SeekOrigin.Begin);
BinaryReader reader = new BinaryReader(stream);
Assert.AreEqual((byte)Types.Decimal, reader.ReadByte());
Assert.AreEqual(dc, reader.ReadDecimal());
Assert.AreEqual(-1, reader.PeekChar());
reader.Close();
}
public static decimal ByteArrayToDecimal(byte[] src)
{
decimal num3;
if (src.Length < 0x10)
{
byte[] buffer = new byte[0x10];
int num = 0;
foreach (byte num2 in src)
{
buffer[num++] = num2;
}
src = buffer;
}
using (MemoryStream stream = new MemoryStream(src))
{
using (BinaryReader reader = new BinaryReader(stream))
{
num3 = reader.ReadDecimal();
}
}
return num3;
}
public void CreateEachDataType()
{
var idx = ObjectIndex.Create("Index_Name1", 5);
Assert.AreEqual("Index_Name1", idx.Name);
Assert.AreEqual(5, idx.GetObjectValue());
Assert.AreEqual(ObjectIndexType.Integer, idx.DataType);
Assert.AreEqual(5, BitConverter.ToInt32(idx.Value, 0));
idx = ObjectIndex.Create("Index_Name1", "test val");
Assert.AreEqual("Index_Name1", idx.Name);
Assert.AreEqual("test val", idx.GetObjectValue());
Assert.AreEqual(ObjectIndexType.String, idx.DataType);
Assert.AreEqual("test val", Encoding.UTF8.GetString(idx.Value));
idx = ObjectIndex.Create("Index_Name1", new Decimal(5));
Assert.AreEqual("Index_Name1", idx.Name);
Assert.AreEqual(new Decimal(5), idx.GetObjectValue());
Assert.AreEqual(ObjectIndexType.Decimal, idx.DataType);
var reader = new BinaryReader(new MemoryStream(idx.Value));
Assert.AreEqual(new Decimal(5), reader.ReadDecimal());
var binValue = Encoding.UTF8.GetBytes("test bin");
idx = ObjectIndex.Create("Index_Name1", binValue);
Assert.AreEqual("Index_Name1", idx.Name);
Assert.AreEqual(binValue, idx.GetObjectValue());
Assert.AreEqual(ObjectIndexType.Binary, idx.DataType);
Assert.AreEqual(binValue, idx.Value);
var dtVal = DateTime.Now;
var val = dtVal.ToBinary();
idx = ObjectIndex.Create("Index_Name1", dtVal);
Assert.AreEqual("Index_Name1", idx.Name);
Assert.AreEqual(dtVal, idx.GetObjectValue());
Assert.AreEqual(ObjectIndexType.DateTime, idx.DataType);
Assert.AreEqual(dtVal, DateTime.FromBinary(BitConverter.ToInt64(idx.Value, 0)));
}
/// <summary>
/// Deserialisiert den Player aus dem angegebenen BinaryReader.
/// </summary>
/// <param name="reader">Der BinaryWriter, mit dem gelesen wird.</param>
/// <param name="definitionManager">Der aktuell verwendete <see cref="IDefinitionManager"/>.</param>
public override void Deserialize(BinaryReader reader, IDefinitionManager definitionManager)
{
// Entity
base.Deserialize(reader, definitionManager);
// Radius
Radius = reader.ReadSingle();
// Angle
Angle = reader.ReadSingle();
// Height
Height = reader.ReadSingle();
// Tilt
Tilt = reader.ReadSingle();
// FlyMode
FlyMode = reader.ReadBoolean();
// Inventory Limit
// TODO: Noch nicht persistiert
// Inventory
int inventoryCount = reader.ReadInt32();
for (int i = 0; i < inventoryCount; i++)
{
string definitionName = reader.ReadString();
decimal amount = reader.ReadDecimal();
var definition = definitionManager.GetItemDefinitions().FirstOrDefault(d => d.GetType().FullName.Equals(definitionName));
if (definition != null)
{
InventorySlot slot = new InventorySlot();
slot.Definition = definition;
slot.Amount = amount;
Inventory.Add(slot);
}
}
// Inventory Tools (Index auf Inventory)
byte toolCount = reader.ReadByte();
for (byte i = 0; i < toolCount; i++)
{
byte index = reader.ReadByte();
string definitionType = reader.ReadString();
InventorySlot slot = Inventory.FirstOrDefault(s => s.Definition.GetType().FullName.Equals(definitionType));
if (slot != null)
Tools[index] = slot;
}
}
private object ConvertToObject(byte[] data, string resourceType)
{
MemoryStream dataStream = new MemoryStream(data);
BinaryReader reader = new BinaryReader(dataStream);
if (resourceType.Equals("ResourceTypeCode.Null"))
return null;
else if (resourceType.Equals("ResourceTypeCode.String"))
return reader.ReadString();
else if (resourceType.Equals("ResourceTypeCode.Boolean"))
return reader.ReadBoolean();
else if (resourceType.Equals("ResourceTypeCode.Char"))
return (char) reader.ReadUInt16();
else if (resourceType.Equals("ResourceTypeCode.Byte"))
return reader.ReadByte();
else if (resourceType.Equals("ResourceTypeCode.SByte"))
return reader.ReadSByte();
else if (resourceType.Equals("ResourceTypeCode.Int16"))
return reader.ReadInt16();
else if (resourceType.Equals("ResourceTypeCode.UInt16"))
return reader.ReadUInt16();
else if (resourceType.Equals("ResourceTypeCode.Int32"))
return reader.ReadInt32();
else if (resourceType.Equals("ResourceTypeCode.UInt32"))
return reader.ReadUInt32();
else if (resourceType.Equals("ResourceTypeCode.Int64"))
return reader.ReadInt64();
else if (resourceType.Equals("ResourceTypeCode.UInt64"))
return reader.ReadUInt64();
else if (resourceType.Equals("ResourceTypeCode.Single"))
return reader.ReadSingle();
else if (resourceType.Equals("ResourceTypeCode.Double"))
return reader.ReadDouble();
else if (resourceType.Equals("ResourceTypeCode.Decimal"))
return reader.ReadDecimal();
else if (resourceType.Equals("ResourceTypeCode.DateTime"))
{
// Use DateTime's ToBinary & FromBinary.
Int64 dateData = reader.ReadInt64();
return DateTime.FromBinary(dateData);
}
else if (resourceType.Equals("ResourceTypeCode.TimeSpan"))
{
Int64 ticks = reader.ReadInt64();
return new TimeSpan(ticks);
}
// Special types
else if (resourceType.Equals("ResourceTypeCode.ByteArray"))
{
int len = reader.ReadInt32();
return reader.ReadBytes(len);
}
else if (resourceType.Equals("ResourceTypeCode.Stream"))
{
int len = reader.ReadInt32();
return new MemoryStream(reader.ReadBytes(len));
}
else
{
// weitere Klassen
BinaryFormatter bf = new BinaryFormatter();
return bf.Deserialize(dataStream);
}
}
private void ReadArrayOfPrimitiveType (BinaryReader reader, out long objectId, out object val)
{
objectId = (long) reader.ReadUInt32 ();
int length = reader.ReadInt32 ();
Type elementType = ReadType (reader, TypeTag.PrimitiveType);
switch (Type.GetTypeCode (elementType))
{
case TypeCode.Boolean: {
bool[] arr = new bool [length];
for (int n = 0; n < length; n++) arr [n] = reader.ReadBoolean();
val = arr;
break;
}
case TypeCode.Byte: {
byte[] arr = new byte [length];
int pos = 0;
while (pos < length) {
int nr = reader.Read (arr, pos, length - pos);
if (nr == 0) break;
pos += nr;
}
val = arr;
break;
}
case TypeCode.Char: {
char[] arr = new char [length];
int pos = 0;
while (pos < length) {
int nr = reader.Read (arr, pos, length - pos);
if (nr == 0) break;
pos += nr;
}
val = arr;
break;
}
case TypeCode.DateTime: {
DateTime[] arr = new DateTime [length];
for (int n = 0; n < length; n++) {
arr [n] = DateTime.FromBinary (reader.ReadInt64 ());
}
val = arr;
break;
}
case TypeCode.Decimal: {
Decimal[] arr = new Decimal [length];
for (int n = 0; n < length; n++) arr [n] = reader.ReadDecimal();
val = arr;
break;
}
case TypeCode.Double: {
Double[] arr = new Double [length];
if (length > 2)
BlockRead (reader, arr, 8);
else
for (int n = 0; n < length; n++) arr [n] = reader.ReadDouble();
val = arr;
break;
}
case TypeCode.Int16: {
short[] arr = new short [length];
if (length > 2)
BlockRead (reader, arr, 2);
else
for (int n = 0; n < length; n++) arr [n] = reader.ReadInt16();
val = arr;
break;
}
case TypeCode.Int32: {
int[] arr = new int [length];
if (length > 2)
BlockRead (reader, arr, 4);
else
for (int n = 0; n < length; n++) arr [n] = reader.ReadInt32();
val = arr;
break;
}
case TypeCode.Int64: {
long[] arr = new long [length];
if (length > 2)
BlockRead (reader, arr, 8);
else
for (int n = 0; n < length; n++) arr [n] = reader.ReadInt64();
val = arr;
break;
}
case TypeCode.SByte: {
sbyte[] arr = new sbyte [length];
if (length > 2)
BlockRead (reader, arr, 1);
else
for (int n = 0; n < length; n++) arr [n] = reader.ReadSByte();
val = arr;
break;
}
case TypeCode.Single: {
float[] arr = new float [length];
if (length > 2)
BlockRead (reader, arr, 4);
else
for (int n = 0; n < length; n++) arr [n] = reader.ReadSingle();
val = arr;
break;
}
case TypeCode.UInt16: {
ushort[] arr = new ushort [length];
if (length > 2)
BlockRead (reader, arr, 2);
else
for (int n = 0; n < length; n++) arr [n] = reader.ReadUInt16();
val = arr;
break;
}
case TypeCode.UInt32: {
uint[] arr = new uint [length];
if (length > 2)
BlockRead (reader, arr, 4);
else
for (int n = 0; n < length; n++) arr [n] = reader.ReadUInt32();
val = arr;
break;
}
case TypeCode.UInt64: {
ulong[] arr = new ulong [length];
if (length > 2)
BlockRead (reader, arr, 8);
else
for (int n = 0; n < length; n++) arr [n] = reader.ReadUInt64();
val = arr;
break;
}
case TypeCode.String: {
string[] arr = new string [length];
for (int n = 0; n < length; n++) arr [n] = reader.ReadString();
val = arr;
break;
}
default: {
if (elementType == typeof(TimeSpan)) {
TimeSpan[] arr = new TimeSpan [length];
for (int n = 0; n < length; n++) arr [n] = new TimeSpan (reader.ReadInt64 ());
val = arr;
}
else
throw new NotSupportedException ("Unsupported primitive type: " + elementType.FullName);
break;
}
}
}
/// <summary>
/// Reads a definition to disk
/// </summary>
/// <param name="br"></param>
/// <returns></returns>
internal static Variant ReadFromFieldDef(BinaryReader br)
{
Variant v= new Variant();
const string FuncErrCode=ClassErrCode+".0002";
try{
//BinaryReader br = new BinaryReader(_br.BaseStream,System.Text.Encoding.Unicode);
v.type=(FieldType)br.ReadInt32();
switch(v.type)
{
case FieldType.ftBoolean:
v.obj=br.ReadBoolean();
break;
case FieldType.ftDecimal:
v.obj=br.ReadDecimal();
break;
case FieldType.ftDateTime:
v.obj=new DateTime(br.ReadInt64());
break;
case FieldType.ftInt32:
v.obj=br.ReadInt32();
break;
case FieldType.ftInt64:
v.obj=br.ReadInt64();
break;
case FieldType.ftString:
v.obj=br.ReadString();
break;
default:
throw new Exception(FuncErrCode+": Field type not recognized");
}
return v;
}
catch(Exception ex)
{
throw new Exception(ex.Message+"\n"+FuncErrCode+": Inner exception.");
}
}
internal object ReadData(BinaryReader br)
{
const string FuncErrCode=ClassErrCode+".0006";
try
{
Field f = this;
switch(f.type)
{
case FieldType.ftBoolean:
return br.ReadBoolean();
case FieldType.ftDecimal:
return br.ReadDecimal();
case FieldType.ftDateTime:
return new DateTime(br.ReadInt64());
case FieldType.ftInt32:
return br.ReadInt32();
case FieldType.ftInt64:
return br.ReadInt64();
case FieldType.ftString: //long total = 2*len+8 bytes
long p = br.BaseStream.Position;
byte[] bytes = new byte[br.ReadInt32()];
bytes=br.ReadBytes(bytes.Length);
string str =System.Text.Encoding.Unicode.GetString(bytes);
br.BaseStream.Position = p+DataSize();
return str;
default:
return null;
}
}
catch(Exception ex)
{
throw new Exception(ex.Message+"\n"+FuncErrCode+": Inner exception.");
}
}
internal static object Deserialize (BinaryReader r)
{
TypeCode typeCode = (TypeCode)r.ReadByte();
switch (typeCode) {
case TypeCode.Boolean:
return r.ReadBoolean ();
case TypeCode.Byte:
return r.ReadByte ();
case TypeCode.Char:
return r.ReadChar ();
case TypeCode.DateTime:
return new DateTime (r.ReadInt64 ());
case TypeCode.DBNull:
return DBNull.Value;
case TypeCode.Decimal:
return r.ReadDecimal ();
case TypeCode.Double:
return r.ReadDouble ();
case TypeCode.Empty:
return null;
case TypeCode.Int16:
return r.ReadInt16 ();
case TypeCode.Int32:
return r.ReadInt32 ();
case TypeCode.Int64:
return r.ReadInt64 ();
case TypeCode.Object:
BinaryFormatter bf = new BinaryFormatter ();
return bf.Deserialize (r.BaseStream);
case TypeCode.SByte:
return r.ReadSByte ();
case TypeCode.Single:
return r.ReadSingle ();
case TypeCode.String:
return r.ReadString ();
case TypeCode.UInt16:
return r.ReadUInt16 ();
case TypeCode.UInt32:
return r.ReadUInt32 ();
case TypeCode.UInt64:
return r.ReadUInt64 ();
default:
throw new ArgumentOutOfRangeException ("TypeCode:" + typeCode);
}
}
public override object[] ReadDbRecord(int offset)
{
var mainMask = Table.RowMask;
var bytes = Table.RowMaskLength;
//point to record offset
reader.BaseStream.Position = offset;
//read record
var buffer = new byte[sizeof(UInt64)];
reader.Read(buffer, 0, bytes);
var recordMask = BitConverter.ToUInt64(buffer, 0);
//copy main
var bitMask = mainMask;
var columnCount = Table.Count;
//create record according to table columns
var dbRecord = new object[columnCount];
for (var i = 0; i < columnCount; i++)
{
var colType = Table.ColumnTypes[i];
if ((recordMask & bitMask) == 0)
{
//not null value
object value = null;
switch (colType)
{
case DbColumnType.Char:
value = reader.ReadChar();
break;
case DbColumnType.Byte:
value = reader.ReadByte();
break;
case DbColumnType.Int16:
value = reader.ReadInt16();
break;
case DbColumnType.Int32:
value = reader.ReadInt32();
break;
case DbColumnType.Int64:
value = reader.ReadInt64();
break;
case DbColumnType.Single:
value = reader.ReadSingle();
break;
case DbColumnType.Double:
value = reader.ReadDouble();
break;
case DbColumnType.Decimal:
value = reader.ReadDecimal();
break;
case DbColumnType.String:
value = reader.ReadString();
break;
default:
throw new ArgumentException($"invalid column type: {colType}");
}
//store value in right spot
dbRecord[i] = value;
}
bitMask >>= 1;
}
//
return(dbRecord);
}
public void Read(System.IO.BinaryReader r)
{
_d = r.ReadDecimal();
}
public void Read(System.IO.BinaryReader reader)
{
totalAmount = reader.ReadDecimal();
totalCount = reader.ReadInt32();
}
public object[] Deserialize(byte[] data)
{
MemoryStream Stream = new MemoryStream(data);
BinaryReader Reader = new BinaryReader(Stream, Encoding.UTF8);
List<object> Items = new List<object>();
byte Current = 0;
byte Count = Reader.ReadByte();
for (int I = 0; I < Count; I++)
{
Current = Reader.ReadByte();
switch (Current)
{
case 0:
Items.Add(Reader.ReadBoolean());
break;
case 1:
Items.Add(Reader.ReadByte());
break;
case 2:
Items.Add(Reader.ReadBytes(Reader.ReadInt32()));
break;
case 3:
Items.Add(Reader.ReadChar());
break;
case 4:
Items.Add(Reader.ReadString().ToCharArray());
break;
case 5:
Items.Add(Reader.ReadDecimal());
break;
case 6:
Items.Add(Reader.ReadDouble());
break;
case 7:
Items.Add(Reader.ReadInt32());
break;
case 8:
Items.Add(Reader.ReadInt64());
break;
case 9:
Items.Add(Reader.ReadSByte());
break;
case 10:
Items.Add(Reader.ReadInt16());
break;
case 11:
Items.Add(Reader.ReadSingle());
break;
case 12:
Items.Add(Reader.ReadString());
break;
case 13:
Items.Add(Reader.ReadUInt32());
break;
case 14:
Items.Add(Reader.ReadUInt64());
break;
case 15:
Items.Add(Reader.ReadUInt16());
break;
case 16:
Items.Add(DateTime.FromBinary(Reader.ReadInt64()));
break;
}
}
Reader.Close();
return Items.ToArray();
}
public object[] ReceiveParameters(BinaryReader reader)
{
int parameterCount = reader.ReadInt32();
object[] parameters = new object[parameterCount];
for (int i = 0; i < parameterCount; i++)
{
//read type byte
byte typeByte = reader.ReadByte();
if (typeByte == ParameterTypes.Null)
parameters[i] = null;
else
{
switch (typeByte)
{
case ParameterTypes.Bool:
parameters[i] = reader.ReadBoolean();
break;
case ParameterTypes.Byte:
parameters[i] = reader.ReadByte();
break;
case ParameterTypes.ByteArray:
parameters[i] = reader.ReadBytes(reader.ReadInt32());
break;
case ParameterTypes.CompressedByteArray:
parameters[i] = reader.ReadBytes(reader.ReadInt32()).FromGZipBytes();
break;
case ParameterTypes.Char:
parameters[i] = reader.ReadChar();
break;
case ParameterTypes.CharArray:
parameters[i] = reader.ReadChars(reader.ReadInt32());
break;
case ParameterTypes.CompressedCharArray:
var ccBytes = reader.ReadBytes(reader.ReadInt32()).FromGZipBytes();
parameters[i] = Encoding.UTF8.GetChars(ccBytes);
break;
case ParameterTypes.Decimal:
parameters[i] = reader.ReadDecimal();
break;
case ParameterTypes.Double:
parameters[i] = reader.ReadDouble();
break;
case ParameterTypes.Float:
parameters[i] = reader.ReadSingle();
break;
case ParameterTypes.Int:
parameters[i] = reader.ReadInt32();
break;
case ParameterTypes.Long:
parameters[i] = reader.ReadInt64();
break;
case ParameterTypes.SByte:
parameters[i] = reader.ReadSByte();
break;
case ParameterTypes.Short:
parameters[i] = reader.ReadInt16();
break;
case ParameterTypes.String:
parameters[i] = reader.ReadString();
break;
case ParameterTypes.CompressedString:
var csBytes = reader.ReadBytes(reader.ReadInt32()).FromGZipBytes();
parameters[i] = Encoding.UTF8.GetString(csBytes);
break;
case ParameterTypes.UInt:
parameters[i] = reader.ReadUInt32();
break;
case ParameterTypes.ULong:
parameters[i] = reader.ReadUInt64();
break;
case ParameterTypes.UShort:
parameters[i] = reader.ReadUInt16();
break;
case ParameterTypes.Type:
var typeName = reader.ReadString();
parameters[i] = Type.GetType(typeName);
break;
case ParameterTypes.Guid:
parameters[i] = new Guid(reader.ReadBytes(16));
break;
case ParameterTypes.DateTime:
var dtstr = reader.ReadString();
parameters[i] = DateTime.Parse(dtstr, null, DateTimeStyles.RoundtripKind);
break;
case ParameterTypes.ArrayBool:
var blen = reader.ReadInt32();
var bs = new bool[blen];
for (int x = 0; x < blen; x++) bs[x] = reader.ReadBoolean();
parameters[i] = bs;
break;
case ParameterTypes.ArraySByte:
var sblen = reader.ReadInt32();
var sbs = new sbyte[sblen];
for (int x = 0; x < sblen; x++) sbs[x] = reader.ReadSByte();
parameters[i] = sbs;
break;
case ParameterTypes.ArrayDecimal:
var dclen = reader.ReadInt32();
var dcs = new decimal[dclen];
for (int x = 0; x < dclen; x++) dcs[x] = reader.ReadDecimal();
parameters[i] = dcs;
break;
case ParameterTypes.ArrayDouble:
var dblen = reader.ReadInt32();
var dbs = new double[dblen];
for (int x = 0; x < dblen; x++) dbs[x] = reader.ReadDouble();
parameters[i] = dbs;
break;
case ParameterTypes.ArrayFloat:
var flen = reader.ReadInt32();
var fs = new float[flen];
for (int x = 0; x < flen; x++) fs[x] = reader.ReadSingle();
parameters[i] = fs;
break;
case ParameterTypes.ArrayInt:
var ilen = reader.ReadInt32();
var iss = new int[ilen];
for (int x = 0; x < ilen; x++) iss[x] = reader.ReadInt32();
parameters[i] = iss;
break;
case ParameterTypes.ArrayUInt:
var uilen = reader.ReadInt32();
var uis = new uint[uilen];
for (int x = 0; x < uilen; x++) uis[x] = reader.ReadUInt32();
parameters[i] = uis;
break;
case ParameterTypes.ArrayLong:
var llen = reader.ReadInt32();
var ls = new long[llen];
for (int x = 0; x < llen; x++) ls[x] = reader.ReadInt64();
parameters[i] = ls;
break;
case ParameterTypes.ArrayULong:
var ullen = reader.ReadInt32();
var uls = new ulong[ullen];
for (int x = 0; x < ullen; x++) uls[x] = reader.ReadUInt64();
parameters[i] = uls;
break;
case ParameterTypes.ArrayShort:
var sslen = reader.ReadInt32();
var sss = new short[sslen];
for (int x = 0; x < sslen; x++) sss[x] = reader.ReadInt16();
parameters[i] = sss;
break;
case ParameterTypes.ArrayUShort:
var ulen = reader.ReadInt32();
var us = new ushort[ulen];
for (int x = 0; x < ulen; x++) us[x] = reader.ReadUInt16();
parameters[i] = us;
break;
case ParameterTypes.ArrayString:
var slen = reader.ReadInt32();
var ss = new string[slen];
for (int x = 0; x < slen; x++) ss[x] = reader.ReadString();
parameters[i] = ss;
break;
case ParameterTypes.ArrayType:
var tlen = reader.ReadInt32();
var ts = new Type[tlen];
for (int x = 0; x < tlen; x++) ts[x] = Type.GetType(reader.ReadString());
parameters[i] = ts;
break;
case ParameterTypes.ArrayGuid:
var glen = reader.ReadInt32();
var gs = new Guid[glen];
for (int x = 0; x < glen; x++) gs[x] = new Guid(reader.ReadBytes(16));
parameters[i] = gs;
break;
case ParameterTypes.ArrayDateTime:
var dlen = reader.ReadInt32();
var dts = new DateTime[dlen];
for (int x = 0; x < dlen; x++)
{
var adtstr = reader.ReadString();
dts[x] = DateTime.Parse(adtstr, null, DateTimeStyles.RoundtripKind);
}
parameters[i] = dts;
break;
case ParameterTypes.Unknown:
var typeConfigName = reader.ReadString();
var bytes = reader.ReadBytes(reader.ReadInt32());
parameters[i] = bytes.ToDeserializedObject(typeConfigName);
break;
case ParameterTypes.CompressedUnknown:
var cuTypeConfigName = reader.ReadString();
var cuBytes = reader.ReadBytes(reader.ReadInt32()).FromGZipBytes();
parameters[i] = cuBytes.ToDeserializedObject(cuTypeConfigName);
break;
default:
throw new Exception(string.Format("Unknown type byte '0x{0:X}'", typeByte));
}
}
}
return parameters;
}
private static bool LoadPrimitiveData(ref object data, Type type, BinaryReader reader)
{
switch (Type.GetTypeCode(type))
{
case TypeCode.Boolean:
data = reader.ReadBoolean();
return true;
case TypeCode.Byte:
data = reader.ReadByte();
return true;
case TypeCode.Char:
data = reader.ReadChar();
return true;
case TypeCode.Decimal:
data = reader.ReadDecimal();
return true;
case TypeCode.Double:
data = reader.ReadDouble();
return true;
case TypeCode.Single:
data = reader.ReadSingle();
return true;
case TypeCode.Int16:
data = reader.ReadInt16();
return true;
case TypeCode.Int32:
data = reader.ReadInt32();
return true;
case TypeCode.Int64:
data = reader.ReadInt64();
return true;
case TypeCode.String:
data = reader.ReadString();
return true;
case TypeCode.SByte:
data = reader.ReadSByte();
return true;
case TypeCode.UInt16:
data = reader.ReadUInt16();
return true;
case TypeCode.UInt32:
data = reader.ReadUInt32();
return true;
case TypeCode.UInt64:
data = reader.ReadUInt64();
return true;
}
return false;
}
private static object ReadValueCore(Type type, BinaryReader reader)
{
try {
if (type == typeof (byte[])) {
return ReadArrayOfByte(reader);
}
if (type == typeof (string)) {
return reader.ReadString();
}
if (type == typeof (bool)) {
return reader.ReadBoolean();
}
if (type == typeof (byte)) {
return reader.ReadByte();
}
if (type == typeof (char)) {
return reader.ReadChar();
}
if (type == typeof (DateTime)) {
return new DateTime(reader.ReadInt64());
}
if (type == typeof (Guid)) {
return new Guid(reader.ReadBytes(16));
}
#if DEBUG || PORTABLE || SILVERLIGHT
if (type == typeof (decimal)) {
return ReadDecimal(reader);
}
#else
if (type == typeof (Decimal)) return reader.ReadDecimal();
#endif
if (type == typeof (double)) {
return reader.ReadDouble();
}
if (type == typeof (short)) {
return reader.ReadInt16();
}
if (type == typeof (int)) {
return reader.ReadInt32();
}
if (type == typeof (long)) {
return reader.ReadInt64();
}
if (type == typeof (sbyte)) {
return reader.ReadSByte();
}
if (type == typeof (float)) {
return reader.ReadSingle();
}
if (type == typeof (ushort)) {
return reader.ReadUInt16();
}
if (type == typeof (uint)) {
return reader.ReadUInt32();
}
if (type == typeof (ulong)) {
return reader.ReadUInt64();
}
if (type == typeof (TimeSpan)) {
return new TimeSpan(reader.ReadInt64());
}
// Enumeration
if (type.IsEnum) {
return ReadEnumeration(type, reader);
}
// Type
if (IsType(type)) {
var typeName = reader.ReadString();
return Type.GetType(typeName, true);
}
throw new InvalidOperationException(string.Format("Unknown simple type: {0}", type.FullName));
}
catch (Exception ex) {
throw new SimpleValueParsingException(string.Format("Invalid type: {0}. See details in the inner exception.", type), ex);
}
}
/// <summary>
/// Decodes a byte array (stored in the memory stream) into an object
/// If the GUID is one of the internal versions, then the type is assumed
/// to be byte array.
/// If however, the guid is of unknown origin or not v1 internal, then the type
/// information is assumed to be stored in the first 2 bytes of the stream.
/// </summary>
/// <param name="guid">Guid of property - to detect origin</param>
/// <param name="memStream">Buffer of data</param>
/// <param name="type">the type info stored in the stream</param>
/// <returns>object stored in data buffer</returns>
/// <remarks>The buffer stream passed in to the method will be closed after reading</remarks>
internal static object DecodeAttribute(Guid guid, Stream memStream, out VarEnum type)
{
// First determine the object type
using (BinaryReader br = new BinaryReader(memStream))
{
//
// if usesEmbeddedTypeInfo is true, we do not
// read the variant type from the ISF stream. Instead,
// we assume it to be a byte[]
//
bool usesEmbeddedTypeInfo = UsesEmbeddedTypeInformation(guid);
// if the Id has embedded type information then retrieve it from the stream
if (usesEmbeddedTypeInfo)
{
// We must read the data type from the stream
type = (VarEnum)br.ReadUInt16();
}
else
{
// The data is stored as byte array
type = (VarEnum.VT_ARRAY | VarEnum.VT_UI1);
}
switch (type)
{
case (VarEnum.VT_ARRAY | VarEnum.VT_I1):
return br.ReadChars((int)(memStream.Length - 2));
case (VarEnum.VT_ARRAY | VarEnum.VT_UI1):
{
//
// note: for (VarEnum.VT_ARRAY | VarEnum.VT_UI1),
// we might be reading data that didn't have the
// type embedded in the ISF stream, in which case
// we must not assume we've already read two bytes
//
int previouslyReadBytes = 2;
if (!usesEmbeddedTypeInfo)
{
previouslyReadBytes = 0;
}
return br.ReadBytes((int)(memStream.Length - previouslyReadBytes));
}
case (VarEnum.VT_ARRAY | VarEnum.VT_I2):
{
int count = (int)(memStream.Length - 2) / 2; // 2 is the size of one element
short[] val = new short[count];
for (int i = 0; i < count; i++)
val[i] = br.ReadInt16();
return val;
}
case (VarEnum.VT_ARRAY | VarEnum.VT_UI2):
{
int count = (int)(memStream.Length - 2) / 2; // 2 is the size of one element
ushort[] val = new ushort[count];
for (int i = 0; i < count; i++)
val[i] = br.ReadUInt16();
return val;
}
case (VarEnum.VT_ARRAY | VarEnum.VT_I4):
{
int count = (int)(memStream.Length - 2) / 4; // 2 is the size of one element
int[] val = new int[count];
for (int i = 0; i < count; i++)
val[i] = br.ReadInt32();
return val;
}
case (VarEnum.VT_ARRAY | VarEnum.VT_UI4):
{
int count = (int)(memStream.Length - 2) / 4; // size of one element
uint[] val = new uint[count];
for (int i = 0; i < count; i++)
val[i] = br.ReadUInt32();
return val;
}
case (VarEnum.VT_ARRAY | VarEnum.VT_I8):
{
int count = (int)(memStream.Length - 2) / Native.BitsPerByte; // size of one element
long[] val = new long[count];
for (int i = 0; i < count; i++)
val[i] = br.ReadInt64();
return val;
}
case (VarEnum.VT_ARRAY | VarEnum.VT_UI8):
{
int count = (int)(memStream.Length - 2) / Native.BitsPerByte; // size of one element
ulong[] val = new ulong[count];
for (int i = 0; i < count; i++)
val[i] = br.ReadUInt64();
return val;
}
case (VarEnum.VT_ARRAY | VarEnum.VT_R4):
{
int count = (int)(memStream.Length - 2) / 4; // size of one element
float[] val = new float[count];
for (int i = 0; i < count; i++)
val[i] = br.ReadSingle();
return val;
}
case (VarEnum.VT_ARRAY | VarEnum.VT_R8):
{
int count = (int)(memStream.Length - 2) / Native.BitsPerByte; // size of one element
double[] val = new double[count];
for (int i = 0; i < count; i++)
val[i] = br.ReadDouble();
return val;
}
case (VarEnum.VT_ARRAY | VarEnum.VT_DATE):
{
int count = (int)(memStream.Length - 2) / Native.BitsPerByte; // size of one element
DateTime[] val = new DateTime[count];
for (int i = 0; i < count; i++)
{
val[i] = DateTime.FromOADate(br.ReadDouble());
}
return val;
}
case (VarEnum.VT_ARRAY | VarEnum.VT_BOOL):
{
int count = (int)(memStream.Length - 2); // size of one element
bool[] val = new bool[count];
for (int i = 0; i < count; i++)
val[i] = br.ReadBoolean();
return val;
}
case (VarEnum.VT_ARRAY | VarEnum.VT_DECIMAL):
{
int count = (int)((memStream.Length - 2) / Native.SizeOfDecimal); // size of one element
decimal[] val = new decimal[count];
for (int i = 0; i < count; i++)
val[i] = br.ReadDecimal();
return val;
}
case (VarEnum.VT_I1):
return br.ReadChar();
case (VarEnum.VT_UI1):
return br.ReadByte();
case (VarEnum.VT_I2):
return br.ReadInt16();
case (VarEnum.VT_UI2):
return br.ReadUInt16();
case (VarEnum.VT_I4):
return br.ReadInt32();
case (VarEnum.VT_UI4):
return br.ReadUInt32();
case (VarEnum.VT_I8):
return br.ReadInt64();
case (VarEnum.VT_UI8):
return br.ReadUInt64();
case (VarEnum.VT_R4):
return br.ReadSingle();
case (VarEnum.VT_R8):
return br.ReadDouble();
case (VarEnum.VT_DATE):
return DateTime.FromOADate(br.ReadDouble());
case (VarEnum.VT_BOOL):
return br.ReadBoolean();
case (VarEnum.VT_DECIMAL):
return br.ReadDecimal();
case (VarEnum.VT_BSTR):
{
byte[] bytestring = br.ReadBytes((int)memStream.Length);
return System.Text.Encoding.Unicode.GetString(bytestring);
}
default:
{
throw new InvalidOperationException(SR.Get(SRID.InvalidEpInIsf));
}
}
}
}
/// <summary>
/// Read column data from file.
/// </summary>
/// <param name="reader"></param>
/// <param name="length"></param>
/// <returns></returns>
internal static object[] ReadData(BinaryReader reader, int length)
{
object[] data = new object[length];
for (int i = 0; i < length; i++)
{
#if !POCKETPC
ColumnType type = (ColumnType)Enum.Parse( typeof(ColumnType), reader.ReadInt32().ToString() );
#else
ColumnType type = (ColumnType)OpenNETCF.EnumEx.Parse( typeof(ColumnType), reader.ReadInt32().ToString() );
#endif
object o = null;
switch (type)
{
case ColumnType.Null:
o = null;
break;
case ColumnType.Float:
case ColumnType.Real:
o = reader.ReadSingle();
break;
case ColumnType.DbDouble:
o = reader.ReadDouble();
break;
case ColumnType.VarCharIgnoreCase:
case ColumnType.VarChar:
case ColumnType.Char:
case ColumnType.LongVarChar:
o = reader.ReadString();
break;
case ColumnType.Date:
case ColumnType.Time:
case ColumnType.Timestamp:
o = new DateTime( reader.ReadInt64() );
break;
case ColumnType.Numeric:
case ColumnType.DbDecimal:
#if !POCKETPC
o = reader.ReadDecimal();
#else
int l = reader.ReadInt32();
byte[] bytes = reader.ReadBytes(l);
int[] bits = new int[bytes.Length/4];
for(int ix=0;ix<bits.Length;ix++)
{
bits[ix] = BitConverter.ToInt32(bytes, ix*4);
}
o = new Decimal( bits );
#endif
break;
case ColumnType.Bit:
o = reader.ReadBoolean();
break;
case ColumnType.TinyInt:
o = reader.ReadByte();
break;
case ColumnType.SmallInt:
o = reader.ReadInt16();
break;
case ColumnType.Integer:
o = reader.ReadInt32();
break;
case ColumnType.BigInt:
o = reader.ReadInt64();
break;
case ColumnType.Binary:
case ColumnType.VarBinary:
case ColumnType.LongVarBinary:
int len = reader.ReadInt32();
o = reader.ReadBytes(len);
break;
case ColumnType.Other:
int other = reader.ReadInt32();
o = ByteArray.Deserialize(reader.ReadBytes(other));
break;
case ColumnType.UniqueIdentifier:
o = new Guid(reader.ReadString());
break;
default:
throw TracingHelper.Error(TracingHelper.WRONG_DATA_TYPE, (int)type);
}
data[i] = o;
}
return data;
}
/// <summary>
/// Creates an instance of the specified type contained in the specified stream.
/// </summary>
public static object CreateInstance(Type type, Stream stream)
{
BinaryReader br = new BinaryReader(stream, Encoding.ASCII);
object obj = Activator.CreateInstance(type);
foreach(FieldInfo field in type.GetFields())
{
if((!field.IsPublic) || (field.IsStatic))
continue;
if(field.FieldType == typeof(Boolean))
field.SetValue(obj, br.ReadBoolean());
else if(field.FieldType == typeof(Byte))
field.SetValue(obj, br.ReadByte());
else if(field.FieldType == typeof(Char))
field.SetValue(obj, br.ReadChar());
else if(field.FieldType == typeof(Decimal))
field.SetValue(obj, br.ReadDecimal());
else if(field.FieldType == typeof(Double))
field.SetValue(obj, br.ReadDouble());
else if(field.FieldType == typeof(Int16))
field.SetValue(obj, br.ReadInt16());
else if(field.FieldType == typeof(Int32))
field.SetValue(obj, br.ReadInt32());
else if(field.FieldType == typeof(Int64))
field.SetValue(obj, br.ReadInt64());
else if(field.FieldType == typeof(SByte))
field.SetValue(obj, br.ReadSByte());
else if(field.FieldType == typeof(Single))
field.SetValue(obj, br.ReadSingle());
else if(field.FieldType == typeof(UInt16))
field.SetValue(obj, br.ReadUInt16());
else if(field.FieldType == typeof(UInt32))
field.SetValue(obj, br.ReadUInt32());
else if(field.FieldType == typeof(UInt64))
field.SetValue(obj, br.ReadUInt64());
else if(field.FieldType == typeof(Byte[]))
{
ArrayLengthAttribute[] attrs = (ArrayLengthAttribute[])field.GetCustomAttributes(typeof(ArrayLengthAttribute), true);
if(attrs.Length != 1)
throw new InvalidOperationException("Required a single specified length given by the ArrayLength Attribute");
field.SetValue(obj, br.ReadBytes(attrs[0].ArrayLength));
}
else if(field.FieldType == typeof(Char[]))
{
ArrayLengthAttribute[] attrs = (ArrayLengthAttribute[])field.GetCustomAttributes(typeof(ArrayLengthAttribute), true);
if(attrs.Length != 1)
throw new InvalidOperationException("Required a single specified length given by the ArrayLength Attribute");
field.SetValue(obj, br.ReadChars(attrs[0].ArrayLength));
}
else if(field.FieldType == typeof(String))
{
ArrayLengthAttribute[] attrs = (ArrayLengthAttribute[])field.GetCustomAttributes(typeof(ArrayLengthAttribute), true);
if(attrs.Length == 1)
field.SetValue(obj, new string(br.ReadChars(attrs[0].ArrayLength)));
else
field.SetValue(obj, br.ReadString());
}
else
throw new NotSupportedException("Type not supported in read");
}
return obj;
}
object DeserializeObject (BinaryReader reader)
{
TypeId tid = (TypeId)reader.ReadByte ();
if (tid == TypeId.NULL)
return null;
if (tid == TypeId.String) {
return reader.ReadString ();
}
if (tid == TypeId.Int32) {
return reader.ReadInt32 ();
}
if (tid == TypeId.Int64) {
return reader.ReadInt64 ();
}
if (tid == TypeId.UInt32) {
return reader.ReadUInt32 ();
}
if (tid == TypeId.UInt64) {
return reader.ReadUInt64 ();
}
if (tid == TypeId.Boolean) {
return reader.ReadBoolean ();
}
if (tid == TypeId.Byte) {
return reader.ReadByte ();
}
if (tid == TypeId.SByte) {
return reader.ReadSByte ();
}
if (tid == TypeId.Char) {
return reader.ReadChar ();
}
if (tid == TypeId.Double) {
return reader.ReadDouble ();
}
if (tid == TypeId.Single) {
return reader.ReadSingle ();
}
if (tid == TypeId.Byte) {
return reader.ReadByte ();
}
if (tid == TypeId.Int16) {
return reader.ReadInt16 ();
}
if (tid == TypeId.UInt16) {
return reader.ReadUInt16 ();
}
if (tid == TypeId.Decimal) {
return reader.ReadDecimal ();
}
throw new NotSupportedException ();
}