internal override void CheckIfTypeSerializable(Type memberType, bool isMemberTypeSerializable) { if (mode == SerializationMode.SharedType && surrogateSelector != null && CheckIfTypeSerializableForSharedTypeMode(memberType)) { return; } else { if (dataContractSurrogate != null) { while (memberType.IsArray) { memberType = memberType.GetElementType(); } memberType = DataContractSurrogateCaller.GetDataContractType(dataContractSurrogate, memberType); if (!DataContract.IsTypeSerializable(memberType)) { throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataContractException(SR.GetString(SR.TypeNotSerializable, memberType))); } return; } } base.CheckIfTypeSerializable(memberType, isMemberTypeSerializable); }
private void CheckAndAddType(Type type) { type = GetSurrogatedType(type); if (!type.ContainsGenericParameters && DataContract.IsTypeSerializable(type)) { AddType(type); } }
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); }
internal override void CheckIfTypeSerializable(Type memberType, bool isMemberTypeSerializable) { if (_serializationSurrogateProvider != null) { while (memberType.IsArray) { memberType = memberType.GetElementType(); } memberType = DataContractSurrogateCaller.GetDataContractType(_serializationSurrogateProvider, memberType); if (!DataContract.IsTypeSerializable(memberType)) { throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataContractException(SR.Format(SR.TypeNotSerializable, memberType))); } return; } base.CheckIfTypeSerializable(memberType, isMemberTypeSerializable); }
internal override void CheckIfTypeSerializable(Type memberType, bool isMemberTypeSerializable) { if (((this.mode != SerializationMode.SharedType) || (this.surrogateSelector == null)) || !this.CheckIfTypeSerializableForSharedTypeMode(memberType)) { if (this.dataContractSurrogate != null) { while (memberType.IsArray) { memberType = memberType.GetElementType(); } memberType = DataContractSurrogateCaller.GetDataContractType(this.dataContractSurrogate, memberType); if (!DataContract.IsTypeSerializable(memberType)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataContractException(System.Runtime.Serialization.SR.GetString("TypeNotSerializable", new object[] { memberType }))); } } else { base.CheckIfTypeSerializable(memberType, isMemberTypeSerializable); } } }
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); }
public static 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); } } } } }
private void WriteValue(LocalBuilder memberValue, bool writeXsiType) { Type memberType = memberValue.LocalType; 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(); } }
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); var typeHandleValue = Type.GetTypeHandle(memberValue); var isDeclaredType = typeHandleValue.Equals(CodeInterpreter.ConvertValue(memberValue, memberType, Globals.TypeOfObject)); ctx.InternalSerialize(writer, memberValue, isDeclaredType, writeXsiType, DataContract.GetId(memberType.TypeHandle), memberType.TypeHandle); } } 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 { var typeHandleValue = Type.GetTypeHandle(memberValue); var isDeclaredType = typeHandleValue.Equals(CodeInterpreter.ConvertValue(memberValue, memberType, Globals.TypeOfObject)); if (isNullableOfT) { ctx.InternalSerialize(writer, memberValue, isDeclaredType, writeXsiType, DataContract.GetId(memberType.TypeHandle), memberType.TypeHandle); } else { ctx.InternalSerializeReference(writer, memberValue, isDeclaredType, writeXsiType, DataContract.GetId(memberType.TypeHandle), memberType.TypeHandle); } //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 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 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); }