Files
Aaron Bockover f76b8b4df1 XmlObjectSerialier: fix ISerializable (bxc#37171)
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
2015-12-21 11:00:46 -05:00

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;
}
}
}