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 LocalBuilder ReadValue(Type type, string name, string ns) { LocalBuilder value = _ilg.DeclareLocal(type, "valueRead"); LocalBuilder nullableValue = null; int nullables = 0; while (type.GetTypeInfo().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.GetTypeInfo().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.GetTypeInfo().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.GetTypeInfo().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.GetTypeInfo().IsValueType) { _ilg.Call(_contextArg, XmlFormatGeneratorStatics.AddNewObjectMethod, value); } } else { InternalDeserialize(value, type, name, ns); } // Deserialize ref _ilg.Else(); if (type.GetTypeInfo().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); }
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); IEnumerator enumerator = collectionDataContract.GetEnumeratorForCollection(obj); PrimitiveDataContract?primitiveContractForType = PrimitiveDataContract.GetPrimitiveDataContract(collectionDataContract.UnderlyingType); 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 { Type elementType = collectionDataContract.GetCollectionElementType(); bool isDictionary = collectionDataContract.Kind == CollectionKind.Dictionary || collectionDataContract.Kind == CollectionKind.GenericDictionary; while (enumerator.MoveNext()) { object current = enumerator.Current; context.IncrementItemCount(1); _reflectionClassWriter.ReflectionWriteStartElement(xmlWriter, elementType, ns, ns.Value, itemName.Value, 0); if (isDictionary) { collectionDataContract.ItemContract.WriteXmlValue(xmlWriter, current, context); } else { _reflectionClassWriter.ReflectionWriteValue(xmlWriter, context, elementType, current, false, primitiveContractForParamType: null); } _reflectionClassWriter.ReflectionWriteEndElement(xmlWriter); } } } }
private void WriteValue(LocalBuilder memberValue, bool writeXsiType) { Type memberType = memberValue.LocalType; bool isNullableOfT = (memberType.GetTypeInfo().IsGenericType&& memberType.GetGenericTypeDefinition() == Globals.TypeOfNullable); if (memberType.GetTypeInfo().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(); } }
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 DataContract?ResolveDataContractFromKnownTypes(XmlQualifiedName typeName) => PrimitiveDataContract.GetPrimitiveDataContract(typeName.Name, typeName.Namespace) ?? scopedKnownTypes.GetDataContract(typeName) ?? GetDataContractFromSerializerKnownTypes(typeName);
protected object ReflectionReadValue(XmlReaderDelegator xmlReader, XmlObjectSerializerReadContext context, Type type, string name, string ns, PrimitiveDataContract primitiveContractForOriginalType = null) { object value = null; int nullables = 0; while (type.IsGenericType && type.GetGenericTypeDefinition() == Globals.TypeOfNullable) { nullables++; type = type.GetGenericArguments()[0]; } PrimitiveDataContract primitiveContract = nullables != 0 ? PrimitiveDataContract.GetPrimitiveDataContract(type) : (primitiveContractForOriginalType ?? PrimitiveDataContract.GetPrimitiveDataContract(type)); if ((primitiveContract != null && primitiveContract.UnderlyingType != Globals.TypeOfObject) || nullables != 0 || type.IsValueType) { value = ReadItemOfPrimitiveType(xmlReader, context, type, name, ns, primitiveContract, nullables); } else { value = ReflectionInternalDeserialize(xmlReader, context, null /*collectionContract*/, type, name, ns); } return(value); }
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); }
protected object ReflectionReadValue(XmlReaderDelegator xmlReader, XmlObjectSerializerReadContext context, Type type, string name, string ns, PrimitiveDataContract primitiveContractForOriginalType = null) { object value = null; int nullables = 0; while (type.GetTypeInfo().IsGenericType&& type.GetGenericTypeDefinition() == Globals.TypeOfNullable) { nullables++; type = type.GetGenericArguments()[0]; } PrimitiveDataContract primitiveContract = nullables != 0 ? PrimitiveDataContract.GetPrimitiveDataContract(type) : (primitiveContractForOriginalType ?? PrimitiveDataContract.GetPrimitiveDataContract(type)); if ((primitiveContract != null && primitiveContract.UnderlyingType != Globals.TypeOfObject) || nullables != 0 || type.GetTypeInfo().IsValueType) { context.ReadAttributes(xmlReader); string objectId = context.ReadIfNullOrRef(xmlReader, Globals.TypeOfString, true); if (objectId != null) { if (objectId.Length == 0) { objectId = context.GetObjectId(); if (primitiveContract != null && primitiveContract.UnderlyingType != Globals.TypeOfObject) { value = primitiveContract.ReadXmlValue(xmlReader, context); context.AddNewObject(value); } else { value = ReflectionInternalDeserialize(xmlReader, context, null /*collectionContract*/, type, name, ns); } } else if (type.GetTypeInfo().IsValueType) { throw new SerializationException(SR.Format(SR.ValueTypeCannotHaveId, DataContract.GetClrTypeFullName(type))); } } else { value = null; } } else { value = ReflectionInternalDeserialize(xmlReader, context, null /*collectionContract*/, type, name, ns); } return(value); }
protected override int ReflectionWriteMembers(XmlWriterDelegator xmlWriter, object obj, XmlObjectSerializerWriteContext context, ClassDataContract classContract, ClassDataContract derivedMostClassContract, int childElementIndex, XmlDictionaryString[] emptyStringArray) { int memberCount = (classContract.BaseContract == null) ? 0 : ReflectionWriteMembers(xmlWriter, obj, context, classContract.BaseContract, derivedMostClassContract, childElementIndex, emptyStringArray); childElementIndex += memberCount; XmlDictionaryString[] memberNames = classContract.MemberNames; XmlDictionaryString ns = classContract.Namespace; context.IncrementItemCount(classContract.Members.Count); for (int i = 0; i < classContract.Members.Count; i++, memberCount++) { DataMember member = classContract.Members[i]; Type memberType = member.MemberType; if (member.IsGetOnlyCollection) { context.StoreIsGetOnlyCollection(); } else { context.ResetIsGetOnlyCollection(); } bool shouldWriteValue = true; object memberValue = null; if (!member.EmitDefaultValue) { memberValue = ReflectionGetMemberValue(obj, member); object defaultValue = XmlFormatGeneratorStatics.GetDefaultValue(memberType); if ((memberValue == null && defaultValue == null) || (memberValue != null && memberValue.Equals(defaultValue))) { shouldWriteValue = false; if (member.IsRequired) { XmlObjectSerializerWriteContext.ThrowRequiredMemberMustBeEmitted(member.Name, classContract.UnderlyingType); } } } if (shouldWriteValue) { bool writeXsiType = CheckIfMemberHasConflict(member, classContract, derivedMostClassContract); if (memberValue == null) { memberValue = ReflectionGetMemberValue(obj, member); } PrimitiveDataContract primitiveContract = member.MemberPrimitiveContract; if (writeXsiType || !ReflectionTryWritePrimitive(xmlWriter, context, memberType, memberValue, memberNames[i + childElementIndex] /*name*/, ns, primitiveContract)) { ReflectionWriteStartElement(xmlWriter, memberType, ns, ns.Value, member.Name, 0); if (classContract.ChildElementNamespaces[i + childElementIndex] != null) { var nsChildElement = classContract.ChildElementNamespaces[i + childElementIndex]; xmlWriter.WriteNamespaceDecl(nsChildElement); } ReflectionWriteValue(xmlWriter, context, memberType, memberValue, writeXsiType, primitiveContractForParamType: null); ReflectionWriteEndElement(xmlWriter); } if (classContract.HasExtensionData) { context.WriteExtensionData(xmlWriter, ((IExtensibleDataObject)obj).ExtensionData, memberCount); } } } return(memberCount); }
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); } } } } }
protected bool ReflectionTryWritePrimitive(XmlWriterDelegator xmlWriter, XmlObjectSerializerWriteContext context, Type type, object value, XmlDictionaryString name, XmlDictionaryString ns, PrimitiveDataContract primitiveContract) { if (primitiveContract == null || primitiveContract.UnderlyingType == Globals.TypeOfObject) return false; primitiveContract.WriteXmlElement(xmlWriter, value, context, name, ns); return true; }
public void ReflectionWriteValue(XmlWriterDelegator xmlWriter, XmlObjectSerializerWriteContext context, Type type, object value, bool writeXsiType, PrimitiveDataContract primitiveContractForParamType) { Type memberType = type; object memberValue = value; TypeInfo memberTypeInfo = memberType.GetTypeInfo(); bool originValueIsNullableOfT = (memberTypeInfo.IsGenericType && memberType.GetGenericTypeDefinition() == Globals.TypeOfNullable); if (memberTypeInfo.IsValueType && !originValueIsNullableOfT) { 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", Array.Empty<Type>()); 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.GetTypeInfo().IsValueType))) { context.WriteNull(xmlWriter, memberType, DataContract.IsTypeSerializable(memberType)); } else { ReflectionInternalSerialize(xmlWriter, context, memberValue, memberValue.GetType().TypeHandle.Equals(memberType.TypeHandle), writeXsiType, memberType, originValueIsNullableOfT); } } } } }
protected bool ReflectionTryWritePrimitive(XmlWriterDelegator xmlWriter, XmlObjectSerializerWriteContext context, Type type, object value, XmlDictionaryString name, XmlDictionaryString ns, PrimitiveDataContract primitiveContract) { if (primitiveContract == null || primitiveContract.UnderlyingType == Globals.TypeOfObject) { return(false); } primitiveContract.WriteXmlElement(xmlWriter, value, context, name, ns); return(true); }
private object ReadItemOfPrimitiveType(XmlReaderDelegator xmlReader, XmlObjectSerializerReadContext context, Type type, string name, string ns, PrimitiveDataContract primitiveContract, int nullables) { object value; context.ReadAttributes(xmlReader); string objectId = context.ReadIfNullOrRef(xmlReader, type, DataContract.IsTypeSerializable(type)); bool typeIsValueType = type.IsValueType; if (objectId != null) { if (objectId.Length == 0) { objectId = context.GetObjectId(); if (!string.IsNullOrEmpty(objectId) && typeIsValueType) { throw new SerializationException(SR.Format(SR.ValueTypeCannotHaveId, DataContract.GetClrTypeFullName(type))); } if (primitiveContract != null && primitiveContract.UnderlyingType != Globals.TypeOfObject) { value = primitiveContract.ReadXmlValue(xmlReader, context); } else { value = ReflectionInternalDeserialize(xmlReader, context, null /*collectionContract*/, type, name, ns); } } else { if (typeIsValueType) { throw new SerializationException(SR.Format(SR.ValueTypeCannotHaveRef, DataContract.GetClrTypeFullName(type))); } else { value = context.GetExistingObject(objectId, type, name, ns); } } } else { if (typeIsValueType && nullables == 0) { throw new SerializationException(SR.Format(SR.ValueTypeCannotBeNull, DataContract.GetClrTypeFullName(type))); } else { value = null; } } return(value); }
public void ReflectionWriteValue(XmlWriterDelegator xmlWriter, XmlObjectSerializerWriteContext context, Type type, object value, bool writeXsiType, PrimitiveDataContract primitiveContractForParamType) { Type memberType = type; object memberValue = value; TypeInfo memberTypeInfo = memberType.GetTypeInfo(); bool originValueIsNullableOfT = (memberTypeInfo.IsGenericType && memberType.GetGenericTypeDefinition() == Globals.TypeOfNullable); if (memberTypeInfo.IsValueType && !originValueIsNullableOfT) { 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", Array.Empty <Type>()); 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.GetTypeInfo().IsValueType))) { context.WriteNull(xmlWriter, memberType, DataContract.IsTypeSerializable(memberType)); } else { ReflectionInternalSerialize(xmlWriter, context, memberValue, memberValue.GetType().TypeHandle.Equals(memberType.TypeHandle), writeXsiType, memberType, originValueIsNullableOfT); } } } } }
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); }