public static DataTable DeserializeDataTable(BinaryTypesReader br)
{
DataTable table = new DataTable();
table.TableName = br.ReadString();
int columnCount = br.Read7BitInt();
Type[] columnTypes = new Type[columnCount];
for (int i = 0; i < columnCount; i++)
{
string columnName = br.ReadString();
string typeName = br.ReadString();
Type columnType = Type.GetType(typeName);
DataColumn col = new DataColumn(columnName, columnType);
table.Columns.Add(col);
columnTypes[i] = columnType;
}
int rowsCount = br.Read7BitInt();
for (int rowIndex = 0; rowIndex < rowsCount; rowIndex++)
{
DataRow row = table.NewRow();
table.Rows.Add(row);
for (int i = 0; i < columnCount; i++)
{
if (columnTypes[i] == typeof(System.String))
{
row[i] = br.ReadString();
}
else if (columnTypes[i] == typeof(System.Int32))
{
row[i] = br.Read7BitInt();
}
else if (columnTypes[i] == typeof(System.Int64))
{
row[i] = br.Read7BitLong();
}
else if (columnTypes[i] == typeof(System.Decimal))
{
row[i] = br.ReadCompactDecimal();
}
else if (columnTypes[i] == typeof(System.DateTime))
{
row[i] = br.ReadCompactDateTime(TimeSpan.TicksPerMillisecond * 100);
}
else if (columnTypes[i] == typeof(bool))
{
row[i] = br.ReadBoolean();
}
}
}
return(table);
}
///////////////////////////////////////////////////////////////////////
// Can be used by Disctionary<X, List<long>>
public static List <long> ReadLongsList(BinaryTypesReader br, object objParam)
{
List <long> result = new List <long>();
SerializationUtils.DeserializeList(br, result, SerializationUtils.ReadLong, null);
return(result);
}
public static object DeserializeObject(byte[] buf, Type type, SerializerSettings settings)
{
using (MemoryStream ms = new MemoryStream(buf))
{
using (BinaryTypesReader br = new BinaryTypesReader(ms))
{
return(DeserializeObject(br, type, settings, null, null));
}
}
}
public static object DeserializeObject(byte[] buf, Type type)
{
using (MemoryStream ms = new MemoryStream(buf))
{
using (BinaryTypesReader br = new BinaryTypesReader(ms))
{
return(DeserializeObject(br, type));
}
}
}
public static void DeserializeList <T>(BinaryTypesReader br, List <T> list, ReadDataDelegate <T> itemReader, object objParam)
{
//Clear the list before work starts. In case the list is null it will throw exception
list.Clear();
int count = br.Read7BitInt();
for (int i = 0; i < count; i++)
{
T item = itemReader(br, objParam);
list.Add(item);
}
}
private static object DeserializeClass(BinaryTypesReader br, Type type)
{
var props = type.GetProperties(BindingFlags.Instance | BindingFlags.Public)
.OrderBy(x => x.MetadataToken);
var instance = Activator.CreateInstance(type);
foreach (var prop in props)
{
prop.SetValue(instance, DeserializeObject(br, prop.PropertyType));
}
return(instance);
}
public static void DeserializeDictionary <K, V>(
BinaryTypesReader br,
IDictionary <K, V> map,
ReadDataDelegate <K> keyReader,
object keyObjParam,
ReadDataDelegate <V> valReader,
object valObjParam)
{
int count = br.Read7BitInt();
for (int i = 0; i < count; i++)
{
K key = keyReader(br, keyObjParam);
V val = valReader(br, valObjParam);
map.Add(key, val);
}
}
internal static object DeserializeObject(BinaryTypesReader br, Type type, SerializerSettings settings, ISerializer serializer, ISerializerArg serializerArg)
{
serializer = GetSerializer(type, serializer);
if (serializer == null)
{
throw new Exception($"SerializeObject: serializer not found for type {type.FullName}");
}
if (type.IsClass && serializer.CommonNullHandle)
{
if (br.ReadBoolean() == false) //null
{
return(null);
}
}
return(serializer.Deserialize(br, type, settings, serializerArg));
}
///////////////////////////////////////////////////////////////////////
public static bool ReadBool(BinaryTypesReader br, object objParam)
{
return(br.ReadBoolean());
}
///////////////////////////////////////////////////////////////////////
public static decimal ReadCompactDecimal(BinaryTypesReader br, object objParam)
{
return(br.ReadCompactDecimal());
}
///////////////////////////////////////////////////////////////////////
public static byte[] ReadBytesArray(BinaryTypesReader br, object objParam)
{
return(br.ReadBytesArray());
}
///////////////////////////////////////////////////////////////////////
public static long ReadLong(BinaryTypesReader br, object objParam)
{
return(br.Read7BitLong());
}
///////////////////////////////////////////////////////////////////////
// Uses reflection - relatively slow!!!
public static T ReadEnum <T>(BinaryTypesReader br, object objParam) where T : IConvertible
{
long val = br.Read7BitLong();
return((T)Enum.ToObject(typeof(T), val));
}
///////////////////////////////////////////////////////////////////////
public static int ReadInt(BinaryTypesReader br, object objParam)
{
return(br.Read7BitInt());
}
///////////////////////////////////////////////////////////////////////
public static string ReadString(BinaryTypesReader br, object objParam)
{
return(br.ReadString());
}
private static object DeserializeObject(BinaryTypesReader br, Type type)
{
if (type.IsPrimitive)
{
switch (type.FullName)
{
case SystemTypeDefs.FullNameBoolean:
case SystemTypeDefs.FullNameByte:
case SystemTypeDefs.FullNameSByte:
case SystemTypeDefs.FullNameInt16:
case SystemTypeDefs.FullNameUInt16:
case SystemTypeDefs.FullNameInt32:
case SystemTypeDefs.FullNameUInt32:
case SystemTypeDefs.FullNameInt64:
case SystemTypeDefs.FullNameUInt64:
case SystemTypeDefs.FullNameChar:
{
var val = br.Read7BitLong();
return(Convert.ChangeType(val, type));
}
case SystemTypeDefs.FullNameSingle: // todo: compact
return(br.ReadSingle());
case SystemTypeDefs.FullNameDouble: // todo: compact
return(br.ReadDouble());
}
}
if (type.FullName == typeof(decimal).FullName)
{
return(br.ReadCompactDecimal());
}
if (type.IsEnum)
{
int val = (int)br.Read7BitLong();
return(Enum.ToObject(type, val));
}
if (type.IsValueType)
{
switch (type.FullName)
{
case SystemTypeDefs.FullNameDateTime:
return(new DateTime(br.Read7BitLong()));
}
}
if (type.IsClass)
{
switch (type.FullName)
{
case SystemTypeDefs.FullNameString:
return(br.ReadString());
default:
return(DeserializeClass(br, type));
}
}
return(null);
}
