public void Write(object value, ProtoWriter dest)
{
if (map == null)
{
#if TTD_LONGENUMS
ProtoWriter.WriteInt64(EnumToWire(value), dest);
#else
ProtoWriter.WriteInt32(EnumToWire(value), dest);
#endif
}
else
{
for (int i = 0; i < map.Length; i++)
{
if (object.Equals(map[i].TypedValue, value))
{
#if TTD_LONGENUMS
ProtoWriter.WriteInt64(map[i].WireValue, dest);
#else
ProtoWriter.WriteInt32(map[i].WireValue, dest);
#endif
return;
}
}
ProtoWriter.ThrowEnumException(dest, value);
}
}
public void writeDouble(double value, WireType wireType)
{
switch (wireType)
{
case WireType.Fixed32:
float f = (float)value;
if (Helpers.IsInfinity(f) &&
!Helpers.IsInfinity(value))
{
throw new OverflowException();
}
writeSingle(f, wireType);
return;
case WireType.Fixed64:
#if FEAT_SAFE
ProtoWriter.WriteInt64(BitConverter.ToInt64(BitConverter.GetBytes(value), 0), writer);
#else
writeInt64(*(long *)&value, wireType);
#endif
return;
default:
throw createException(wireType);
}
}
/// <summary>
/// Serialises the specified item.
/// </summary>
/// <param name="item">The item.</param>
/// <returns></returns>
/// <exception cref="System.NotSupportedException"></exception>
public byte[] Serialise(IAirEntity item)
{
var stream = new MemoryStream();
using (var writer = new ProtoWriter(stream, null, null))
{
writer.SetRootObject(item);
int fieldNumber = 1;
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Fixed64, writer);
ProtoWriter.WriteInt64(item.Id, writer);
var props = item.GetType()
.GetProperties()
.Where(IsAirMember)
.OrderBy(GetAirMemberOrder);
foreach (var prop in props)
{
var value = prop.GetGetMethod().Invoke(item, new object[] { });
if (value is string)
{
ProtoWriter.WriteFieldHeader(++fieldNumber, WireType.String, writer);
ProtoWriter.WriteString(value as string, writer);
}
else if (value is long)
{
ProtoWriter.WriteFieldHeader(++fieldNumber, WireType.Fixed64, writer);
ProtoWriter.WriteInt64((long)value, writer);
}
else if (value is DateTime)
{
ProtoWriter.WriteFieldHeader(++fieldNumber, WireType.Fixed64, writer);
ProtoWriter.WriteInt64(((DateTime)value).Ticks, writer);
}
else
{
throw new NotSupportedException();
}
}
}
return(stream.ToArray());
}
private static void Write(ActiveCodeReq activeCodeReq, ProtoWriter protoWrite)
{
long accountId = activeCodeReq.AccountId;
if (accountId != 0)
{
// Variant可变的
ProtoWriter.WriteFieldHeader(1, WireType.Variant, protoWrite);
ProtoWriter.WriteInt64(accountId, protoWrite);
}
string activeCode = activeCodeReq.ActiveCode;
if (!string.IsNullOrEmpty(activeCode))
{
ProtoWriter.WriteFieldHeader(2, WireType.String, protoWrite);
ProtoWriter.WriteString(activeCode, protoWrite);
}
ProtoWriter.AppendExtensionData(activeCodeReq, protoWrite);
}
public static void ProtoWrite(DataTable table, Stream stream)
{
using (ProtoWriter writer = new ProtoWriter(stream, null, null))
{
if (!string.IsNullOrEmpty(table.TableName))
{
ProtoWriter.WriteFieldHeader(1, WireType.String, writer);
ProtoWriter.WriteString(table.TableName, writer);
}
DataColumnCollection columns = table.Columns;
Action <object>[] actionArray = new Action <object> [columns.Count];
int index = 0;
foreach (DataColumn column in columns)
{
MappedType boolean;
Action <object> action;
Action <object> action2 = null;
Action <object> action3 = null;
Action <object> action4 = null;
Action <object> action5 = null;
Action <object> action6 = null;
Action <object> action7 = null;
Action <object> action8 = null;
Action <object> action9 = null;
Action <object> action10 = null;
Action <object> action11 = null;
Action <object> action12 = null;
ProtoWriter.WriteFieldHeader(2, WireType.StartGroup, writer);
SubItemToken token = ProtoWriter.StartSubItem(column, writer);
ProtoWriter.WriteFieldHeader(1, WireType.String, writer);
ProtoWriter.WriteString(column.ColumnName, writer);
ProtoWriter.WriteFieldHeader(2, WireType.Variant, writer);
switch (Type.GetTypeCode(column.DataType))
{
case TypeCode.Boolean:
boolean = MappedType.Boolean;
break;
case TypeCode.Byte:
boolean = MappedType.Byte;
break;
case TypeCode.Int16:
boolean = MappedType.Int16;
break;
case TypeCode.Int32:
boolean = MappedType.Int32;
break;
case TypeCode.Int64:
boolean = MappedType.Int64;
break;
case TypeCode.Double:
boolean = MappedType.Double;
break;
case TypeCode.Decimal:
boolean = MappedType.Decimal;
break;
case TypeCode.DateTime:
boolean = MappedType.DateTime;
break;
case TypeCode.String:
boolean = MappedType.String;
break;
default:
if (column.DataType == typeof(Guid))
{
boolean = MappedType.Guid;
}
else if (column.DataType == typeof(byte[]))
{
boolean = MappedType.Byte;
}
else
{
if (column.DataType != typeof(TimeSpan))
{
throw new NotSupportedException(column.DataType.Name);
}
boolean = MappedType.TimeSpan;
}
break;
}
ProtoWriter.WriteInt32((int)boolean, writer);
ProtoWriter.WriteFieldHeader(3, WireType.String, writer);
ProtoWriter.WriteString(column.Caption, writer);
ProtoWriter.EndSubItem(token, writer);
int field = index + 1;
switch (boolean)
{
case MappedType.Boolean:
if (action2 == null)
{
action2 = delegate(object value)
{
ProtoWriter.WriteFieldHeader(field, WireType.Variant, writer);
ProtoWriter.WriteBoolean(Convert.ToBoolean(value), writer);
};
}
action = action2;
break;
case MappedType.Byte:
if (action3 == null)
{
action3 = delegate(object value)
{
byte[] inArray = value as byte[];
string str = Convert.ToBase64String(inArray);
ProtoWriter.WriteFieldHeader(field, WireType.String, writer);
ProtoWriter.WriteString(str, writer);
};
}
action = action3;
break;
case MappedType.Double:
if (action4 == null)
{
action4 = delegate(object value)
{
ProtoWriter.WriteFieldHeader(field, WireType.Fixed64, writer);
ProtoWriter.WriteDouble(Convert.ToDouble(value), writer);
};
}
action = action4;
break;
case MappedType.Int16:
if (action7 == null)
{
action7 = delegate(object value)
{
ProtoWriter.WriteFieldHeader(field, WireType.Variant, writer);
ProtoWriter.WriteInt16((short)value, writer);
};
}
action = action7;
break;
case MappedType.Int32:
if (action8 == null)
{
action8 = delegate(object value)
{
ProtoWriter.WriteFieldHeader(field, WireType.Variant, writer);
ProtoWriter.WriteInt32(Convert.ToInt32(value), writer);
};
}
action = action8;
break;
case MappedType.Int64:
if (action9 == null)
{
action9 = delegate(object value)
{
ProtoWriter.WriteFieldHeader(field, WireType.Variant, writer);
ProtoWriter.WriteInt64((long)value, writer);
};
}
action = action9;
break;
case MappedType.String:
if (action5 == null)
{
action5 = delegate(object value)
{
ProtoWriter.WriteFieldHeader(field, WireType.String, writer);
ProtoWriter.WriteString(Convert.ToString(value), writer);
};
}
action = action5;
break;
case MappedType.Decimal:
if (action6 == null)
{
action6 = delegate(object value)
{
ProtoWriter.WriteFieldHeader(field, WireType.StartGroup, writer);
BclHelpers.WriteDecimal(Convert.ToDecimal(value), writer);
};
}
action = action6;
break;
case MappedType.Guid:
if (action10 == null)
{
action10 = delegate(object value)
{
ProtoWriter.WriteFieldHeader(field, WireType.StartGroup, writer);
BclHelpers.WriteGuid((Guid)value, writer);
};
}
action = action10;
break;
case MappedType.DateTime:
if (action11 == null)
{
action11 = delegate(object value)
{
ProtoWriter.WriteFieldHeader(field, WireType.StartGroup, writer);
BclHelpers.WriteDateTime(Convert.ToDateTime(value), writer);
};
}
action = action11;
break;
case MappedType.TimeSpan:
if (action12 == null)
{
action12 = delegate(object value)
{
ProtoWriter.WriteFieldHeader(field, WireType.StartGroup, writer);
if (value is TimeSpan)
{
BclHelpers.WriteTimeSpan((TimeSpan)value, writer);
}
else
{
BclHelpers.WriteTimeSpan(TimeSpan.Zero, writer);
}
};
}
action = action12;
break;
default:
throw new NotSupportedException(column.DataType.Name);
}
actionArray[index++] = action;
}
foreach (DataRow row in table.Rows)
{
index = 0;
ProtoWriter.WriteFieldHeader(3, WireType.StartGroup, writer);
SubItemToken token2 = ProtoWriter.StartSubItem(row, writer);
foreach (DataColumn column2 in columns)
{
object obj2 = row[column2];
if ((obj2 != null) && !(obj2 is DBNull))
{
actionArray[index](obj2);
}
index++;
}
ProtoWriter.EndSubItem(token2, writer);
}
}
}
public void Write(ProtoWriter dest, ref ProtoWriter.State state, object value)
{
ProtoWriter.WriteInt64((long)value, dest, ref state);
}
/// <summary>
/// This is the more "complete" version of Serialize, which handles single instances of mapped types.
/// The value is written as a complete field, including field-header and (for sub-objects) a
/// length-prefix
/// In addition to that, this provides support for:
/// - basic values; individual int / string / Guid / etc
/// - IEnumerable sequences of any type handled by TrySerializeAuxiliaryType
///
/// </summary>
internal bool TrySerializeAuxiliaryType(ProtoWriter writer, Type type, DataFormat format, int tag, object value)
{
if (type == null)
{
type = value.GetType();
}
TypeCode typecode = Type.GetTypeCode(type);
int modelKey;
// note the "ref type" here normalizes against proxies
WireType wireType = GetWireType(typecode, format, ref type, out modelKey);
if (modelKey >= 0)
{ // write the header, but defer to the model
ProtoWriter.WriteFieldHeader(tag, wireType, writer);
switch (wireType)
{
case WireType.None:
throw ProtoWriter.CreateException(writer);
case WireType.StartGroup:
case WireType.String:
// needs a wrapping length etc
SubItemToken token = ProtoWriter.StartSubItem(value, writer);
Serialize(modelKey, value, writer);
ProtoWriter.EndSubItem(token, writer);
return(true);
default:
Serialize(modelKey, value, writer);
return(true);
}
}
if (wireType != WireType.None)
{
ProtoWriter.WriteFieldHeader(tag, wireType, writer);
}
switch (typecode)
{
case TypeCode.Int16: ProtoWriter.WriteInt16((short)value, writer); return(true);
case TypeCode.Int32: ProtoWriter.WriteInt32((int)value, writer); return(true);
case TypeCode.Int64: ProtoWriter.WriteInt64((long)value, writer); return(true);
case TypeCode.UInt16: ProtoWriter.WriteUInt16((ushort)value, writer); return(true);
case TypeCode.UInt32: ProtoWriter.WriteUInt32((uint)value, writer); return(true);
case TypeCode.UInt64: ProtoWriter.WriteUInt64((ulong)value, writer); return(true);
case TypeCode.Boolean: ProtoWriter.WriteBoolean((bool)value, writer); return(true);
case TypeCode.SByte: ProtoWriter.WriteSByte((sbyte)value, writer); return(true);
case TypeCode.Byte: ProtoWriter.WriteByte((byte)value, writer); return(true);
case TypeCode.Char: ProtoWriter.WriteUInt16((ushort)(char)value, writer); return(true);
case TypeCode.Double: ProtoWriter.WriteDouble((double)value, writer); return(true);
case TypeCode.Single: ProtoWriter.WriteSingle((float)value, writer); return(true);
case TypeCode.DateTime: BclHelpers.WriteDateTime((DateTime)value, writer); return(true);
case TypeCode.Decimal: BclHelpers.WriteDecimal((decimal)value, writer); return(true);
case TypeCode.String: ProtoWriter.WriteString((string)value, writer); return(true);
}
if (type == typeof(byte[]))
{
ProtoWriter.WriteBytes((byte[])value, writer); return(true);
}
if (type == typeof(TimeSpan))
{
BclHelpers.WriteTimeSpan((TimeSpan)value, writer); return(true);
}
if (type == typeof(Guid))
{
BclHelpers.WriteGuid((Guid)value, writer); return(true);
}
if (type == typeof(Uri))
{
ProtoWriter.WriteString(((Uri)value).AbsoluteUri, writer); return(true);
}
// by now, we should have covered all the simple cases; if we wrote a field-header, we have
// forgotten something!
Helpers.DebugAssert(wireType == WireType.None);
// now attempt to handle sequences (including arrays and lists)
IEnumerable sequence = value as IEnumerable;
if (sequence != null)
{
foreach (object item in sequence)
{
if (item == null)
{
throw new NullReferenceException();
}
if (!TrySerializeAuxiliaryType(writer, null, format, tag, item))
{
ThrowUnexpectedType(item.GetType());
}
}
return(true);
}
return(false);
}
/// <summary>
/// 写出数据
/// </summary>
/// <param name="writer">写出目标</param>
/// <param name="obj">写出对象</param>
/// <param name="field_desc">字段描述</param>
/// <see cref="https://developers.google.com/protocol-buffers/docs/encoding"/>
private void write_object(ProtoWriter writer, object obj, FieldDescriptorProto field_desc)
{
try {
switch (field_desc.type)
{
case FieldDescriptorProto.Type.TYPE_DOUBLE: {
double val = Convert.ToDouble(obj);
ProtoWriter.WriteFieldHeader(field_desc.number, WireType.Fixed64, writer);
ProtoWriter.WriteDouble(val, writer);
break;
}
case FieldDescriptorProto.Type.TYPE_FLOAT: {
float val = Convert.ToSingle(obj);
ProtoWriter.WriteFieldHeader(field_desc.number, WireType.Fixed32, writer);
ProtoWriter.WriteSingle(val, writer);
break;
}
case FieldDescriptorProto.Type.TYPE_SINT64:
case FieldDescriptorProto.Type.TYPE_INT64: {
long val = Convert.ToInt64(obj);
ProtoWriter.WriteFieldHeader(field_desc.number, WireType.Variant, writer);
ProtoWriter.WriteInt64(val, writer);
break;
}
case FieldDescriptorProto.Type.TYPE_UINT64: {
ulong val = Convert.ToUInt64(obj);
ProtoWriter.WriteFieldHeader(field_desc.number, WireType.Variant, writer);
ProtoWriter.WriteUInt64(val, writer);
break;
}
case FieldDescriptorProto.Type.TYPE_SINT32:
case FieldDescriptorProto.Type.TYPE_INT32: {
int val = Convert.ToInt32(obj);
ProtoWriter.WriteFieldHeader(field_desc.number, WireType.Variant, writer);
ProtoWriter.WriteInt32(val, writer);
break;
}
case FieldDescriptorProto.Type.TYPE_FIXED64: {
long val = Convert.ToInt64(obj);
ProtoWriter.WriteFieldHeader(field_desc.number, WireType.Fixed64, writer);
ProtoWriter.WriteInt64(val, writer);
break;
}
case FieldDescriptorProto.Type.TYPE_FIXED32: {
int val = Convert.ToInt32(obj);
ProtoWriter.WriteFieldHeader(field_desc.number, WireType.Fixed32, writer);
ProtoWriter.WriteInt32(val, writer);
break;
}
case FieldDescriptorProto.Type.TYPE_BOOL: {
bool val = Convert.ToBoolean(obj);
ProtoWriter.WriteFieldHeader(field_desc.number, WireType.Variant, writer);
ProtoWriter.WriteBoolean(val, writer);
break;
}
case FieldDescriptorProto.Type.TYPE_STRING: {
string val = Convert.ToString(obj);
ProtoWriter.WriteFieldHeader(field_desc.number, WireType.String, writer);
ProtoWriter.WriteString(val, writer);
break;
}
//case FieldDescriptorProto.Type.TYPE_GROUP: // deprecated
// break;
case FieldDescriptorProto.Type.TYPE_MESSAGE:
if (!(obj is DynamicMessage))
{
lastError.AddLast(string.Format("try add {0} to {1}.{2}.{3}, but not a message", obj.ToString(), msgDescriptor.Package, msgDescriptor.Protocol.name, field_desc.name));
break;
}
ProtoWriter.WriteFieldHeader(field_desc.number, WireType.String, writer);
SubItemToken token = ProtoWriter.StartSubItem(null, writer);
try {
((DynamicMessage)obj).Serialize(writer);
} catch (Exception e) {
lastError.AddLast(string.Format("{0}.{1}.{2} => {3}", msgDescriptor.Package, msgDescriptor.Protocol.name, field_desc.name, e.Message));
}
ProtoWriter.EndSubItem(token, writer);
break;
case FieldDescriptorProto.Type.TYPE_BYTES: {
if (!(obj is byte[]))
{
throw new ArgumentException("{0} should be a byte[]", field_desc.name);
}
ProtoWriter.WriteFieldHeader(field_desc.number, WireType.String, writer);
ProtoWriter.WriteBytes((byte[])obj, writer);
break;
}
case FieldDescriptorProto.Type.TYPE_UINT32: {
uint val = Convert.ToUInt32(obj);
ProtoWriter.WriteFieldHeader(field_desc.number, WireType.Variant, writer);
ProtoWriter.WriteUInt32(val, writer);
break;
}
case FieldDescriptorProto.Type.TYPE_ENUM: {
int val = Convert.ToInt32(obj);
ProtoWriter.WriteFieldHeader(field_desc.number, WireType.Variant, writer);
ProtoWriter.WriteInt32(val, writer);
break;
}
case FieldDescriptorProto.Type.TYPE_SFIXED32: {
uint val = Convert.ToUInt32(obj);
ProtoWriter.WriteFieldHeader(field_desc.number, WireType.Fixed32, writer);
ProtoWriter.WriteUInt32(val, writer);
break;
}
case FieldDescriptorProto.Type.TYPE_SFIXED64: {
ulong val = Convert.ToUInt64(obj);
ProtoWriter.WriteFieldHeader(field_desc.number, WireType.Fixed64, writer);
ProtoWriter.WriteUInt64(val, writer);
break;
}
default:
// unsupported field
lastError.AddLast(string.Format("field type {0} in {1}.{2}.{3} unsupported", field_desc.type.ToString(), msgDescriptor.Package, msgDescriptor.Protocol.name, field_desc.name));
break;
}
} catch (Exception e) {
lastError.AddLast(string.Format("{0}.{1}.{2} {3}", msgDescriptor.Package, msgDescriptor.Protocol.name, field_desc.name, e.ToString()));
}
}
private static void WriteTimeSpanImpl(TimeSpan timeSpan, ProtoWriter dest, DateTimeKind kind)
{
if (dest == null)
{
throw new ArgumentNullException(nameof(dest));
}
switch (dest.WireType)
{
case WireType.String:
case WireType.StartGroup:
TimeSpanScale scale;
long value = timeSpan.Ticks;
if (timeSpan == TimeSpan.MaxValue)
{
value = 1;
scale = TimeSpanScale.MinMax;
}
else if (timeSpan == TimeSpan.MinValue)
{
value = -1;
scale = TimeSpanScale.MinMax;
}
else if (value % TimeSpan.TicksPerDay == 0)
{
scale = TimeSpanScale.Days;
value /= TimeSpan.TicksPerDay;
}
else if (value % TimeSpan.TicksPerHour == 0)
{
scale = TimeSpanScale.Hours;
value /= TimeSpan.TicksPerHour;
}
else if (value % TimeSpan.TicksPerMinute == 0)
{
scale = TimeSpanScale.Minutes;
value /= TimeSpan.TicksPerMinute;
}
else if (value % TimeSpan.TicksPerSecond == 0)
{
scale = TimeSpanScale.Seconds;
value /= TimeSpan.TicksPerSecond;
}
else if (value % TimeSpan.TicksPerMillisecond == 0)
{
scale = TimeSpanScale.Milliseconds;
value /= TimeSpan.TicksPerMillisecond;
}
else
{
scale = TimeSpanScale.Ticks;
}
SubItemToken token = ProtoWriter.StartSubItemWithoutWritingHeader(null, dest);
if (value != 0)
{
ProtoWriter.WriteFieldHeader(FieldTimeSpanValue, WireType.SignedVariant, dest);
ProtoWriter.WriteInt64(value, dest);
}
if (scale != TimeSpanScale.Days)
{
ProtoWriter.WriteFieldHeader(FieldTimeSpanScale, WireType.Variant, dest);
ProtoWriter.WriteInt32((int)scale, dest);
}
if (kind != DateTimeKind.Unspecified)
{
ProtoWriter.WriteFieldHeader(FieldTimeSpanKind, WireType.Variant, dest);
ProtoWriter.WriteInt32((int)kind, dest);
}
ProtoWriter.EndSubItem(token, dest);
break;
case WireType.Fixed64:
ProtoWriter.WriteInt64(timeSpan.Ticks, dest);
break;
default:
throw new ProtoException("Unexpected wire-type: " + dest.WireType.ToString());
}
}
private static void WriteRecord(IDataReader reader, List <ProtoBufDataColumn> columns, ProtoWriter writer, int recordIndex)
{
ProtoWriter.WriteFieldHeader(FieldHeaders.Record, WireType.StartGroup, writer);
var recordToken = ProtoWriter.StartSubItem(recordIndex, writer);
for (var i = 0; i < columns.Count; i++)
{
var fieldHeader = i + 1;
if (!reader.IsDBNull(columns[i].Ordinal))
{
switch (columns[i].ProtoBufDataType)
{
case ProtoBufDataType.Bool:
ProtoWriter.WriteFieldHeader(fieldHeader, WireType.Variant, writer);
ProtoWriter.WriteBoolean(reader.GetBoolean(columns[i].Ordinal), writer);
break;
case ProtoBufDataType.Byte:
ProtoWriter.WriteFieldHeader(fieldHeader, WireType.Variant, writer);
ProtoWriter.WriteByte(reader.GetByte(columns[i].Ordinal), writer);
break;
case ProtoBufDataType.ByteArray:
ProtoWriter.WriteFieldHeader(fieldHeader, WireType.String, writer);
var value = reader[columns[i].Ordinal];
ProtoWriter.WriteBytes((byte[])value, 0, ((byte[])value).Length, writer);
break;
case ProtoBufDataType.Char:
ProtoWriter.WriteFieldHeader(fieldHeader, WireType.Variant, writer);
ProtoWriter.WriteInt16((short)reader.GetChar(columns[i].Ordinal), writer);
break;
case ProtoBufDataType.CharArray:
ProtoWriter.WriteFieldHeader(fieldHeader, WireType.String, writer);
ProtoWriter.WriteString(new string((char[])reader[columns[i].Ordinal]), writer);
break;
case ProtoBufDataType.DateTime:
ProtoWriter.WriteFieldHeader(fieldHeader, WireType.StartGroup, writer);
BclHelpers.WriteDateTime(reader.GetDateTime(columns[i].Ordinal), writer);
break;
case ProtoBufDataType.Decimal:
ProtoWriter.WriteFieldHeader(fieldHeader, WireType.StartGroup, writer);
BclHelpers.WriteDecimal(reader.GetDecimal(columns[i].Ordinal), writer);
break;
case ProtoBufDataType.Double:
ProtoWriter.WriteFieldHeader(fieldHeader, WireType.Fixed64, writer);
ProtoWriter.WriteDouble(reader.GetDouble(columns[i].Ordinal), writer);
break;
case ProtoBufDataType.Float:
ProtoWriter.WriteFieldHeader(fieldHeader, WireType.Fixed32, writer);
ProtoWriter.WriteSingle(reader.GetFloat(columns[i].Ordinal), writer);
break;
case ProtoBufDataType.Guid:
ProtoWriter.WriteFieldHeader(fieldHeader, WireType.StartGroup, writer);
BclHelpers.WriteGuid(reader.GetGuid(columns[i].Ordinal), writer);
break;
case ProtoBufDataType.Int:
ProtoWriter.WriteFieldHeader(fieldHeader, WireType.Variant, writer);
ProtoWriter.WriteInt32(reader.GetInt32(columns[i].Ordinal), writer);
break;
case ProtoBufDataType.Long:
ProtoWriter.WriteFieldHeader(fieldHeader, WireType.Variant, writer);
ProtoWriter.WriteInt64(reader.GetInt64(columns[i].Ordinal), writer);
break;
case ProtoBufDataType.Short:
ProtoWriter.WriteFieldHeader(fieldHeader, WireType.Variant, writer);
ProtoWriter.WriteInt16(reader.GetInt16(columns[i].Ordinal), writer);
break;
case ProtoBufDataType.String:
ProtoWriter.WriteFieldHeader(fieldHeader, WireType.String, writer);
ProtoWriter.WriteString(reader.GetString(columns[i].Ordinal), writer);
break;
case ProtoBufDataType.TimeSpan:
ProtoWriter.WriteFieldHeader(fieldHeader, WireType.StartGroup, writer);
BclHelpers.WriteTimeSpan((TimeSpan)reader[columns[i].Ordinal], writer);
break;
}
}
}
ProtoWriter.EndSubItem(recordToken, writer);
}
public void WriteRow(IDataRecord row)
{
int fieldIndex = 1;
ProtoWriter.WriteFieldHeader(3, WireType.StartGroup, writer);
SubItemToken token = ProtoWriter.StartSubItem(rowIndex, writer);
foreach (ProtoDataColumn column in columns)
{
object value = row[column.ColumnIndex];
if (value == null || value is DBNull || (options.SerializeEmptyArraysAsNull && IsZeroLengthArray(value)))
{
// don't write anything
}
else
{
switch (column.ProtoDataType)
{
case ProtoDataType.String:
ProtoWriter.WriteFieldHeader(fieldIndex, WireType.String, writer);
ProtoWriter.WriteString((string)value, writer);
break;
case ProtoDataType.Short:
ProtoWriter.WriteFieldHeader(fieldIndex, WireType.Variant, writer);
ProtoWriter.WriteInt16((short)value, writer);
break;
case ProtoDataType.Decimal:
ProtoWriter.WriteFieldHeader(fieldIndex, WireType.StartGroup, writer);
BclHelpers.WriteDecimal((decimal)value, writer);
break;
case ProtoDataType.Int:
ProtoWriter.WriteFieldHeader(fieldIndex, WireType.Variant, writer);
ProtoWriter.WriteInt32((int)value, writer);
break;
case ProtoDataType.Guid:
ProtoWriter.WriteFieldHeader(fieldIndex, WireType.StartGroup, writer);
BclHelpers.WriteGuid((Guid)value, writer);
break;
case ProtoDataType.DateTime:
ProtoWriter.WriteFieldHeader(fieldIndex, WireType.StartGroup, writer);
BclHelpers.WriteDateTime((DateTime)value, writer);
break;
case ProtoDataType.Bool:
ProtoWriter.WriteFieldHeader(fieldIndex, WireType.Variant, writer);
ProtoWriter.WriteBoolean((bool)value, writer);
break;
case ProtoDataType.Byte:
ProtoWriter.WriteFieldHeader(fieldIndex, WireType.Variant, writer);
ProtoWriter.WriteByte((byte)value, writer);
break;
case ProtoDataType.Char:
ProtoWriter.WriteFieldHeader(fieldIndex, WireType.Variant, writer);
ProtoWriter.WriteInt16((short)(char)value, writer);
break;
case ProtoDataType.Double:
ProtoWriter.WriteFieldHeader(fieldIndex, WireType.Fixed64, writer);
ProtoWriter.WriteDouble((double)value, writer);
break;
case ProtoDataType.Float:
ProtoWriter.WriteFieldHeader(fieldIndex, WireType.Fixed32, writer);
ProtoWriter.WriteSingle((float)value, writer);
break;
case ProtoDataType.Long:
ProtoWriter.WriteFieldHeader(fieldIndex, WireType.Variant, writer);
ProtoWriter.WriteInt64((long)value, writer);
break;
case ProtoDataType.ByteArray:
ProtoWriter.WriteFieldHeader(fieldIndex, WireType.String, writer);
ProtoWriter.WriteBytes((byte[])value, 0, ((byte[])value).Length, writer);
break;
case ProtoDataType.CharArray:
ProtoWriter.WriteFieldHeader(fieldIndex, WireType.String, writer);
ProtoWriter.WriteString(new string((char[])value), writer);
break;
case ProtoDataType.TimeSpan:
ProtoWriter.WriteFieldHeader(fieldIndex, WireType.StartGroup, writer);
BclHelpers.WriteTimeSpan((TimeSpan)value, writer);
break;
default:
throw new UnsupportedColumnTypeException(
ConvertProtoDataType.ToClrType(column.ProtoDataType));
}
}
fieldIndex++;
}
ProtoWriter.EndSubItem(token, writer);
rowIndex++;
}
public void Write(object value, ProtoWriter dest)
{
ProtoWriter.WriteInt64(ValueObject.Value <long>(value), dest);
}
private void WriteColumn(ProtoWriter writer, IReactiveColumn column, int fieldId, int rowId)
{
if (column.Type == typeof(int))
{
ProtoWriter.WriteFieldHeader(fieldId, WireType.Variant, writer);
ProtoWriter.WriteInt32(_table.GetValue <int>(column.ColumnId, rowId), writer);
}
else if (column.Type == typeof(short))
{
ProtoWriter.WriteFieldHeader(fieldId, WireType.Variant, writer);
ProtoWriter.WriteInt16(_table.GetValue <short>(column.ColumnId, rowId), writer);
}
else if (column.Type == typeof(string))
{
ProtoWriter.WriteFieldHeader(fieldId, WireType.String, writer);
var value = _table.GetValue <string>(column.ColumnId, rowId);
// Console.WriteLine("Writing string {0}", value);
ProtoWriter.WriteString(value ?? string.Empty, writer);
}
else if (column.Type == typeof(bool))
{
ProtoWriter.WriteFieldHeader(fieldId, WireType.Variant, writer);
ProtoWriter.WriteBoolean(_table.GetValue <bool>(column.ColumnId, rowId), writer);
}
else if (column.Type == typeof(double))
{
ProtoWriter.WriteFieldHeader(fieldId, WireType.Fixed64, writer);
ProtoWriter.WriteDouble(_table.GetValue <double>(column.ColumnId, rowId), writer);
}
else if (column.Type == typeof(long))
{
ProtoWriter.WriteFieldHeader(fieldId, WireType.Variant, writer);
ProtoWriter.WriteInt64(_table.GetValue <long>(column.ColumnId, rowId), writer);
}
else if (column.Type == typeof(decimal))
{
ProtoWriter.WriteFieldHeader(fieldId, WireType.StartGroup, writer);
BclHelpers.WriteDecimal(_table.GetValue <decimal>(column.ColumnId, rowId), writer);
}
else if (column.Type == typeof(DateTime))
{
ProtoWriter.WriteFieldHeader(fieldId, WireType.StartGroup, writer);
BclHelpers.WriteDateTime(_table.GetValue <DateTime>(column.ColumnId, rowId), writer);
}
else if (column.Type == typeof(TimeSpan))
{
ProtoWriter.WriteFieldHeader(fieldId, WireType.StartGroup, writer);
BclHelpers.WriteTimeSpan(_table.GetValue <TimeSpan>(column.ColumnId, rowId), writer);
}
else if (column.Type == typeof(Guid))
{
ProtoWriter.WriteFieldHeader(fieldId, WireType.StartGroup, writer);
BclHelpers.WriteGuid(_table.GetValue <Guid>(column.ColumnId, rowId), writer);
}
else if (column.Type == typeof(float))
{
ProtoWriter.WriteFieldHeader(fieldId, WireType.Fixed32, writer);
ProtoWriter.WriteSingle(_table.GetValue <float>(column.ColumnId, rowId), writer);
}
else if (column.Type == typeof(byte))
{
ProtoWriter.WriteFieldHeader(fieldId, WireType.Variant, writer);
ProtoWriter.WriteByte(_table.GetValue <byte>(column.ColumnId, rowId), writer);
}
else if (column.Type == typeof(char))
{
ProtoWriter.WriteFieldHeader(fieldId, WireType.Variant, writer);
ProtoWriter.WriteInt16((short)_table.GetValue <char>(column.ColumnId, rowId), writer);
}
}
public static void WriteRecord(ProtoWriterContext context, int recordIndex, IDataRecord record)
{
ProtoWriter.WriteFieldHeader(RecordFieldHeader, WireType.StartGroup, context.Writer);
context.StartSubItem(recordIndex);
for (var columnIndex = 0; columnIndex < context.Columns.Count; columnIndex++)
{
// The check whether record[columnIndex] == null is removed due to the fact that value types have to be
// boxed into an object just to check whether the field value is null. This creates garbage, thus has
// impact on garbage collection. Removing the check should not be a problem as IDataRecord.IsDBNull
// should be sufficient (tested with SqlDataReader, SqlLiteDataReader, and DataTableReader).
if (record.IsDBNull(columnIndex))
{
continue;
}
var fieldNumber = columnIndex + 1;
switch (context.Columns[columnIndex].ProtoDataType)
{
case ProtoDataType.String:
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.String, context.Writer);
ProtoWriter.WriteString(record.GetString(columnIndex), context.Writer);
break;
case ProtoDataType.Short:
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Variant, context.Writer);
ProtoWriter.WriteInt16(record.GetInt16(columnIndex), context.Writer);
break;
case ProtoDataType.Decimal:
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.StartGroup, context.Writer);
BclHelpers.WriteDecimal(record.GetDecimal(columnIndex), context.Writer);
break;
case ProtoDataType.Int:
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Variant, context.Writer);
ProtoWriter.WriteInt32(record.GetInt32(columnIndex), context.Writer);
break;
case ProtoDataType.Guid:
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.StartGroup, context.Writer);
BclHelpers.WriteGuid(record.GetGuid(columnIndex), context.Writer);
break;
case ProtoDataType.DateTime:
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.StartGroup, context.Writer);
BclHelpers.WriteDateTime(record.GetDateTime(columnIndex), context.Writer);
break;
case ProtoDataType.Bool:
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Variant, context.Writer);
ProtoWriter.WriteBoolean(record.GetBoolean(columnIndex), context.Writer);
break;
case ProtoDataType.Byte:
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Variant, context.Writer);
ProtoWriter.WriteByte(record.GetByte(columnIndex), context.Writer);
break;
case ProtoDataType.Char:
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Variant, context.Writer);
ProtoWriter.WriteInt16((short)record.GetChar(columnIndex), context.Writer);
break;
case ProtoDataType.Double:
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Fixed64, context.Writer);
ProtoWriter.WriteDouble(record.GetDouble(columnIndex), context.Writer);
break;
case ProtoDataType.Float:
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Fixed32, context.Writer);
ProtoWriter.WriteSingle(record.GetFloat(columnIndex), context.Writer);
break;
case ProtoDataType.Long:
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Variant, context.Writer);
ProtoWriter.WriteInt64(record.GetInt64(columnIndex), context.Writer);
break;
case ProtoDataType.ByteArray:
var bytes = (byte[])record[columnIndex];
if (bytes.Length != 0 || !context.Options.SerializeEmptyArraysAsNull)
{
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.String, context.Writer);
ProtoWriter.WriteBytes(bytes, 0, bytes.Length, context.Writer);
}
break;
case ProtoDataType.CharArray:
var characters = (char[])record[columnIndex];
if (characters.Length != 0 || !context.Options.SerializeEmptyArraysAsNull)
{
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.String, context.Writer);
ProtoWriter.WriteString(new string(characters), context.Writer);
}
break;
case ProtoDataType.TimeSpan:
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.StartGroup, context.Writer);
BclHelpers.WriteTimeSpan((TimeSpan)record[columnIndex], context.Writer);
break;
default:
throw new NotSupportedException($"The data type '{context.Columns[columnIndex].DataType.Name}' is not supported. The supported data types are: {TypeHelper.GetSupportedDataTypes()}.");
}
}
context.EndSubItem();
}
internal bool TrySerializeAuxiliaryType(ProtoWriter writer, Type type, DataFormat format, int tag, object value, bool isInsideList)
{
if (type == null)
{
type = value.GetType();
}
ProtoTypeCode typeCode = Helpers.GetTypeCode(type);
int modelKey;
WireType wireType = GetWireType(typeCode, format, ref type, out modelKey);
if (modelKey >= 0)
{
if (Helpers.IsEnum(type))
{
Serialize(modelKey, value, writer);
return(true);
}
ProtoWriter.WriteFieldHeader(tag, wireType, writer);
switch (wireType)
{
case WireType.None:
throw ProtoWriter.CreateException(writer);
case WireType.String:
case WireType.StartGroup:
{
SubItemToken token = ProtoWriter.StartSubItem(value, writer);
Serialize(modelKey, value, writer);
ProtoWriter.EndSubItem(token, writer);
return(true);
}
default:
Serialize(modelKey, value, writer);
return(true);
}
}
if (wireType != WireType.None)
{
ProtoWriter.WriteFieldHeader(tag, wireType, writer);
}
switch (typeCode)
{
case ProtoTypeCode.Int16:
ProtoWriter.WriteInt16((short)value, writer);
return(true);
case ProtoTypeCode.Int32:
ProtoWriter.WriteInt32((int)value, writer);
return(true);
case ProtoTypeCode.Int64:
ProtoWriter.WriteInt64((long)value, writer);
return(true);
case ProtoTypeCode.UInt16:
ProtoWriter.WriteUInt16((ushort)value, writer);
return(true);
case ProtoTypeCode.UInt32:
ProtoWriter.WriteUInt32((uint)value, writer);
return(true);
case ProtoTypeCode.UInt64:
ProtoWriter.WriteUInt64((ulong)value, writer);
return(true);
case ProtoTypeCode.Boolean:
ProtoWriter.WriteBoolean((bool)value, writer);
return(true);
case ProtoTypeCode.SByte:
ProtoWriter.WriteSByte((sbyte)value, writer);
return(true);
case ProtoTypeCode.Byte:
ProtoWriter.WriteByte((byte)value, writer);
return(true);
case ProtoTypeCode.Char:
ProtoWriter.WriteUInt16((char)value, writer);
return(true);
case ProtoTypeCode.Double:
ProtoWriter.WriteDouble((double)value, writer);
return(true);
case ProtoTypeCode.Single:
ProtoWriter.WriteSingle((float)value, writer);
return(true);
case ProtoTypeCode.DateTime:
BclHelpers.WriteDateTime((DateTime)value, writer);
return(true);
case ProtoTypeCode.Decimal:
BclHelpers.WriteDecimal((decimal)value, writer);
return(true);
case ProtoTypeCode.String:
ProtoWriter.WriteString((string)value, writer);
return(true);
case ProtoTypeCode.ByteArray:
ProtoWriter.WriteBytes((byte[])value, writer);
return(true);
case ProtoTypeCode.TimeSpan:
BclHelpers.WriteTimeSpan((TimeSpan)value, writer);
return(true);
case ProtoTypeCode.Guid:
BclHelpers.WriteGuid((Guid)value, writer);
return(true);
case ProtoTypeCode.Uri:
ProtoWriter.WriteString(((Uri)value).AbsoluteUri, writer);
return(true);
default:
{
IEnumerable enumerable = value as IEnumerable;
if (enumerable != null)
{
if (isInsideList)
{
throw CreateNestedListsNotSupported();
}
foreach (object item in enumerable)
{
if (item == null)
{
throw new NullReferenceException();
}
if (!TrySerializeAuxiliaryType(writer, null, format, tag, item, isInsideList: true))
{
ThrowUnexpectedType(item.GetType());
}
}
return(true);
}
return(false);
}
}
}
// Token: 0x06003589 RID: 13705 RVA: 0x00134ABC File Offset: 0x00132EBC
public void Write(object value, ProtoWriter dest)
{
ProtoWriter.WriteInt64((long)value, dest);
}
void WriteField(ProtoWriter writer, object memberV, Type memberT, int fieldNumber)
{
if (memberT == typeof(int))
{
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Variant, writer);
ProtoWriter.WriteInt32((int)memberV, writer);
}
else if (memberT == typeof(uint))
{
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Variant, writer);
ProtoWriter.WriteUInt32((uint)memberV, writer);
}
else if (memberT == typeof(bool))
{
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Variant, writer);
ProtoWriter.WriteBoolean((bool)memberV, writer);
}
else if (memberT == typeof(byte))
{
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Variant, writer);
ProtoWriter.WriteByte((byte)memberV, writer);
}
else if (memberT == typeof(sbyte))
{
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Variant, writer);
ProtoWriter.WriteSByte((sbyte)memberV, writer);
}
else if (memberT == typeof(float))
{
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Variant, writer);
ProtoWriter.WriteSingle((float)memberV, writer);
}
else if (memberT == typeof(double))
{
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Variant, writer);
ProtoWriter.WriteDouble((double)memberV, writer);
}
else if (memberT == typeof(short))
{
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Variant, writer);
ProtoWriter.WriteInt16((short)memberV, writer);
}
else if (memberT == typeof(ushort))
{
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Variant, writer);
ProtoWriter.WriteUInt16((ushort)memberV, writer);
}
else if (memberT == typeof(long))
{
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Variant, writer);
ProtoWriter.WriteInt64((long)memberV, writer);
}
else if (memberT == typeof(ulong))
{
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Variant, writer);
ProtoWriter.WriteUInt64((ulong)memberV, writer);
}
else if (memberT == typeof(string))
{
string str = (string)memberV;
if (!string.IsNullOrEmpty(str))
{
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.String, writer);
ProtoWriter.WriteString(str, writer);
}
}
else if (memberT == typeof(byte[]))
{
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.String, writer);
ProtoWriter.WriteBytes((byte[])memberV, writer);
}
else if (memberT == typeof(SInstance))
{
SInstance subSinstance = (SInstance)memberV;
if (subSinstance != null)
{
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.String, writer);
SubItemToken st = ProtoWriter.StartSubItem(null, writer);
WriteSInstance(writer, subSinstance);
ProtoWriter.EndSubItem(st, writer);
}
}
else
{
throw new NotImplementedException("未实现类型: " + memberT);
}
}