public object Deserialize(Stream source, string className)
{
CLS_Type_Class sClass = m_clsEnv.GetTypeByKeywordQuiet(className) as CLS_Type_Class;
if (sClass == null)
{
throw new NotImplementedException("未实现类型: " + className);
}
if (!sClass.compiled)
{
RuntimeCompilerClass(className);
}
CLS_Content.Value retVal = (sClass.function as SType).New(m_clsContent, m_emptyParams);
SInstance sInstance = (SInstance)retVal.value;
ProtoReader reader = null;
try
{
reader = ProtoReader.Create(source, null, null, ProtoReader.TO_EOF);
ReadSInstance(reader, sInstance, m_clsEnv);
reader.CheckFullyConsumed();
return(sInstance);
}
finally
{
ProtoReader.Recycle(reader);
}
}
/// <summary>
/// All this does is call GetExtendedValuesTyped with the correct type for "instance";
/// this ensures that we don't get issues with subclasses declaring conflicting types -
/// the caller must respect the fields defined for the type they pass in.
/// </summary>
internal static IEnumerable GetExtendedValues(TypeModel model, Type type, IExtensible instance, int tag, DataFormat format, bool singleton, bool allowDefinedTag)
{
if (instance == null)
{
throw new ArgumentNullException(nameof(instance));
}
if (tag <= 0)
{
throw new ArgumentOutOfRangeException(nameof(tag));
}
IExtension extn = instance.GetExtensionObject(false);
if (extn == null)
{
yield break;
}
Stream stream = extn.BeginQuery();
object value = null;
ProtoReader reader = null;
try
{
SerializationContext ctx = new SerializationContext();
reader = ProtoReader.Create(stream, model, ctx, ProtoReader.TO_EOF);
while (model.TryDeserializeAuxiliaryType(reader, format, tag, type, ref value, true, true, false, false, null) && value != null)
{
if (!singleton)
{
yield return(value);
value = null; // fresh item each time
}
}
if (singleton && value != null)
{
yield return(value);
}
}
finally
{
ProtoReader.Recycle(reader);
extn.EndQuery(stream);
}
}
object Deserialize <T>(TypeModel model, byte[] data)
{
Type type = typeof(T);
int key = model.GetKey(ref type);
using (MemoryStream ms = new MemoryStream(data))
{
ProtoReader reader = null;
try
{
reader = ProtoReader.Create(ms, model, null, ProtoReader.TO_EOF);
return(model.Deserialize(key, null, reader));
}
finally
{
ProtoReader.Recycle(reader);
}
}
}
public object Deserialize(Stream source, object value, Type type, int length, SerializationContext context)
{
bool noAutoCreate = PrepareDeserialize(value, ref type);
ProtoReader protoReader = null;
try
{
protoReader = ProtoReader.Create(source, this, context, length);
if (value != null)
{
protoReader.SetRootObject(value);
}
object result = DeserializeCore(protoReader, type, value, noAutoCreate);
protoReader.CheckFullyConsumed();
return(result);
}
finally
{
ProtoReader.Recycle(protoReader);
}
}
public object Deserialize(Stream source, object value, Type type, SerializationContext context)
{
bool autoCreate = this.PrepareDeserialize(value, ref type);
ProtoReader reader = null;
object result;
try
{
reader = ProtoReader.Create(source, this, context, -1);
if (value != null)
{
reader.SetRootObject(value);
}
object obj = this.DeserializeCore(reader, type, value, autoCreate);
reader.CheckFullyConsumed();
result = obj;
}
finally
{
ProtoReader.Recycle(reader);
}
return(result);
}
public static T Deserialize(Stream stream, T obj)
{
if (_invoke == null)
{
return(_default(stream));
}
obj = ProtoSerializeHelper <T> .CreateInstance(obj);
ProtoReader source = null;
try
{
source = ProtoReader.Create(stream, RuntimeTypeModel.Default, null, ProtoReader.TO_EOF);
source.SetRootObject(obj);
obj = _invoke(source, obj);
source.CheckFullyConsumed();
return(obj);
}
finally
{
ProtoReader.Recycle(source);
}
}
/// <summary>
/// Reads the body of an object
/// </summary>
public override object ReadObject(System.Xml.XmlDictionaryReader reader, bool verifyObjectName)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
reader.MoveToContent();
bool isSelfClosed = reader.IsEmptyElement, isNil = reader.GetAttribute("nil") == "true";
reader.ReadStartElement(PROTO_ELEMENT);
// explicitly null
if (isNil)
{
if (!isSelfClosed)
{
reader.ReadEndElement();
}
return(null);
}
if (isSelfClosed) // no real content
{
if (isList || isEnum)
{
return(model.Deserialize(Stream.Null, null, type, null));
}
ProtoReader protoReader = null;
try
{
protoReader = ProtoReader.Create(Stream.Null, model, null, ProtoReader.TO_EOF);
return(model.Deserialize(key, null, protoReader));
}
finally
{
ProtoReader.Recycle(protoReader);
}
}
object result;
Helpers.DebugAssert(reader.CanReadBinaryContent, "CanReadBinaryContent");
using (MemoryStream ms = new MemoryStream(reader.ReadContentAsBase64()))
{
if (isList || isEnum)
{
result = model.Deserialize(ms, null, type, null);
}
else
{
ProtoReader protoReader = null;
try
{
protoReader = ProtoReader.Create(ms, model, null, ProtoReader.TO_EOF);
result = model.Deserialize(key, null, protoReader);
}
finally
{
ProtoReader.Recycle(protoReader);
}
}
}
reader.ReadEndElement();
return(result);
}
/// <summary>
/// All this does is call GetExtendedValuesTyped with the correct type for "instance";
/// this ensures that we don't get issues with subclasses declaring conflicting types -
/// the caller must respect the fields defined for the type they pass in.
/// </summary>
internal static IEnumerable GetExtendedValues(TypeModel model, Type type, IExtensible instance, int tag, DataFormat format, bool singleton, bool allowDefinedTag)
{
#if FEAT_IKVM
throw new NotSupportedException();
#else
if (instance == null)
{
throw new ArgumentNullException("instance");
}
if (tag <= 0)
{
throw new ArgumentOutOfRangeException("tag");
}
IExtension extn = instance.GetExtensionObject(false);
if (extn == null)
{
#if FX11
return(new object[0]);
#else
yield break;
#endif
}
#if FX11
BasicList result = new BasicList();
#endif
Stream stream = extn.BeginQuery();
object value = null;
ProtoReader reader = null;
try {
SerializationContext ctx = new SerializationContext();
reader = ProtoReader.Create(stream, model, ctx, ProtoReader.TO_EOF);
while (model.TryDeserializeAuxiliaryType(reader, format, tag, type, ref value, true, false, false, false) && value != null)
{
if (!singleton)
{
#if FX11
result.Add(value);
#else
yield return(value);
#endif
value = null; // fresh item each time
}
}
if (singleton && value != null)
{
#if FX11
result.Add(value);
#else
yield return(value);
#endif
}
#if FX11
object[] resultArr = new object[result.Count];
result.CopyTo(resultArr, 0);
return(resultArr);
#endif
} finally {
ProtoReader.Recycle(reader);
extn.EndQuery(stream);
}
#endif
}
private object DeserializeWithLengthPrefix(Stream source, object value, Type type, PrefixStyle style, int expectedField, Serializer.TypeResolver resolver, out int bytesRead, out bool haveObject, SerializationContext context)
{
haveObject = false;
bytesRead = 0;
if (type == null && (style != PrefixStyle.Base128 || resolver == null))
{
throw new InvalidOperationException("A type must be provided unless base-128 prefixing is being used in combination with a resolver");
}
int num;
bool flag2;
do
{
bool flag = expectedField > 0 || resolver != null;
num = ProtoReader.ReadLengthPrefix(source, flag, style, out int fieldNumber, out int bytesRead2);
if (bytesRead2 == 0)
{
return(value);
}
bytesRead += bytesRead2;
if (num < 0)
{
return(value);
}
if (style == PrefixStyle.Base128)
{
if (flag && expectedField == 0 && type == null && resolver != null)
{
type = resolver(fieldNumber);
flag2 = (type == null);
}
else
{
flag2 = (expectedField != fieldNumber);
}
}
else
{
flag2 = false;
}
if (flag2)
{
if (num == int.MaxValue)
{
throw new InvalidOperationException();
}
ProtoReader.Seek(source, num, null);
bytesRead += num;
}
}while (flag2);
ProtoReader protoReader = null;
try
{
protoReader = ProtoReader.Create(source, this, context, num);
int key = GetKey(ref type);
if (key >= 0 && !Helpers.IsEnum(type))
{
value = Deserialize(key, value, protoReader);
}
else if (!TryDeserializeAuxiliaryType(protoReader, DataFormat.Default, 1, type, ref value, skipOtherFields: true, asListItem: false, autoCreate: true, insideList: false) && num != 0)
{
ThrowUnexpectedType(type);
}
bytesRead += protoReader.Position;
haveObject = true;
return(value);
}
finally
{
ProtoReader.Recycle(protoReader);
}
}
public object DeepClone(object value)
{
if (value == null)
{
return(null);
}
Type type = value.GetType();
int key = GetKey(ref type);
if (key >= 0 && !Helpers.IsEnum(type))
{
using (MemoryStream memoryStream = new MemoryStream())
{
using (ProtoWriter protoWriter = new ProtoWriter(memoryStream, this, null))
{
protoWriter.SetRootObject(value);
Serialize(key, value, protoWriter);
protoWriter.Close();
}
memoryStream.Position = 0L;
ProtoReader protoReader = null;
try
{
protoReader = ProtoReader.Create(memoryStream, this, null, -1);
return(Deserialize(key, null, protoReader));
}
finally
{
ProtoReader.Recycle(protoReader);
}
}
}
if (type == typeof(byte[]))
{
byte[] array = (byte[])value;
byte[] array2 = new byte[array.Length];
Helpers.BlockCopy(array, 0, array2, 0, array.Length);
return(array2);
}
if (GetWireType(Helpers.GetTypeCode(type), DataFormat.Default, ref type, out int modelKey) != WireType.None && modelKey < 0)
{
return(value);
}
using (MemoryStream memoryStream2 = new MemoryStream())
{
using (ProtoWriter protoWriter2 = new ProtoWriter(memoryStream2, this, null))
{
if (!TrySerializeAuxiliaryType(protoWriter2, type, DataFormat.Default, 1, value, isInsideList: false))
{
ThrowUnexpectedType(type);
}
protoWriter2.Close();
}
memoryStream2.Position = 0L;
ProtoReader reader = null;
try
{
reader = ProtoReader.Create(memoryStream2, this, null, -1);
value = null;
TryDeserializeAuxiliaryType(reader, DataFormat.Default, 1, type, ref value, skipOtherFields: true, asListItem: false, autoCreate: true, insideList: false);
return(value);
}
finally
{
ProtoReader.Recycle(reader);
}
}
}
private object DeserializeWithLengthPrefix(Stream source, object value, Type type, PrefixStyle style, int expectedField, Serializer.TypeResolver resolver, out int bytesRead, out bool haveObject, SerializationContext context)
{
haveObject = false;
bytesRead = 0;
if (type == null && (style != PrefixStyle.Base128 || resolver == null))
{
throw new InvalidOperationException("A type must be provided unless base-128 prefixing is being used in combination with a resolver");
}
while (true)
{
bool expectPrefix = expectedField > 0 || resolver != null;
int actualField;
int tmpBytesRead;
int len = ProtoReader.ReadLengthPrefix(source, expectPrefix, style, out actualField, out tmpBytesRead);
if (tmpBytesRead == 0)
{
break;
}
bytesRead += tmpBytesRead;
if (len < 0)
{
return(value);
}
bool skip;
if (style == PrefixStyle.Base128)
{
if (expectPrefix && expectedField == 0 && type == null && resolver != null)
{
type = resolver(actualField);
skip = (type == null);
}
else
{
skip = (expectedField != actualField);
}
}
else
{
skip = false;
}
if (skip)
{
if (len == 2147483647)
{
goto Block_12;
}
ProtoReader.Seek(source, len, null);
bytesRead += len;
}
if (!skip)
{
goto Block_13;
}
}
return(value);
Block_12:
throw new InvalidOperationException();
Block_13:
ProtoReader reader = null;
object result;
try
{
int len;
reader = ProtoReader.Create(source, this, context, len);
int key = this.GetKey(ref type);
if (key >= 0 && !Helpers.IsEnum(type))
{
value = this.Deserialize(key, value, reader);
}
else
{
if (!this.TryDeserializeAuxiliaryType(reader, DataFormat.Default, 1, type, ref value, true, false, true, false) && len != 0)
{
TypeModel.ThrowUnexpectedType(type);
}
}
bytesRead += reader.Position;
haveObject = true;
result = value;
}
finally
{
ProtoReader.Recycle(reader);
}
return(result);
}
public object DeepClone(object value)
{
if (value == null)
{
return(null);
}
Type type = value.GetType();
int key = this.GetKey(ref type);
object result;
if (key >= 0 && !Helpers.IsEnum(type))
{
using (MemoryStream ms = new MemoryStream())
{
using (ProtoWriter writer = new ProtoWriter(ms, this, null))
{
writer.SetRootObject(value);
this.Serialize(key, value, writer);
writer.Close();
}
ms.Position = 0L;
ProtoReader reader = null;
try
{
reader = ProtoReader.Create(ms, this, null, -1);
result = this.Deserialize(key, null, reader);
return(result);
}
finally
{
ProtoReader.Recycle(reader);
}
}
}
if (type == typeof(byte[]))
{
byte[] orig = (byte[])value;
byte[] clone = new byte[orig.Length];
Helpers.BlockCopy(orig, 0, clone, 0, orig.Length);
return(clone);
}
int modelKey;
if (this.GetWireType(Helpers.GetTypeCode(type), DataFormat.Default, ref type, out modelKey) != WireType.None && modelKey < 0)
{
return(value);
}
using (MemoryStream ms2 = new MemoryStream())
{
using (ProtoWriter writer2 = new ProtoWriter(ms2, this, null))
{
if (!this.TrySerializeAuxiliaryType(writer2, type, DataFormat.Default, 1, value, false))
{
TypeModel.ThrowUnexpectedType(type);
}
writer2.Close();
}
ms2.Position = 0L;
ProtoReader reader2 = null;
try
{
reader2 = ProtoReader.Create(ms2, this, null, -1);
value = null;
this.TryDeserializeAuxiliaryType(reader2, DataFormat.Default, 1, type, ref value, true, false, true, false);
result = value;
}
finally
{
ProtoReader.Recycle(reader2);
}
}
return(result);
}
