private LocalBuilder ReadValue(Type type, string name, string ns)
{
LocalBuilder value = _ilg.DeclareLocal(type, "valueRead");
LocalBuilder nullableValue = null;
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)
{
LocalBuilder objectId = _ilg.DeclareLocal(Globals.TypeOfString, "objectIdRead");
_ilg.Call(_contextArg, XmlFormatGeneratorStatics.ReadAttributesMethod, _xmlReaderArg);
_ilg.Call(_contextArg, XmlFormatGeneratorStatics.ReadIfNullOrRefMethod, _xmlReaderArg, type, DataContract.IsTypeSerializable(type));
_ilg.Stloc(objectId);
// Deserialize null
_ilg.If(objectId, Cmp.EqualTo, Globals.NullObjectId);
if (nullables != 0)
{
_ilg.LoadAddress(value);
_ilg.InitObj(value.LocalType);
}
else if (type.IsValueType)
{
ThrowValidationException(SR.Format(SR.ValueTypeCannotBeNull, DataContract.GetClrTypeFullName(type)));
}
else
{
_ilg.Load(null);
_ilg.Stloc(value);
}
// Deserialize value
// Compare against Globals.NewObjectId, which is set to string.Empty
_ilg.ElseIfIsEmptyString(objectId);
_ilg.Call(_contextArg, XmlFormatGeneratorStatics.GetObjectIdMethod);
_ilg.Stloc(objectId);
if (type.IsValueType)
{
_ilg.IfNotIsEmptyString(objectId);
ThrowValidationException(SR.Format(SR.ValueTypeCannotHaveId, DataContract.GetClrTypeFullName(type)));
_ilg.EndIf();
}
if (nullables != 0)
{
nullableValue = value;
value = _ilg.DeclareLocal(type, "innerValueRead");
}
if (primitiveContract != null && primitiveContract.UnderlyingType != Globals.TypeOfObject)
{
_ilg.Call(_xmlReaderArg, primitiveContract.XmlFormatReaderMethod);
_ilg.Stloc(value);
if (!type.IsValueType)
{
_ilg.Call(_contextArg, XmlFormatGeneratorStatics.AddNewObjectMethod, value);
}
}
else
{
InternalDeserialize(value, type, name, ns);
}
// Deserialize ref
_ilg.Else();
if (type.IsValueType)
{
ThrowValidationException(SR.Format(SR.ValueTypeCannotHaveRef, DataContract.GetClrTypeFullName(type)));
}
else
{
_ilg.Call(_contextArg, XmlFormatGeneratorStatics.GetExistingObjectMethod, objectId, type, name, ns);
_ilg.ConvertValue(Globals.TypeOfObject, type);
_ilg.Stloc(value);
}
_ilg.EndIf();
if (nullableValue != null)
{
_ilg.If(objectId, Cmp.NotEqualTo, Globals.NullObjectId);
WrapNullableObject(value, nullableValue, nullables);
_ilg.EndIf();
value = nullableValue;
}
}
else
{
InternalDeserialize(value, type, name, ns);
}
return(value);
}
void WriteValue(LocalBuilder memberValue, bool writeXsiType)
{
Type memberType = memberValue.LocalType;
if (memberType.IsPointer)
{
ilg.Load(memberValue);
ilg.Load(memberType);
ilg.Call(XmlFormatGeneratorStatics.BoxPointer);
memberType = Globals.TypeOfReflectionPointer;
memberValue = ilg.DeclareLocal(memberType, "memberValueRefPointer");
ilg.Store(memberValue);
}
bool isNullableOfT = (memberType.IsGenericType &&
memberType.GetGenericTypeDefinition() == Globals.TypeOfNullable);
if (memberType.IsValueType && !isNullableOfT)
{
PrimitiveDataContract primitiveContract = PrimitiveDataContract.GetPrimitiveDataContract(memberType);
if (primitiveContract != null && !writeXsiType)
{
ilg.Call(xmlWriterArg, primitiveContract.XmlFormatContentWriterMethod, memberValue);
}
else
{
InternalSerialize(XmlFormatGeneratorStatics.InternalSerializeMethod, memberValue, memberType, writeXsiType);
}
}
else
{
if (isNullableOfT)
{
memberValue = UnwrapNullableObject(memberValue); //Leaves !HasValue on stack
memberType = memberValue.LocalType;
}
else
{
ilg.Load(memberValue);
ilg.Load(null);
ilg.Ceq();
}
ilg.If();
ilg.Call(contextArg, XmlFormatGeneratorStatics.WriteNullMethod, xmlWriterArg, memberType, DataContract.IsTypeSerializable(memberType));
ilg.Else();
PrimitiveDataContract primitiveContract = PrimitiveDataContract.GetPrimitiveDataContract(memberType);
if (primitiveContract != null && primitiveContract.UnderlyingType != Globals.TypeOfObject && !writeXsiType)
{
if (isNullableOfT)
{
ilg.Call(xmlWriterArg, primitiveContract.XmlFormatContentWriterMethod, memberValue);
}
else
{
ilg.Call(contextArg, primitiveContract.XmlFormatContentWriterMethod, xmlWriterArg, memberValue);
}
}
else
{
if (memberType == Globals.TypeOfObject || //boxed Nullable<T>
memberType == Globals.TypeOfValueType ||
((IList)Globals.TypeOfNullable.GetInterfaces()).Contains(memberType))
{
ilg.Load(memberValue);
ilg.ConvertValue(memberValue.LocalType, Globals.TypeOfObject);
memberValue = ilg.DeclareLocal(Globals.TypeOfObject, "unwrappedMemberValue");
memberType = memberValue.LocalType;
ilg.Stloc(memberValue);
ilg.If(memberValue, Cmp.EqualTo, null);
ilg.Call(contextArg, XmlFormatGeneratorStatics.WriteNullMethod, xmlWriterArg, memberType, DataContract.IsTypeSerializable(memberType));
ilg.Else();
}
InternalSerialize((isNullableOfT ? XmlFormatGeneratorStatics.InternalSerializeMethod : XmlFormatGeneratorStatics.InternalSerializeReferenceMethod),
memberValue, memberType, writeXsiType);
if (memberType == Globals.TypeOfObject) //boxed Nullable<T>
{
ilg.EndIf();
}
}
ilg.EndIf();
}
}
public void ReflectionWriteValue(XmlWriterDelegator xmlWriter, XmlObjectSerializerWriteContext context, Type type, object?value, bool writeXsiType, PrimitiveDataContract?primitiveContractForParamType)
{
Type memberType = type;
object?memberValue = value;
bool originValueIsNullableOfT = (memberType.IsGenericType && memberType.GetGenericTypeDefinition() == Globals.TypeOfNullable);
if (memberType.IsValueType && !originValueIsNullableOfT)
{
Debug.Assert(memberValue != null);
PrimitiveDataContract?primitiveContract = primitiveContractForParamType;
if (primitiveContract != null && !writeXsiType)
{
primitiveContract.WriteXmlValue(xmlWriter, memberValue, context);
}
else
{
ReflectionInternalSerialize(xmlWriter, context, memberValue, memberValue.GetType().TypeHandle.Equals(memberType.TypeHandle), writeXsiType, memberType);
}
}
else
{
if (originValueIsNullableOfT)
{
if (memberValue == null)
{
memberType = Nullable.GetUnderlyingType(memberType) !;
}
else
{
MethodInfo getValue = memberType.GetMethod("get_Value", Type.EmptyTypes) !;
memberValue = getValue.Invoke(memberValue, Array.Empty <object>()) !;
memberType = memberValue.GetType();
}
}
if (memberValue == null)
{
context.WriteNull(xmlWriter, memberType, DataContract.IsTypeSerializable(memberType));
}
else
{
PrimitiveDataContract?primitiveContract = originValueIsNullableOfT ? PrimitiveDataContract.GetPrimitiveDataContract(memberType) : primitiveContractForParamType;
if (primitiveContract != null && primitiveContract.UnderlyingType != Globals.TypeOfObject && !writeXsiType)
{
primitiveContract.WriteXmlValue(xmlWriter, memberValue, context);
}
else
{
if (memberValue == null &&
(memberType == Globals.TypeOfObject ||
(originValueIsNullableOfT && memberType.IsValueType)))
{
context.WriteNull(xmlWriter, memberType, DataContract.IsTypeSerializable(memberType));
}
else
{
ReflectionInternalSerialize(xmlWriter, context, memberValue !, memberValue !.GetType().TypeHandle.Equals(memberType.TypeHandle), writeXsiType, memberType, originValueIsNullableOfT);
}
}
}
}
}
public void ReflectionWriteCollection(XmlWriterDelegator xmlWriter, object obj, XmlObjectSerializerWriteContext context, CollectionDataContract collectionDataContract)
{
XmlDictionaryString ns = collectionDataContract.Namespace;
XmlDictionaryString itemName = collectionDataContract.CollectionItemName;
if (collectionDataContract.ChildElementNamespace != null)
{
xmlWriter.WriteNamespaceDecl(collectionDataContract.ChildElementNamespace);
}
if (collectionDataContract.Kind == CollectionKind.Array)
{
context.IncrementArrayCount(xmlWriter, (Array)obj);
Type itemType = collectionDataContract.ItemType;
if (!ReflectionTryWritePrimitiveArray(xmlWriter, obj, collectionDataContract.UnderlyingType, itemType, itemName, ns))
{
Array array = (Array)obj;
PrimitiveDataContract primitiveContract = PrimitiveDataContract.GetPrimitiveDataContract(itemType);
for (int i = 0; i < array.Length; ++i)
{
_reflectionClassWriter.ReflectionWriteStartElement(xmlWriter, itemType, ns, ns.Value, itemName.Value, 0);
_reflectionClassWriter.ReflectionWriteValue(xmlWriter, context, itemType, array.GetValue(i), false, primitiveContract);
_reflectionClassWriter.ReflectionWriteEndElement(xmlWriter);
}
}
}
else
{
collectionDataContract.IncrementCollectionCount(xmlWriter, obj, context);
Type enumeratorReturnType;
IEnumerator enumerator = collectionDataContract.GetEnumeratorForCollection(obj, out enumeratorReturnType);
PrimitiveDataContract primitiveContractForType = PrimitiveDataContract.GetPrimitiveDataContract(enumeratorReturnType);
if (primitiveContractForType != null && primitiveContractForType.UnderlyingType != Globals.TypeOfObject)
{
while (enumerator.MoveNext())
{
object current = enumerator.Current;
context.IncrementItemCount(1);
primitiveContractForType.WriteXmlElement(xmlWriter, current, context, itemName, ns);
}
}
else
{
bool isDictionary = collectionDataContract.Kind == CollectionKind.Dictionary || collectionDataContract.Kind == CollectionKind.GenericDictionary;
while (enumerator.MoveNext())
{
object current = enumerator.Current;
context.IncrementItemCount(1);
_reflectionClassWriter.ReflectionWriteStartElement(xmlWriter, enumeratorReturnType, ns, ns.Value, itemName.Value, 0);
if (isDictionary)
{
collectionDataContract.ItemContract.WriteXmlValue(xmlWriter, current, context);
}
else
{
_reflectionClassWriter.ReflectionWriteValue(xmlWriter, context, enumeratorReturnType, current, false, primitiveContractForParamType: null);
}
_reflectionClassWriter.ReflectionWriteEndElement(xmlWriter);
}
}
}
}
private bool ReflectionTryReadPrimitiveArray(XmlReaderDelegator xmlReader, XmlObjectSerializerReadContext context, XmlDictionaryString collectionItemName, XmlDictionaryString collectionItemNamespace, Type type, Type itemType, int arraySize, out object resultArray)
{
resultArray = null;
PrimitiveDataContract primitiveContract = PrimitiveDataContract.GetPrimitiveDataContract(itemType);
if (primitiveContract == null)
{
return(false);
}
switch (itemType.GetTypeCode())
{
case TypeCode.Boolean:
{
bool[] boolArray = null;
xmlReader.TryReadBooleanArray(context, collectionItemName, collectionItemNamespace, arraySize, out boolArray);
resultArray = boolArray;
}
break;
case TypeCode.DateTime:
{
DateTime[] dateTimeArray = null;
xmlReader.TryReadDateTimeArray(context, collectionItemName, collectionItemNamespace, arraySize, out dateTimeArray);
resultArray = dateTimeArray;
}
break;
case TypeCode.Decimal:
{
decimal[] decimalArray = null;
xmlReader.TryReadDecimalArray(context, collectionItemName, collectionItemNamespace, arraySize, out decimalArray);
resultArray = decimalArray;
}
break;
case TypeCode.Int32:
{
int[] intArray = null;
xmlReader.TryReadInt32Array(context, collectionItemName, collectionItemNamespace, arraySize, out intArray);
resultArray = intArray;
}
break;
case TypeCode.Int64:
{
long[] longArray = null;
xmlReader.TryReadInt64Array(context, collectionItemName, collectionItemNamespace, arraySize, out longArray);
resultArray = longArray;
}
break;
case TypeCode.Single:
{
float[] floatArray = null;
xmlReader.TryReadSingleArray(context, collectionItemName, collectionItemNamespace, arraySize, out floatArray);
resultArray = floatArray;
}
break;
case TypeCode.Double:
{
double[] doubleArray = null;
xmlReader.TryReadDoubleArray(context, collectionItemName, collectionItemNamespace, arraySize, out doubleArray);
resultArray = doubleArray;
}
break;
default:
return(false);
}
return(true);
}
private void WriteValue(LocalBuilder memberValue, bool writeXsiType)
{
Type localType = memberValue.LocalType;
if (localType.IsPointer)
{
this.ilg.Load(memberValue);
this.ilg.Load(localType);
this.ilg.Call(XmlFormatGeneratorStatics.BoxPointer);
localType = Globals.TypeOfReflectionPointer;
memberValue = this.ilg.DeclareLocal(localType, "memberValueRefPointer");
this.ilg.Store(memberValue);
}
bool flag = localType.IsGenericType && (localType.GetGenericTypeDefinition() == Globals.TypeOfNullable);
if (localType.IsValueType && !flag)
{
PrimitiveDataContract primitiveDataContract = PrimitiveDataContract.GetPrimitiveDataContract(localType);
if ((primitiveDataContract != null) && !writeXsiType)
{
this.ilg.Call(this.xmlWriterArg, primitiveDataContract.XmlFormatContentWriterMethod, memberValue);
}
else
{
this.InternalSerialize(XmlFormatGeneratorStatics.InternalSerializeMethod, memberValue, localType, writeXsiType);
}
}
else
{
if (flag)
{
memberValue = this.UnwrapNullableObject(memberValue);
localType = memberValue.LocalType;
}
else
{
this.ilg.Load(memberValue);
this.ilg.Load(null);
this.ilg.Ceq();
}
this.ilg.If();
this.ilg.Call(this.contextArg, XmlFormatGeneratorStatics.WriteNullMethod, this.xmlWriterArg, localType, DataContract.IsTypeSerializable(localType));
this.ilg.Else();
PrimitiveDataContract contract2 = PrimitiveDataContract.GetPrimitiveDataContract(localType);
if (((contract2 != null) && (contract2.UnderlyingType != Globals.TypeOfObject)) && !writeXsiType)
{
if (flag)
{
this.ilg.Call(this.xmlWriterArg, contract2.XmlFormatContentWriterMethod, memberValue);
}
else
{
this.ilg.Call(this.contextArg, contract2.XmlFormatContentWriterMethod, this.xmlWriterArg, memberValue);
}
}
else
{
if (((localType == Globals.TypeOfObject) || (localType == Globals.TypeOfValueType)) || Globals.TypeOfNullable.GetInterfaces().Contains(localType))
{
this.ilg.Load(memberValue);
this.ilg.ConvertValue(memberValue.LocalType, Globals.TypeOfObject);
memberValue = this.ilg.DeclareLocal(Globals.TypeOfObject, "unwrappedMemberValue");
localType = memberValue.LocalType;
this.ilg.Stloc(memberValue);
this.ilg.If(memberValue, Cmp.EqualTo, null);
this.ilg.Call(this.contextArg, XmlFormatGeneratorStatics.WriteNullMethod, this.xmlWriterArg, localType, DataContract.IsTypeSerializable(localType));
this.ilg.Else();
}
this.InternalSerialize(flag ? XmlFormatGeneratorStatics.InternalSerializeMethod : XmlFormatGeneratorStatics.InternalSerializeReferenceMethod, memberValue, localType, writeXsiType);
if (localType == Globals.TypeOfObject)
{
this.ilg.EndIf();
}
}
this.ilg.EndIf();
}
}
private DataContract?ResolveDataContractFromKnownTypes(XmlQualifiedName typeName) => PrimitiveDataContract.GetPrimitiveDataContract(typeName.Name, typeName.Namespace) ?? scopedKnownTypes.GetDataContract(typeName) ?? GetDataContractFromSerializerKnownTypes(typeName);
void WriteValue(Type memberType, object memberValue, bool writeXsiType)
{
Pointer memberValueRefPointer = null;
if (memberType.IsPointer)
{
memberValueRefPointer = (Pointer)XmlFormatGeneratorStatics.BoxPointer.Invoke(null, new object [] { memberValue, memberType });
}
bool isNullableOfT = (memberType.IsGenericType &&
memberType.GetGenericTypeDefinition() == Globals.TypeOfNullable);
if (memberType.IsValueType && !isNullableOfT)
{
PrimitiveDataContract primitiveContract = PrimitiveDataContract.GetPrimitiveDataContract(memberType);
if (primitiveContract != null && !writeXsiType)
{
primitiveContract.XmlFormatContentWriterMethod.Invoke(writer, new object [] { memberValue });
}
else
{
InternalSerialize(XmlFormatGeneratorStatics.InternalSerializeMethod, () => memberValue, memberType, writeXsiType);
}
}
else
{
bool isNull;
if (isNullableOfT)
{
memberValue = UnwrapNullableObject(() => memberValue, ref memberType, out isNull); //Leaves !HasValue on stack
}
else
{
isNull = memberValue == null;
}
if (isNull)
{
XmlFormatGeneratorStatics.WriteNullMethod.Invoke(ctx, new object [] { writer, memberType, DataContract.IsTypeSerializable(memberType) });
}
else
{
PrimitiveDataContract primitiveContract = PrimitiveDataContract.GetPrimitiveDataContract(memberType);
if (primitiveContract != null && primitiveContract.UnderlyingType != Globals.TypeOfObject && !writeXsiType)
{
if (isNullableOfT)
{
primitiveContract.XmlFormatContentWriterMethod.Invoke(writer, new object [] { memberValue });
}
else
{
primitiveContract.XmlFormatContentWriterMethod.Invoke(ctx, new object [] { writer, memberValue });
}
}
else
{
bool isNull2 = false;
if (memberType == Globals.TypeOfObject || //boxed Nullable<T>
memberType == Globals.TypeOfValueType ||
((IList)Globals.TypeOfNullable.GetInterfaces()).Contains(memberType))
{
var unwrappedMemberValue = CodeInterpreter.ConvertValue(memberValue, memberType.GetType(), Globals.TypeOfObject);
memberValue = unwrappedMemberValue;
isNull2 = memberValue == null;
}
if (isNull2)
{
XmlFormatGeneratorStatics.WriteNullMethod.Invoke(ctx, new object [] { writer, memberType, DataContract.IsTypeSerializable(memberType) });
}
else
{
InternalSerialize((isNullableOfT ? XmlFormatGeneratorStatics.InternalSerializeMethod : XmlFormatGeneratorStatics.InternalSerializeReferenceMethod),
() => memberValue, memberType, writeXsiType);
}
}
}
}
}
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);
}
private LocalBuilder ReadValue(Type type, string name, string ns)
{
LocalBuilder builder = this.ilg.DeclareLocal(type, "valueRead");
LocalBuilder outerValue = null;
int nullables = 0;
while (type.IsGenericType && (type.GetGenericTypeDefinition() == Globals.TypeOfNullable))
{
nullables++;
type = type.GetGenericArguments()[0];
}
PrimitiveDataContract primitiveDataContract = PrimitiveDataContract.GetPrimitiveDataContract(type);
if (((primitiveDataContract != null) && (primitiveDataContract.UnderlyingType != Globals.TypeOfObject)) || ((nullables != 0) || type.IsValueType))
{
LocalBuilder local = this.ilg.DeclareLocal(Globals.TypeOfString, "objectIdRead");
this.ilg.Call(this.contextArg, XmlFormatGeneratorStatics.ReadAttributesMethod, this.xmlReaderArg);
this.ilg.Call(this.contextArg, XmlFormatGeneratorStatics.ReadIfNullOrRefMethod, this.xmlReaderArg, type, DataContract.IsTypeSerializable(type));
this.ilg.Stloc(local);
this.ilg.If(local, Cmp.EqualTo, null);
if (nullables != 0)
{
this.ilg.LoadAddress(builder);
this.ilg.InitObj(builder.LocalType);
}
else if (type.IsValueType)
{
this.ThrowValidationException(System.Runtime.Serialization.SR.GetString("ValueTypeCannotBeNull", new object[] { DataContract.GetClrTypeFullName(type) }), new object[0]);
}
else
{
this.ilg.Load(null);
this.ilg.Stloc(builder);
}
this.ilg.ElseIfIsEmptyString(local);
this.ilg.Call(this.contextArg, XmlFormatGeneratorStatics.GetObjectIdMethod);
this.ilg.Stloc(local);
if (type.IsValueType)
{
this.ilg.IfNotIsEmptyString(local);
this.ThrowValidationException(System.Runtime.Serialization.SR.GetString("ValueTypeCannotHaveId", new object[] { DataContract.GetClrTypeFullName(type) }), new object[0]);
this.ilg.EndIf();
}
if (nullables != 0)
{
outerValue = builder;
builder = this.ilg.DeclareLocal(type, "innerValueRead");
}
if ((primitiveDataContract != null) && (primitiveDataContract.UnderlyingType != Globals.TypeOfObject))
{
this.ilg.Call(this.xmlReaderArg, primitiveDataContract.XmlFormatReaderMethod);
this.ilg.Stloc(builder);
if (!type.IsValueType)
{
this.ilg.Call(this.contextArg, XmlFormatGeneratorStatics.AddNewObjectMethod, builder);
}
}
else
{
this.InternalDeserialize(builder, type, name, ns);
}
this.ilg.Else();
if (type.IsValueType)
{
this.ThrowValidationException(System.Runtime.Serialization.SR.GetString("ValueTypeCannotHaveRef", new object[] { DataContract.GetClrTypeFullName(type) }), new object[0]);
}
else
{
this.ilg.Call(this.contextArg, XmlFormatGeneratorStatics.GetExistingObjectMethod, local, type, name, ns);
this.ilg.ConvertValue(Globals.TypeOfObject, type);
this.ilg.Stloc(builder);
}
this.ilg.EndIf();
if (outerValue != null)
{
this.ilg.If(local, Cmp.NotEqualTo, null);
this.WrapNullableObject(builder, outerValue, nullables);
this.ilg.EndIf();
builder = outerValue;
}
return(builder);
}
this.InternalDeserialize(builder, type, name, ns);
return(builder);
}
