private void StoreCollectionValue(LocalBuilder collection, LocalBuilder value, CollectionDataContract collectionContract) { if (collectionContract.Kind == CollectionKind.GenericDictionary || collectionContract.Kind == CollectionKind.Dictionary) { ClassDataContract keyValuePairContract = DataContract.GetDataContract(value.LocalType) as ClassDataContract; if (keyValuePairContract == null) { DiagnosticUtility.DebugAssert("Failed to create contract for KeyValuePair type"); } DataMember keyMember = keyValuePairContract.Members[0]; DataMember valueMember = keyValuePairContract.Members[1]; LocalBuilder pairKey = _ilg.DeclareLocal(keyMember.MemberType, keyMember.Name); LocalBuilder pairValue = _ilg.DeclareLocal(valueMember.MemberType, valueMember.Name); _ilg.LoadAddress(value); _ilg.LoadMember(keyMember.MemberInfo); _ilg.Stloc(pairKey); _ilg.LoadAddress(value); _ilg.LoadMember(valueMember.MemberInfo); _ilg.Stloc(pairValue); _ilg.Call(collection, collectionContract.AddMethod, pairKey, pairValue); if (collectionContract.AddMethod.ReturnType != Globals.TypeOfVoid) { _ilg.Pop(); } } else { _ilg.Call(collection, collectionContract.AddMethod, value); if (collectionContract.AddMethod.ReturnType != Globals.TypeOfVoid) { _ilg.Pop(); } } }
private void InitArgs(Type objType) { _xmlWriterArg = _ilg.GetArg(0); _contextArg = _ilg.GetArg(2); _dataContractArg = _ilg.GetArg(3); _objectLocal = _ilg.DeclareLocal(objType, "objSerialized"); ArgBuilder objectArg = _ilg.GetArg(1); _ilg.Load(objectArg); // Copy the data from the DataTimeOffset object passed in to the DateTimeOffsetAdapter. // DateTimeOffsetAdapter is used here for serialization purposes to bypass the ISerializable implementation // on DateTimeOffset; which does not work in partial trust. if (objType == Globals.TypeOfDateTimeOffsetAdapter) { _ilg.ConvertValue(objectArg.ArgType, Globals.TypeOfDateTimeOffset); _ilg.Call(XmlFormatGeneratorStatics.GetDateTimeOffsetAdapterMethod); } //Copy the KeyValuePair<K,T> to a KeyValuePairAdapter<K,T>. else if (objType.IsGenericType && objType.GetGenericTypeDefinition() == Globals.TypeOfKeyValuePairAdapter) { ClassDataContract dc = (ClassDataContract)DataContract.GetDataContract(objType); _ilg.ConvertValue(objectArg.ArgType, Globals.TypeOfKeyValuePair.MakeGenericType(dc.KeyValuePairGenericArguments)); _ilg.New(dc.KeyValuePairAdapterConstructorInfo); } else { _ilg.ConvertValue(objectArg.ArgType, objType); } _ilg.Stloc(_objectLocal); }
private void StoreCollectionValue(LocalBuilder collection, LocalBuilder value, CollectionDataContract collectionContract) { if ((collectionContract.Kind == CollectionKind.GenericDictionary) || (collectionContract.Kind == CollectionKind.Dictionary)) { ClassDataContract dataContract = DataContract.GetDataContract(value.LocalType) as ClassDataContract; DataMember member = dataContract.Members[0]; DataMember member2 = dataContract.Members[1]; LocalBuilder local = this.ilg.DeclareLocal(member.MemberType, member.Name); LocalBuilder builder2 = this.ilg.DeclareLocal(member2.MemberType, member2.Name); this.ilg.LoadAddress(value); this.ilg.LoadMember(member.MemberInfo); this.ilg.Stloc(local); this.ilg.LoadAddress(value); this.ilg.LoadMember(member2.MemberInfo); this.ilg.Stloc(builder2); this.ilg.Call(collection, collectionContract.AddMethod, local, builder2); if (collectionContract.AddMethod.ReturnType != Globals.TypeOfVoid) { this.ilg.Pop(); } } else { this.ilg.Call(collection, collectionContract.AddMethod, value); if (collectionContract.AddMethod.ReturnType != Globals.TypeOfVoid) { this.ilg.Pop(); } } }
internal DataContract GetDataContract(Type clrType) { if (dataContractSurrogate == null) { return(DataContract.GetDataContract(clrType)); } DataContract dataContract = DataContract.GetBuiltInDataContract(clrType); if (dataContract != null) { return(dataContract); } Type dcType = DataContractSurrogateCaller.GetDataContractType(dataContractSurrogate, clrType); //if (clrType.IsValueType != dcType.IsValueType) // throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataContractException(SR.GetString(SR.ValueTypeMismatchInSurrogatedType, dcType, clrType))); dataContract = DataContract.GetDataContract(dcType); if (!SurrogateDataTable.Contains(dataContract)) { object customData = DataContractSurrogateCaller.GetCustomDataToExport( dataContractSurrogate, clrType, dcType); if (customData != null) { SurrogateDataTable.Add(dataContract, customData); } } return(dataContract); }
public override bool TryResolveType(Type type, Type declaredType, DataContractResolver knownTypeResolver, out XmlDictionaryString typeName, out XmlDictionaryString typeNamespace) { if (type == null) { typeName = null; typeNamespace = null; return(false); } if (declaredType != null && declaredType.IsInterface && CollectionDataContract.IsCollectionInterface(declaredType)) { typeName = null; typeNamespace = null; return(true); } DataContract contract = DataContract.GetDataContract(type); if (_context.IsKnownType(contract, contract.KnownDataContracts, declaredType)) { typeName = contract.Name; typeNamespace = contract.Namespace; return(true); } else { typeName = null; typeNamespace = null; return(false); } }
internal virtual DataContract GetDataContract(RuntimeTypeHandle typeHandle, Type type) { if (this.IsGetOnlyCollection) { return(DataContract.GetGetOnlyCollectionDataContract(DataContract.GetId(typeHandle), typeHandle, type, this.Mode)); } return(DataContract.GetDataContract(typeHandle, type, this.Mode)); }
internal virtual DataContract GetDataContract(int id, RuntimeTypeHandle typeHandle) { if (this.IsGetOnlyCollection) { return(DataContract.GetGetOnlyCollectionDataContract(id, typeHandle, null, this.Mode)); } return(DataContract.GetDataContract(id, typeHandle, this.Mode)); }
internal virtual DataContract GetDataContract(RuntimeTypeHandle typeHandle, Type?type) { if (IsGetOnlyCollection) { return(DataContract.GetGetOnlyCollectionDataContract(DataContract.GetId(typeHandle), typeHandle, type)); } else { return(DataContract.GetDataContract(typeHandle, type)); } }
internal virtual DataContract GetDataContract(int id, RuntimeTypeHandle typeHandle) { if (IsGetOnlyCollection) { return(DataContract.GetGetOnlyCollectionDataContract(id, typeHandle, null /*type*/)); } else { return(DataContract.GetDataContract(id, typeHandle)); } }
internal static DataContract GetDataContract(DataContract declaredTypeContract, Type declaredType, Type objectType) { if (declaredType.IsInterface && CollectionDataContract.IsCollectionInterface(declaredType)) { return(declaredTypeContract); } if (declaredType.IsArray) { return(declaredTypeContract); } return(DataContract.GetDataContract(objectType.TypeHandle, objectType, SerializationMode.SharedContract)); }
internal static DataContract GetDataContractFromSurrogateSelector(ISurrogateSelector surrogateSelector, StreamingContext context, RuntimeTypeHandle typeHandle, Type type, ref Hashtable surrogateDataContracts) { if (surrogateSelector == null) { return(null); } if (type == null) { type = Type.GetTypeFromHandle(typeHandle); } DataContract builtInDataContract = DataContract.GetBuiltInDataContract(type); if (builtInDataContract != null) { return(builtInDataContract); } if (surrogateDataContracts != null) { DataContract cachedSurrogateContract = (DataContract)surrogateDataContracts[type]; if (cachedSurrogateContract != null) { return(cachedSurrogateContract); } } DataContract surrogateContract = null; ISerializationSurrogate surrogate = GetSurrogate(type, surrogateSelector, context); if (surrogate != null) { surrogateContract = new SurrogateDataContract(type, surrogate); } else if (type.IsArray) { Type elementType = type.GetElementType(); DataContract itemContract = GetDataContractFromSurrogateSelector(surrogateSelector, context, elementType.TypeHandle, elementType, ref surrogateDataContracts); if (itemContract == null) { itemContract = DataContract.GetDataContract(elementType.TypeHandle, elementType, SerializationMode.SharedType); } surrogateContract = new CollectionDataContract(type, itemContract); } if (surrogateContract != null) { if (surrogateDataContracts == null) { surrogateDataContracts = new Hashtable(); } surrogateDataContracts.Add(type, surrogateContract); return(surrogateContract); } return(null); }
public XmlQualifiedName?GetRootElementName(Type type) { ArgumentNullException.ThrowIfNull(type); type = GetSurrogatedType(type); DataContract dataContract = DataContract.GetDataContract(type); EnsureTypeNotGeneric(dataContract.UnderlyingType); if (dataContract is not XmlDataContract xdc || xdc.HasRoot) // All non-XmlDataContracts "have root". { return(new XmlQualifiedName(dataContract.TopLevelElementName !.Value, dataContract.TopLevelElementNamespace !.Value)); }
private void StoreCollectionValue(LocalBuilder collection, LocalBuilder value, CollectionDataContract collectionContract) { Debug.Assert(collectionContract.AddMethod != null); if (collectionContract.Kind == CollectionKind.GenericDictionary || collectionContract.Kind == CollectionKind.Dictionary) { ClassDataContract?keyValuePairContract = DataContract.GetDataContract(value.LocalType) as ClassDataContract; if (keyValuePairContract == null) { DiagnosticUtility.DebugAssert("Failed to create contract for KeyValuePair type"); } DataMember keyMember = keyValuePairContract.Members ![0];
public XmlSchemaType?GetSchemaType(Type type) { ArgumentNullException.ThrowIfNull(type); type = GetSurrogatedType(type); DataContract dataContract = DataContract.GetDataContract(type); EnsureTypeNotGeneric(dataContract.UnderlyingType); if (dataContract is XmlDataContract xmlDataContract && xmlDataContract.IsAnonymous) { return(xmlDataContract.XsdType); } return(null); }
public XmlQualifiedName GetSchemaTypeName(Type type) { ArgumentNullException.ThrowIfNull(type); type = GetSurrogatedType(type); DataContract dataContract = DataContract.GetDataContract(type); EnsureTypeNotGeneric(dataContract.UnderlyingType); if (dataContract is XmlDataContract xmlDataContract && xmlDataContract.IsAnonymous) { return(XmlQualifiedName.Empty); } return(dataContract.XmlName); }
internal static DataContract GetDataContract(DataContract declaredTypeContract, Type declaredType, Type objectType) { if (declaredType.IsInterface && CollectionDataContract.IsCollectionInterface(declaredType)) { return(declaredTypeContract); } else if (declaredType.IsArray)//Array covariance is not supported in XSD { return(declaredTypeContract); } else { return(DataContract.GetDataContract(objectType.TypeHandle, objectType)); } }
public XmlQualifiedName GetRootElementName(Type type) { if (type == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("type")); } type = this.GetSurrogatedType(type); DataContract dataContract = DataContract.GetDataContract(type); System.Runtime.Serialization.DataContractSet.EnsureTypeNotGeneric(dataContract.UnderlyingType); if (dataContract.HasRoot) { return(new XmlQualifiedName(dataContract.TopLevelElementName.Value, dataContract.TopLevelElementNamespace.Value)); } return(null); }
public XmlQualifiedName GetSchemaTypeName(Type type) { ArgumentNullException.ThrowIfNull(type); type = GetSurrogatedType(type); DataContract dataContract = DataContract.GetDataContract(type); DataContractSet.EnsureTypeNotGeneric(dataContract.UnderlyingType); XmlDataContract?xmlDataContract = dataContract as XmlDataContract; if (xmlDataContract != null && xmlDataContract.IsAnonymous) { return(XmlQualifiedName.Empty); } return(dataContract.StableName); }
public ExceptionDataContractCriticalHelper(Type type) : base(type) { this.StableName = DataContract.GetStableName(type, out _hasDataContract); Type baseType = Globals.TypeOfException; this.IsValueType = type.GetTypeInfo().IsValueType; if (baseType != null && baseType != Globals.TypeOfObject && type != Globals.TypeOfException) { DataContract baseContract = DataContract.GetDataContract(baseType); this.BaseContract = baseContract as ExceptionDataContract; } else { this.BaseContract = null; } ImportDataMembers(); ImportKnownTypes(); XmlDictionary dictionary = new XmlDictionary(2 + Members.Count); Name = dictionary.Add(StableName.Name); Namespace = dictionary.Add(StableName.Namespace); int baseContractCount = 0; if (BaseContract == null) { _memberNames = new XmlDictionaryString[Members.Count]; _memberNamespaces = new XmlDictionaryString[Members.Count]; _contractNamespaces = new XmlDictionaryString[1]; } else { _memberNames = new XmlDictionaryString[Members.Count]; _memberNamespaces = new XmlDictionaryString[Members.Count]; baseContractCount = BaseContract._contractNamespaces.Length; _contractNamespaces = new XmlDictionaryString[1 + baseContractCount]; Array.Copy(BaseContract._contractNamespaces, _contractNamespaces, baseContractCount); } _contractNamespaces[baseContractCount] = Namespace; for (int i = 0; i < Members.Count; i++) { _memberNames[i] = dictionary.Add(Members[i].Name); _memberNamespaces[i] = Namespace; } }
public XmlQualifiedName?GetRootElementName(Type type) { ArgumentNullException.ThrowIfNull(type); type = GetSurrogatedType(type); DataContract dataContract = DataContract.GetDataContract(type); DataContractSet.EnsureTypeNotGeneric(dataContract.UnderlyingType); if (dataContract.HasRoot) { return(new XmlQualifiedName(dataContract.TopLevelElementName !.Value, dataContract.TopLevelElementNamespace !.Value)); } else { return(null); } }
public XmlSchemaType GetSchemaType(Type type) { if (type == null) { throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException(nameof(type))); } type = GetSurrogatedType(type); DataContract dataContract = DataContract.GetDataContract(type); DataContractSet.EnsureTypeNotGeneric(dataContract.UnderlyingType); XmlDataContract xmlDataContract = dataContract as XmlDataContract; if (xmlDataContract != null && xmlDataContract.IsAnonymous) { return(xmlDataContract.XsdType); } return(null); }
public XmlQualifiedName GetSchemaTypeName(Type type) { if (type == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("type")); } type = this.GetSurrogatedType(type); DataContract dataContract = DataContract.GetDataContract(type); System.Runtime.Serialization.DataContractSet.EnsureTypeNotGeneric(dataContract.UnderlyingType); XmlDataContract contract2 = dataContract as XmlDataContract; if ((contract2 != null) && contract2.IsAnonymous) { return(XmlQualifiedName.Empty); } return(dataContract.StableName); }
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 }); } }
internal DataContract GetDataContract(RuntimeTypeHandle typeHandle, Type type, ref Hashtable surrogateDataContracts) { DataContract contract = GetDataContractFromSurrogateSelector(this.surrogateSelector, this.Context, typeHandle, type, ref surrogateDataContracts); if (contract != null) { return(contract); } if (this.cachedDataContract == null) { contract = DataContract.GetDataContract(typeHandle, type, SerializationMode.SharedType); this.cachedDataContract = contract; return(contract); } DataContract cachedDataContract = this.cachedDataContract; if (cachedDataContract.UnderlyingType.TypeHandle.Equals(typeHandle)) { return(cachedDataContract); } return(DataContract.GetDataContract(typeHandle, type, SerializationMode.SharedType)); }
internal DataContract GetDataContract(Type clrType) { if (this.dataContractSurrogate == null) { return(DataContract.GetDataContract(clrType)); } DataContract builtInDataContract = DataContract.GetBuiltInDataContract(clrType); if (builtInDataContract == null) { Type dataContractType = DataContractSurrogateCaller.GetDataContractType(this.dataContractSurrogate, clrType); builtInDataContract = DataContract.GetDataContract(dataContractType); if (!this.SurrogateDataTable.Contains(builtInDataContract)) { object obj2 = DataContractSurrogateCaller.GetCustomDataToExport(this.dataContractSurrogate, clrType, dataContractType); if (obj2 != null) { this.SurrogateDataTable.Add(builtInDataContract, obj2); } } } return(builtInDataContract); }
internal DataContract GetDataContract(Type clrType) { #if SUPPORT_SURROGATE if (_dataContractSurrogate == null) { return(DataContract.GetDataContract(clrType)); } #endif DataContract?dataContract = DataContract.GetBuiltInDataContract(clrType); if (dataContract != null) { return(dataContract); } #if SUPPORT_SURROGATE Type dcType = DataContractSurrogateCaller.GetDataContractType(_dataContractSurrogate, clrType); if (clrType.IsValueType != dcType.IsValueType) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataContractException(SR.GetString(SR.ValueTypeMismatchInSurrogatedType, dcType, clrType))); } #endif Type dcType = clrType; dataContract = DataContract.GetDataContract(dcType); #if SUPPORT_SURROGATE if (!SurrogateDataTable.Contains(dataContract)) { object customData = DataContractSurrogateCaller.GetCustomDataToExport( _dataContractSurrogate, clrType, dcType); if (customData != null) { SurrogateDataTable.Add(dataContract, customData); } } #endif return(dataContract); }
protected virtual void SerializeWithXsiType(XmlWriterDelegator xmlWriter, object obj, RuntimeTypeHandle objectTypeHandle, Type objectType, int declaredTypeID, RuntimeTypeHandle declaredTypeHandle, Type declaredType) { bool verifyKnownType = false; #if !NET_NATIVE DataContract dataContract; if (declaredType.GetTypeInfo().IsInterface&& CollectionDataContract.IsCollectionInterface(declaredType)) { dataContract = GetDataContractSkipValidation(DataContract.GetId(objectTypeHandle), objectTypeHandle, objectType); if (OnHandleIsReference(xmlWriter, dataContract, obj)) { return; } dataContract = GetDataContract(declaredTypeHandle, declaredType); #else DataContract dataContract = DataContract.GetDataContract(declaredType); if (dataContract.TypeIsInterface && dataContract.TypeIsCollectionInterface) { if (OnHandleIsReference(xmlWriter, dataContract, obj)) { return; } if (this.Mode == SerializationMode.SharedType && dataContract.IsValidContract(this.Mode)) { dataContract = dataContract.GetValidContract(this.Mode); } else { dataContract = GetDataContract(declaredTypeHandle, declaredType); } #endif if (!WriteClrTypeInfo(xmlWriter, dataContract) && DataContractResolver != null) { if (objectType == null) { objectType = Type.GetTypeFromHandle(objectTypeHandle); } WriteResolvedTypeInfo(xmlWriter, objectType, declaredType); } } else if (declaredType.IsArray)//Array covariance is not supported in XSD. If declared type is array do not write xsi:type. Instead write xsi:type for each item { // A call to OnHandleIsReference is not necessary here -- arrays cannot be IsReference dataContract = GetDataContract(objectTypeHandle, objectType); WriteClrTypeInfo(xmlWriter, dataContract); dataContract = GetDataContract(declaredTypeHandle, declaredType); } else { dataContract = GetDataContract(objectTypeHandle, objectType); if (OnHandleIsReference(xmlWriter, dataContract, obj)) { return; } if (!WriteClrTypeInfo(xmlWriter, dataContract)) { DataContract declaredTypeContract = (declaredTypeID >= 0) ? GetDataContract(declaredTypeID, declaredTypeHandle) : GetDataContract(declaredTypeHandle, declaredType); verifyKnownType = WriteTypeInfo(xmlWriter, dataContract, declaredTypeContract); } } SerializeAndVerifyType(dataContract, xmlWriter, obj, verifyKnownType, declaredTypeHandle, declaredType); }
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 if (memberType == Globals.TypeOfObject) { var dataContract = DataContract.GetDataContract(memberValue.GetType()); writer.WriteAttributeQualifiedName(Globals.XsiPrefix, DictionaryGlobals.XsiTypeLocalName, DictionaryGlobals.SchemaInstanceNamespace, dataContract.Name, dataContract.Namespace); ctx.InternalSerializeReference(writer, memberValue, false, false, -1, typeHandleValue); } else { ctx.InternalSerializeReference(writer, memberValue, isDeclaredType, writeXsiType, DataContract.GetId(memberType.TypeHandle), memberType.TypeHandle); } } } } } }