mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-16 17:10:20 -10:00
The shim/bridge between Mono and the RS implementation of XmlObjectSerializer, DataContractSerializer, etc. did not properly invoke the constructor required by ISerializable, as it completely omitted passing the populated SerializationInfo object. Fixes https://bugzilla.xamarin.com/show_bug.cgi?id=37171
619 lines
23 KiB
C#
619 lines
23 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Xml;
|
|
|
|
namespace System.Runtime.Serialization
|
|
{
|
|
internal partial class XmlFormatReaderGenerator
|
|
{
|
|
partial class CriticalHelper
|
|
{
|
|
internal XmlFormatClassReaderDelegate GenerateClassReader(ClassDataContract classContract)
|
|
{
|
|
return (XmlReaderDelegator xr, XmlObjectSerializerReadContext ctx, XmlDictionaryString [] memberNames, XmlDictionaryString [] memberNamespaces) => new XmlFormatReaderInterpreter (classContract).ReadFromXml (xr, ctx, memberNames, memberNamespaces);
|
|
}
|
|
|
|
internal XmlFormatCollectionReaderDelegate GenerateCollectionReader(CollectionDataContract collectionContract)
|
|
{
|
|
return (XmlReaderDelegator xr, XmlObjectSerializerReadContext ctx, XmlDictionaryString inm, XmlDictionaryString ins, CollectionDataContract cc) => new XmlFormatReaderInterpreter (collectionContract, false).ReadCollectionFromXml (xr, ctx, inm, ins, cc);
|
|
}
|
|
|
|
internal XmlFormatGetOnlyCollectionReaderDelegate GenerateGetOnlyCollectionReader(CollectionDataContract collectionContract)
|
|
{
|
|
return (XmlReaderDelegator xr, XmlObjectSerializerReadContext ctx, XmlDictionaryString inm, XmlDictionaryString ins, CollectionDataContract cc) => new XmlFormatReaderInterpreter (collectionContract, true).ReadGetOnlyCollectionFromXml (xr, ctx, inm, ins, cc);
|
|
}
|
|
}
|
|
}
|
|
|
|
class XmlFormatReaderInterpreter
|
|
{
|
|
public XmlFormatReaderInterpreter (ClassDataContract classContract)
|
|
{
|
|
this.classContract = classContract;
|
|
}
|
|
|
|
public XmlFormatReaderInterpreter (CollectionDataContract collectionContract, bool isGetOnly)
|
|
{
|
|
this.collectionContract = collectionContract;
|
|
this.is_get_only_collection = isGetOnly;
|
|
}
|
|
|
|
bool is_get_only_collection;
|
|
|
|
ClassDataContract classContract;
|
|
|
|
CollectionDataContract collectionContract;
|
|
|
|
object objectLocal;
|
|
Type objectType;
|
|
XmlReaderDelegator xmlReader;
|
|
XmlObjectSerializerReadContext context;
|
|
|
|
XmlDictionaryString [] memberNames = null;
|
|
XmlDictionaryString [] memberNamespaces = null;
|
|
XmlDictionaryString itemName = null;
|
|
XmlDictionaryString itemNamespace = null;
|
|
|
|
public object ReadFromXml (XmlReaderDelegator xmlReader, XmlObjectSerializerReadContext context, XmlDictionaryString[] memberNames, XmlDictionaryString[] memberNamespaces)
|
|
{
|
|
// InitArgs()
|
|
this.xmlReader = xmlReader;
|
|
this.context = context;
|
|
this.memberNames = memberNames;
|
|
this.memberNamespaces = memberNamespaces;
|
|
|
|
//DemandSerializationFormatterPermission(classContract);
|
|
//DemandMemberAccessPermission(memberAccessFlag);
|
|
CreateObject (classContract);
|
|
|
|
context.AddNewObject (objectLocal);
|
|
InvokeOnDeserializing (classContract);
|
|
|
|
string objectId = null;
|
|
|
|
if (HasFactoryMethod (classContract))
|
|
objectId = context.GetObjectId ();
|
|
if (classContract.IsISerializable)
|
|
ReadISerializable (classContract);
|
|
else
|
|
ReadClass (classContract);
|
|
bool isFactoryType = InvokeFactoryMethod (classContract, objectId);
|
|
if (Globals.TypeOfIDeserializationCallback.IsAssignableFrom (classContract.UnderlyingType))
|
|
((IDeserializationCallback) objectLocal).OnDeserialization (null);
|
|
InvokeOnDeserialized(classContract);
|
|
if (objectId == null || !isFactoryType) {
|
|
|
|
// Do a conversion back from DateTimeOffsetAdapter to DateTimeOffset after deserialization.
|
|
// DateTimeOffsetAdapter is used here for deserialization purposes to bypass the ISerializable implementation
|
|
// on DateTimeOffset; which does not work in partial trust.
|
|
|
|
if (classContract.UnderlyingType == Globals.TypeOfDateTimeOffsetAdapter)
|
|
objectLocal = DateTimeOffsetAdapter.GetDateTimeOffset ((DateTimeOffsetAdapter) objectLocal);
|
|
// else - do we have to call CodeInterpreter.ConvertValue()? I guess not...
|
|
}
|
|
return objectLocal;
|
|
}
|
|
|
|
public object ReadCollectionFromXml (XmlReaderDelegator xmlReader, XmlObjectSerializerReadContext context, XmlDictionaryString itemName, XmlDictionaryString itemNamespace, CollectionDataContract collectionContract)
|
|
{
|
|
#region GenerateCollectionReaderHelper
|
|
// InitArgs()
|
|
this.xmlReader = xmlReader;
|
|
this.context = context;
|
|
this.itemName = itemName;
|
|
this.itemNamespace = itemNamespace;
|
|
|
|
this.collectionContract = collectionContract;
|
|
|
|
#endregion
|
|
|
|
ReadCollection (collectionContract);
|
|
|
|
return objectLocal;
|
|
}
|
|
|
|
public void ReadGetOnlyCollectionFromXml (XmlReaderDelegator xmlReader, XmlObjectSerializerReadContext context, XmlDictionaryString itemName, XmlDictionaryString itemNamespace, CollectionDataContract collectionContract)
|
|
{
|
|
#region GenerateCollectionReaderHelper
|
|
// InitArgs()
|
|
this.xmlReader = xmlReader;
|
|
this.context = context;
|
|
this.itemName = itemName;
|
|
this.itemNamespace = itemNamespace;
|
|
|
|
this.collectionContract = collectionContract;
|
|
|
|
#endregion
|
|
|
|
ReadGetOnlyCollection (collectionContract);
|
|
}
|
|
|
|
void CreateObject (ClassDataContract classContract)
|
|
{
|
|
Type type = objectType = classContract.UnderlyingType;
|
|
if (type.IsValueType && !classContract.IsNonAttributedType)
|
|
type = Globals.TypeOfValueType;
|
|
|
|
if (classContract.UnderlyingType == Globals.TypeOfDBNull)
|
|
objectLocal = DBNull.Value;
|
|
else if (classContract.IsNonAttributedType) {
|
|
if (type.IsValueType)
|
|
objectLocal = FormatterServices.GetUninitializedObject (type);
|
|
else
|
|
objectLocal = classContract.GetNonAttributedTypeConstructor ().Invoke (new object [0]);
|
|
}
|
|
else
|
|
objectLocal = CodeInterpreter.ConvertValue (XmlFormatReaderGenerator.UnsafeGetUninitializedObject (DataContract.GetIdForInitialization (classContract)), Globals.TypeOfObject, type);
|
|
}
|
|
|
|
void InvokeOnDeserializing (ClassDataContract classContract)
|
|
{
|
|
if (classContract.BaseContract != null)
|
|
InvokeOnDeserializing (classContract.BaseContract);
|
|
if (classContract.OnDeserializing != null)
|
|
classContract.OnDeserializing.Invoke (objectLocal, new object [] {context.GetStreamingContext ()});
|
|
}
|
|
|
|
void InvokeOnDeserialized (ClassDataContract classContract)
|
|
{
|
|
if (classContract.BaseContract != null)
|
|
InvokeOnDeserialized (classContract.BaseContract);
|
|
if (classContract.OnDeserialized != null)
|
|
classContract.OnDeserialized.Invoke (objectLocal, new object [] {context.GetStreamingContext ()});
|
|
}
|
|
|
|
bool HasFactoryMethod (ClassDataContract classContract)
|
|
{
|
|
return Globals.TypeOfIObjectReference.IsAssignableFrom (classContract.UnderlyingType);
|
|
}
|
|
|
|
bool InvokeFactoryMethod (ClassDataContract classContract, string objectId)
|
|
{
|
|
if (HasFactoryMethod (classContract)) {
|
|
objectLocal = CodeInterpreter.ConvertValue (context.GetRealObject ((IObjectReference) objectLocal, objectId), Globals.TypeOfObject, classContract.UnderlyingType);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void ReadISerializable (ClassDataContract classContract)
|
|
{
|
|
ConstructorInfo ctor = classContract.GetISerializableConstructor ();
|
|
var info = context.ReadSerializationInfo (xmlReader, classContract.UnderlyingType);
|
|
ctor.Invoke (objectLocal, new object [] {info, context.GetStreamingContext ()});
|
|
}
|
|
|
|
void ReadClass (ClassDataContract classContract)
|
|
{
|
|
if (classContract.HasExtensionData) {
|
|
ExtensionDataObject extensionData = new ExtensionDataObject ();
|
|
ReadMembers (classContract, extensionData);
|
|
ClassDataContract currentContract = classContract;
|
|
while (currentContract != null) {
|
|
MethodInfo extensionDataSetMethod = currentContract.ExtensionDataSetMethod;
|
|
if (extensionDataSetMethod != null)
|
|
extensionDataSetMethod.Invoke (objectLocal, new object [] {extensionData});
|
|
currentContract = currentContract.BaseContract;
|
|
}
|
|
}
|
|
else
|
|
ReadMembers (classContract, null);
|
|
}
|
|
|
|
void ReadMembers (ClassDataContract classContract, ExtensionDataObject extensionData)
|
|
{
|
|
int memberCount = classContract.MemberNames.Length;
|
|
context.IncrementItemCount (memberCount);
|
|
|
|
int memberIndex = -1;
|
|
|
|
int firstRequiredMember;
|
|
bool[] requiredMembers = GetRequiredMembers (classContract, out firstRequiredMember);
|
|
bool hasRequiredMembers = (firstRequiredMember < memberCount);
|
|
int requiredIndex = hasRequiredMembers ? firstRequiredMember : memberCount;
|
|
|
|
while (XmlObjectSerializerReadContext.MoveToNextElement (xmlReader)) {
|
|
int idx; // used as in "switch (idx)" in the original source.
|
|
if (hasRequiredMembers)
|
|
idx = context.GetMemberIndexWithRequiredMembers (xmlReader, memberNames, memberNamespaces, memberIndex, (int) requiredIndex, extensionData);
|
|
else
|
|
idx = context.GetMemberIndex (xmlReader, memberNames, memberNamespaces, memberIndex, extensionData);
|
|
|
|
if (memberCount > 0)
|
|
ReadMembers (idx, classContract, requiredMembers, ref memberIndex, ref requiredIndex);
|
|
}
|
|
|
|
if (hasRequiredMembers)
|
|
{
|
|
if (requiredIndex < memberCount)
|
|
XmlObjectSerializerReadContext.ThrowRequiredMemberMissingException (xmlReader, memberIndex, requiredIndex, memberNames);
|
|
}
|
|
}
|
|
|
|
int ReadMembers (int index, ClassDataContract classContract, bool [] requiredMembers, ref int memberIndex, ref int requiredIndex)
|
|
{
|
|
int memberCount = (classContract.BaseContract == null) ? 0 : ReadMembers (index, classContract.BaseContract, requiredMembers,
|
|
ref memberIndex, ref requiredIndex);
|
|
|
|
if (memberCount <= index && index < memberCount + classContract.Members.Count) {
|
|
DataMember dataMember = classContract.Members [index - memberCount];
|
|
Type memberType = dataMember.MemberType;
|
|
if (dataMember.IsRequired) {
|
|
int nextRequiredIndex = index + 1;
|
|
for (; nextRequiredIndex < requiredMembers.Length; nextRequiredIndex++)
|
|
if (requiredMembers [nextRequiredIndex])
|
|
break;
|
|
requiredIndex = nextRequiredIndex;
|
|
}
|
|
|
|
if (dataMember.IsGetOnlyCollection) {
|
|
var value = CodeInterpreter.GetMember (dataMember.MemberInfo, objectLocal);
|
|
context.StoreCollectionMemberInfo (value);
|
|
ReadValue (memberType, dataMember.Name, classContract.StableName.Namespace);
|
|
} else {
|
|
var value = ReadValue (memberType, dataMember.Name, classContract.StableName.Namespace);
|
|
CodeInterpreter.SetMember (dataMember.MemberInfo, objectLocal, value);
|
|
}
|
|
memberIndex = index;
|
|
}
|
|
return memberCount + classContract.Members.Count;
|
|
}
|
|
|
|
bool[] GetRequiredMembers (ClassDataContract contract, out int firstRequiredMember)
|
|
{
|
|
int memberCount = contract.MemberNames.Length;
|
|
bool [] requiredMembers = new bool [memberCount];
|
|
GetRequiredMembers (contract, requiredMembers);
|
|
for (firstRequiredMember = 0; firstRequiredMember < memberCount; firstRequiredMember++)
|
|
if (requiredMembers [firstRequiredMember])
|
|
break;
|
|
return requiredMembers;
|
|
}
|
|
|
|
int GetRequiredMembers (ClassDataContract contract, bool[] requiredMembers)
|
|
{
|
|
int memberCount = (contract.BaseContract == null) ? 0 : GetRequiredMembers (contract.BaseContract, requiredMembers);
|
|
List<DataMember> members = contract.Members;
|
|
for (int i = 0; i < members.Count; i++, memberCount++)
|
|
requiredMembers [memberCount] = members [i].IsRequired;
|
|
return memberCount;
|
|
}
|
|
|
|
object ReadValue (Type type, string name, string ns)
|
|
{
|
|
var valueType = type;
|
|
object value = null;
|
|
bool shouldAssignNullableValue = false;
|
|
int nullables = 0;
|
|
while (type.IsGenericType && type.GetGenericTypeDefinition () == Globals.TypeOfNullable) {
|
|
nullables++;
|
|
type = type.GetGenericArguments () [0];
|
|
}
|
|
|
|
PrimitiveDataContract primitiveContract = PrimitiveDataContract.GetPrimitiveDataContract (type);
|
|
if ((primitiveContract != null && primitiveContract.UnderlyingType != Globals.TypeOfObject) || nullables != 0 || type.IsValueType) {
|
|
context.ReadAttributes (xmlReader);
|
|
string objectId = context.ReadIfNullOrRef (xmlReader, type, DataContract.IsTypeSerializable (type));
|
|
// Deserialize null
|
|
if (objectId == Globals.NullObjectId) {
|
|
|
|
if (nullables != 0)
|
|
value = Activator.CreateInstance (valueType);
|
|
else if (type.IsValueType)
|
|
throw new SerializationException (SR.GetString (SR.ValueTypeCannotBeNull, DataContract.GetClrTypeFullName (type)));
|
|
else
|
|
value = null;
|
|
} else if (objectId == string.Empty) {
|
|
// Deserialize value
|
|
|
|
// Compare against Globals.NewObjectId, which is set to string.Empty
|
|
|
|
objectId = context.GetObjectId ();
|
|
|
|
if (type.IsValueType) {
|
|
if (!string.IsNullOrEmpty (objectId))
|
|
throw new SerializationException (SR.GetString (SR.ValueTypeCannotHaveId, DataContract.GetClrTypeFullName(type)));
|
|
}
|
|
object innerValueRead = null;
|
|
if (nullables != 0)
|
|
shouldAssignNullableValue = true;
|
|
|
|
if (primitiveContract != null && primitiveContract.UnderlyingType != Globals.TypeOfObject) {
|
|
value = primitiveContract.XmlFormatReaderMethod.Invoke (xmlReader, new object [0]);
|
|
if (!type.IsValueType)
|
|
context.AddNewObject (value);
|
|
}
|
|
else
|
|
value = InternalDeserialize (type, name, ns);
|
|
} else {
|
|
// Deserialize ref
|
|
if (type.IsValueType)
|
|
throw new SerializationException (SR.GetString (SR.ValueTypeCannotHaveRef, DataContract.GetClrTypeFullName (type)));
|
|
else
|
|
value = CodeInterpreter.ConvertValue (context.GetExistingObject (objectId, type, name, ns), Globals.TypeOfObject, type);
|
|
}
|
|
|
|
if (shouldAssignNullableValue) {
|
|
if (objectId != Globals.NullObjectId)
|
|
value = WrapNullableObject (type, value, valueType, nullables);
|
|
}
|
|
}
|
|
else
|
|
value = InternalDeserialize (type, name, ns);
|
|
|
|
return value;
|
|
}
|
|
|
|
object InternalDeserialize (Type type, string name, string ns)
|
|
{
|
|
Type declaredType = type.IsPointer ? Globals.TypeOfReflectionPointer : type;
|
|
var obj = context.InternalDeserialize (xmlReader, DataContract.GetId (declaredType.TypeHandle), declaredType.TypeHandle, name, ns);
|
|
|
|
if (type.IsPointer)
|
|
// wow, there is no way to convert void* to object in strongly typed way...
|
|
return XmlFormatGeneratorStatics.UnboxPointer.Invoke (null, new object [] {obj});
|
|
else
|
|
return CodeInterpreter.ConvertValue (obj, Globals.TypeOfObject, type);
|
|
}
|
|
|
|
object WrapNullableObject (Type innerType, object innerValue, Type outerType, int nullables)
|
|
{
|
|
var outerValue = innerValue;
|
|
for (int i = 1; i < nullables; i++) {
|
|
Type type = Globals.TypeOfNullable.MakeGenericType (innerType);
|
|
outerValue = Activator.CreateInstance (type, new object[] { outerValue });
|
|
innerType = type;
|
|
}
|
|
return Activator.CreateInstance (outerType, new object[] { outerValue });
|
|
}
|
|
|
|
|
|
void ReadCollection (CollectionDataContract collectionContract)
|
|
{
|
|
Type type = collectionContract.UnderlyingType;
|
|
Type itemType = collectionContract.ItemType;
|
|
bool isArray = (collectionContract.Kind == CollectionKind.Array);
|
|
|
|
ConstructorInfo constructor = collectionContract.Constructor;
|
|
|
|
if (type.IsInterface) {
|
|
switch (collectionContract.Kind) {
|
|
case CollectionKind.GenericDictionary:
|
|
type = Globals.TypeOfDictionaryGeneric.MakeGenericType (itemType.GetGenericArguments ());
|
|
constructor = type.GetConstructor (BindingFlags.Instance | BindingFlags.Public, null, Globals.EmptyTypeArray, null);
|
|
break;
|
|
case CollectionKind.Dictionary:
|
|
type = Globals.TypeOfHashtable;
|
|
constructor = XmlFormatGeneratorStatics.HashtableCtor;
|
|
break;
|
|
case CollectionKind.Collection:
|
|
case CollectionKind.GenericCollection:
|
|
case CollectionKind.Enumerable:
|
|
case CollectionKind.GenericEnumerable:
|
|
case CollectionKind.List:
|
|
case CollectionKind.GenericList:
|
|
type = itemType.MakeArrayType ();
|
|
isArray = true;
|
|
break;
|
|
}
|
|
}
|
|
string itemName = collectionContract.ItemName;
|
|
string itemNs = collectionContract.StableName.Namespace;
|
|
|
|
if (!isArray) {
|
|
if (type.IsValueType)
|
|
// FIXME: this is not what the original code does.
|
|
objectLocal = FormatterServices.GetUninitializedObject (type);
|
|
else {
|
|
objectLocal = constructor.Invoke (new object [0]);
|
|
context.AddNewObject (objectLocal);
|
|
}
|
|
}
|
|
|
|
int size = context.GetArraySize ();
|
|
|
|
string objectId = context.GetObjectId ();
|
|
|
|
bool canReadPrimitiveArray = false, readResult = false;
|
|
if (isArray && TryReadPrimitiveArray (type, itemType, size, out readResult))
|
|
canReadPrimitiveArray = true;
|
|
|
|
if (!readResult) {
|
|
if (size == -1) {
|
|
|
|
object growingCollection = null;
|
|
if (isArray)
|
|
growingCollection = Array.CreateInstance (itemType, 32);
|
|
|
|
int i = 0;
|
|
// FIXME: I cannot find i++ part, but without that it won't work as expected.
|
|
for (; i < int.MaxValue; i++) {
|
|
if (IsStartElement (this.itemName, this.itemNamespace)) {
|
|
context.IncrementItemCount (1);
|
|
object value = ReadCollectionItem (collectionContract, itemType, itemName, itemNs);
|
|
if (isArray) {
|
|
MethodInfo ensureArraySizeMethod = XmlFormatGeneratorStatics.EnsureArraySizeMethod.MakeGenericMethod (itemType);
|
|
growingCollection = ensureArraySizeMethod.Invoke (null, new object [] {growingCollection, i});
|
|
((Array) growingCollection).SetValue (value, i);
|
|
} else {
|
|
StoreCollectionValue (objectLocal, itemType, value, collectionContract);
|
|
}
|
|
}
|
|
else if (IsEndElement ())
|
|
break;
|
|
else
|
|
HandleUnexpectedItemInCollection (ref i);
|
|
}
|
|
|
|
if (isArray) {
|
|
MethodInfo trimArraySizeMethod = XmlFormatGeneratorStatics.TrimArraySizeMethod.MakeGenericMethod (itemType);
|
|
objectLocal = trimArraySizeMethod.Invoke (null, new object [] {growingCollection, i});
|
|
context.AddNewObjectWithId (objectId, objectLocal);
|
|
}
|
|
} else {
|
|
context.IncrementItemCount (size);
|
|
if (isArray) {
|
|
objectLocal = Array.CreateInstance (itemType, size);
|
|
context.AddNewObject (objectLocal);
|
|
}
|
|
// FIXME: I cannot find j++ part, but without that it won't work as expected.
|
|
for (int j = 0; j < size; j++) {
|
|
if (IsStartElement (this.itemName, this.itemNamespace)) {
|
|
var itemValue = ReadCollectionItem (collectionContract, itemType, itemName, itemNs);
|
|
if (isArray)
|
|
((Array) objectLocal).SetValue (itemValue, j);
|
|
else
|
|
StoreCollectionValue (objectLocal, itemType, itemValue, collectionContract);
|
|
}
|
|
else
|
|
HandleUnexpectedItemInCollection (ref j);
|
|
}
|
|
context.CheckEndOfArray (xmlReader, size, this.itemName, this.itemNamespace);
|
|
}
|
|
}
|
|
if (canReadPrimitiveArray)
|
|
context.AddNewObjectWithId (objectId, objectLocal);
|
|
}
|
|
|
|
void ReadGetOnlyCollection (CollectionDataContract collectionContract)
|
|
{
|
|
Type type = collectionContract.UnderlyingType;
|
|
Type itemType = collectionContract.ItemType;
|
|
bool isArray = (collectionContract.Kind == CollectionKind.Array);
|
|
string itemName = collectionContract.ItemName;
|
|
string itemNs = collectionContract.StableName.Namespace;
|
|
|
|
objectLocal = context.GetCollectionMember ();
|
|
|
|
//check that items are actually going to be deserialized into the collection
|
|
if (IsStartElement (this.itemName, this.itemNamespace)) {
|
|
if (objectLocal == null)
|
|
XmlObjectSerializerReadContext.ThrowNullValueReturnedForGetOnlyCollectionException (type);
|
|
else {
|
|
int size = 0;
|
|
if (isArray)
|
|
size = ((Array) objectLocal).Length;
|
|
context.AddNewObject (objectLocal);
|
|
for (int i = 0; i < int.MaxValue;) {
|
|
if (IsStartElement (this.itemName, this.itemNamespace)) {
|
|
context.IncrementItemCount (1);
|
|
var value = ReadCollectionItem (collectionContract, itemType, itemName, itemNs);
|
|
if (isArray) {
|
|
if (size == i)
|
|
XmlObjectSerializerReadContext.ThrowArrayExceededSizeException (size, type);
|
|
else
|
|
((Array) objectLocal).SetValue (value, i);
|
|
} else {
|
|
StoreCollectionValue (objectLocal, itemType, value, collectionContract);
|
|
}
|
|
}
|
|
else if (IsEndElement())
|
|
break;
|
|
else
|
|
HandleUnexpectedItemInCollection (ref i);
|
|
}
|
|
context.CheckEndOfArray (xmlReader, size, this.itemName, this.itemNamespace);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool TryReadPrimitiveArray (Type type, Type itemType, int size, out bool readResult)
|
|
{
|
|
readResult = false;
|
|
PrimitiveDataContract primitiveContract = PrimitiveDataContract.GetPrimitiveDataContract (itemType);
|
|
if (primitiveContract == null)
|
|
return false;
|
|
|
|
string readArrayMethod = null;
|
|
switch (Type.GetTypeCode (itemType))
|
|
{
|
|
case TypeCode.Boolean:
|
|
readArrayMethod = "TryReadBooleanArray";
|
|
break;
|
|
case TypeCode.DateTime:
|
|
readArrayMethod = "TryReadDateTimeArray";
|
|
break;
|
|
case TypeCode.Decimal:
|
|
readArrayMethod = "TryReadDecimalArray";
|
|
break;
|
|
case TypeCode.Int32:
|
|
readArrayMethod = "TryReadInt32Array";
|
|
break;
|
|
case TypeCode.Int64:
|
|
readArrayMethod = "TryReadInt64Array";
|
|
break;
|
|
case TypeCode.Single:
|
|
readArrayMethod = "TryReadSingleArray";
|
|
break;
|
|
case TypeCode.Double:
|
|
readArrayMethod = "TryReadDoubleArray";
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
if (readArrayMethod != null) {
|
|
var mi = typeof (XmlReaderDelegator).GetMethod (readArrayMethod, Globals.ScanAllMembers);
|
|
var args = new object [] {context, itemName, itemNamespace, size, objectLocal};
|
|
readResult = (bool) mi.Invoke (xmlReader, args);
|
|
objectLocal = args.Last ();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
object ReadCollectionItem (CollectionDataContract collectionContract, Type itemType, string itemName, string itemNs)
|
|
{
|
|
if (collectionContract.Kind == CollectionKind.Dictionary || collectionContract.Kind == CollectionKind.GenericDictionary) {
|
|
context.ResetAttributes ();
|
|
return CodeInterpreter.ConvertValue (collectionContract.ItemContract.ReadXmlValue (xmlReader, context), Globals.TypeOfObject, itemType);
|
|
}
|
|
else
|
|
return ReadValue (itemType, itemName, itemNs);
|
|
}
|
|
|
|
void StoreCollectionValue (object collection, Type valueType, object value, CollectionDataContract collectionContract)
|
|
{
|
|
if (collectionContract.Kind == CollectionKind.GenericDictionary || collectionContract.Kind == CollectionKind.Dictionary) {
|
|
ClassDataContract keyValuePairContract = DataContract.GetDataContract (valueType) as ClassDataContract;
|
|
if (keyValuePairContract == null)
|
|
Fx.Assert ("Failed to create contract for KeyValuePair type");
|
|
DataMember keyMember = keyValuePairContract.Members [0];
|
|
DataMember valueMember = keyValuePairContract.Members [1];
|
|
object pkey = CodeInterpreter.GetMember (keyMember.MemberInfo, value);
|
|
object pvalue = CodeInterpreter.GetMember (valueMember.MemberInfo, value);
|
|
|
|
collectionContract.AddMethod.Invoke (collection, new object [] {pkey, pvalue});
|
|
}
|
|
else
|
|
collectionContract.AddMethod.Invoke (collection, new object [] {value});
|
|
}
|
|
|
|
void HandleUnexpectedItemInCollection (ref int iterator)
|
|
{
|
|
if (IsStartElement ()) {
|
|
context.SkipUnknownElement (xmlReader);
|
|
iterator--;
|
|
}
|
|
else
|
|
throw XmlObjectSerializerReadContext.CreateUnexpectedStateException (XmlNodeType.Element, xmlReader);
|
|
}
|
|
|
|
bool IsStartElement(XmlDictionaryString name, XmlDictionaryString ns)
|
|
{
|
|
return xmlReader.IsStartElement (name, ns);
|
|
}
|
|
|
|
bool IsStartElement()
|
|
{
|
|
return xmlReader.IsStartElement ();
|
|
}
|
|
|
|
bool IsEndElement ()
|
|
{
|
|
return xmlReader.NodeType == XmlNodeType.EndElement;
|
|
}
|
|
}
|
|
}
|