internal int ReflectionWriteMembers(XmlWriterDelegator xmlWriter, object obj, XmlObjectSerializerWriteContext context, ClassDataContract classContract, ClassDataContract derivedMostClassContract) { int memberCount = (classContract.BaseContract == null) ? 0 : ReflectionWriteMembers(xmlWriter, obj, context, classContract.BaseContract, derivedMostClassContract); Type classType = classContract.UnadaptedClassType; 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(); } bool writeXsiType = CheckIfMemberHasConflict(member, classContract, derivedMostClassContract); MemberInfo memberInfo = member.MemberInfo; object memberValue = ReflectionGetMemberValue(obj, memberInfo); if (writeXsiType || !ReflectionTryWritePrimitive(xmlWriter, context, memberType, memberValue, member.MemberInfo, null /*arrayItemIndex*/, ns, memberNames[i] /*nameLocal*/, i + _childElementIndex)) { ReflectionWriteStartElement(memberType, ns, ns.Value, member.Name, 0); if (classContract.ChildElementNamespaces[i + _childElementIndex] != null) { var nsChildElement = classContract.ChildElementNamespaces[i + _childElementIndex]; _arg0XmlWriter.WriteNamespaceDecl(nsChildElement); } ReflectionWriteValue(memberType, memberValue, writeXsiType); ReflectionWriteEndElement(); } } return 0; }
public void ReflectionWriteClass(XmlWriterDelegator xmlWriter, object obj, XmlObjectSerializerWriteContext context, ClassDataContract classContract, XmlDictionaryString[] memberNames) { InvokeOnSerializing(obj, context, classContract); obj = ResolveAdapterType(obj, classContract); ReflectionWriteMembers(xmlWriter, obj, context, classContract, classContract, 0 /*childElementIndex*/, memberNames); InvokeOnSerialized(obj, context, classContract); }
private void ReflectionInitArgs(XmlWriterDelegator xmlWriter, object obj, XmlObjectSerializerWriteContext context, ClassDataContract classContract) { if (obj.GetType() == typeof(DateTimeOffset)) { obj = DateTimeOffsetAdapter.GetDateTimeOffsetAdapter((DateTimeOffset)obj); } else if (obj.GetType().GetTypeInfo().IsGenericType && obj.GetType().GetGenericTypeDefinition() == typeof(KeyValuePair<,>)) { obj = classContract.KeyValuePairAdapterConstructorInfo.Invoke(new object[] { obj }); } _arg0XmlWriter = xmlWriter; _arg1Object = obj; _arg2Context = context; _arg3ClassDataContract = classContract; }
public void WriteCollectionToXml (XmlWriterDelegator xmlWriter, object obj, XmlObjectSerializerWriteContext context, CollectionDataContract collectionContract) { this.writer = xmlWriter; this.obj = obj; this.ctx = context; this.dataContract = collectionContract; InitArgs (collectionContract.UnderlyingType); // DemandMemberAccessPermission(memberAccessFlag); if (collectionContract.IsReadOnlyContract) { DataContract.ThrowInvalidDataContractException (collectionContract.SerializationExceptionMessage, null); } WriteCollection (collectionContract); }
public void WriteToXml (XmlWriterDelegator xmlWriter, object obj, XmlObjectSerializerWriteContext context, ClassDataContract dataContract) { this.writer = xmlWriter; this.obj = obj; this.ctx = context; this.dataContract = dataContract; InitArgs (classContract.UnderlyingType); // DemandSerializationFormatterPermission (classContract) - irrelevant // DemandMemberAccessPermission (memberAccessFlag) - irrelevant if (classContract.IsReadOnlyContract) { DataContract.ThrowInvalidDataContractException (classContract.SerializationExceptionMessage, null); } WriteClass (classContract); }
public override void WriteXmlValue(XmlWriterDelegator xmlWriter, object obj, XmlObjectSerializerWriteContext context) { xmlWriter.WriteAnyType(obj); }
public override void WriteXmlValue(XmlWriterDelegator xmlWriter, object obj, XmlObjectSerializerWriteContext context) { WriteEnumValue(xmlWriter, obj); }
private void WriteSystemExceptionRequiredValues(XmlWriterDelegator writer, object value, XmlObjectSerializerWriteContext context) { Dictionary<string, object> exceptionFields = GetExceptionFieldValues((Exception)value); object val; foreach (string key in exceptionFields.Keys) { if (!exceptionFields.TryGetValue(key, out val)) continue; Type fieldType; FieldInfo FieldFind = Globals.TypeOfException.GetField(key, BindingFlags.Instance | BindingFlags.NonPublic); if (FieldFind == null) { val = null; // need to nullify because the private fields that are necessary in Exception have changed. fieldType = typeof(int); // can be any type, it doesn't matter. field type will be used to recover a contract, but the type won't be utilized. } else fieldType = FieldFind.FieldType; string fieldDisplayName; if (EssentialExceptionFields.TryGetValue(key, out fieldDisplayName)) writer.WriteStartElement(fieldDisplayName, ""); else writer.WriteStartElement(key, ""); DataContract fieldDataContract = context.GetDataContract(fieldType); if (val != null && fieldDataContract != null && !TryCheckIfNoCountIDictionary(fieldType, val)) { if (!TryWritePrimitive(fieldType, val, writer, context)) { writer.WriteAttributeString(Globals.XsiPrefix, "type", null, "a:" + fieldDataContract.StableName.Name); writer.WriteXmlnsAttribute("a", new XmlDictionary(1).Add(fieldDataContract.StableName.Namespace)); fieldDataContract.WriteXmlValue(writer, val, context); } } else { writer.WriteAttributeString(Globals.XsiPrefix, "nil", null, "true"); } writer.WriteEndElement(); } }
private bool TryWritePrimitive(Type type, object value, XmlWriterDelegator writer, XmlObjectSerializerWriteContext context) { PrimitiveDataContract primitiveContract = PrimitiveDataContract.GetPrimitiveDataContract(type); if (primitiveContract == null || primitiveContract.UnderlyingType == Globals.TypeOfObject) return false; writer.WriteAttributeString(Globals.XsiPrefix, "type", null, "x:" + primitiveContract.StableName.Name); primitiveContract.WriteXmlValue(writer, value, context); return true; }
public override void WriteXmlValue(XmlWriterDelegator xmlWriter, object obj, XmlObjectSerializerWriteContext context) { SerializationInfo serInfo = new SerializationInfo(UnderlyingType, XmlObjectSerializer.FormatterConverter, !context.UnsafeTypeForwardingEnabled); SerializationSurrogateGetObjectData(obj, serInfo, context.GetStreamingContext()); context.WriteSerializationInfo(xmlWriter, UnderlyingType, serInfo); }
void InvokeOnSerialized(ClassDataContract classContract, object objSerialized, XmlObjectSerializerWriteContext context) { if (classContract.BaseContract != null) { InvokeOnSerialized(classContract.BaseContract, objSerialized, context); } if (classContract.OnSerialized != null) { classContract.OnSerialized.Invoke(objSerialized, new object [] { context.GetStreamingContext() }); } }
internal void ReflectionWriteClass(XmlWriterDelegator xmlWriter, object obj, XmlObjectSerializerWriteContext context, ClassDataContract classContract) { ReflectionInitArgs(xmlWriter, obj, context, classContract); ReflectionWriteMembers(xmlWriter, _arg1Object, _arg2Context, _arg3ClassDataContract, _arg3ClassDataContract); }
public override void WriteXmlValue(XmlWriterDelegator writer, object obj, XmlObjectSerializerWriteContext context) { writer.WriteDecimal((decimal)obj); }
private bool ReflectionTryWritePrimitive(XmlWriterDelegator xmlWriter, XmlObjectSerializerWriteContext context, Type type, object value, MemberInfo memberInfo, int? arrayItemIndex, XmlDictionaryString ns, XmlDictionaryString name, int nameIndex) { PrimitiveDataContract primitiveContract = PrimitiveDataContract.GetPrimitiveDataContract(type); if (primitiveContract == null || primitiveContract.UnderlyingType == Globals.TypeOfObject) return false; primitiveContract.WriteXmlElement(xmlWriter, value, context, name, ns); return true; }
internal void ReflectionWriteCollection(XmlWriterDelegator xmlWriter, object obj, XmlObjectSerializerWriteContext context, CollectionDataContract collectionDataContract) { ReflectionInitArgs(xmlWriter, obj, context, null); _arg3CollectionDataContract = collectionDataContract; XmlDictionaryString ns = collectionDataContract.Namespace; XmlDictionaryString itemName = collectionDataContract.CollectionItemName; if (collectionDataContract.Kind == CollectionKind.Array) { _arg2Context.IncrementArrayCount(xmlWriter, (Array)_arg1Object); Type itemType = collectionDataContract.ItemType; if (!ReflectionTryWritePrimitiveArray(collectionDataContract.UnderlyingType, itemType, itemName, ns)) { Array a = (Array)obj; for (int i = 0; i < a.Length; ++i) { ReflectionWriteStartElement(itemType, ns, ns.Value, itemName.Value, 0); ReflectionWriteValue(itemType, a.GetValue(i), false); ReflectionWriteEndElement(); } } } else { switch (collectionDataContract.Kind) { case CollectionKind.Collection: case CollectionKind.List: case CollectionKind.Dictionary: { _arg2Context.IncrementCollectionCount(xmlWriter, (ICollection)obj); } break; case CollectionKind.GenericCollection: case CollectionKind.GenericList: { MethodInfo incrementCollectionCountMethod = XmlFormatGeneratorStatics.IncrementCollectionCountGenericMethod.MakeGenericMethod(collectionDataContract.ItemType); incrementCollectionCountMethod.Invoke(context, new object[] { xmlWriter, obj }); } break; case CollectionKind.GenericDictionary: { MethodInfo incrementCollectionCountMethod = XmlFormatGeneratorStatics.IncrementCollectionCountGenericMethod.MakeGenericMethod(Globals.TypeOfKeyValuePair.MakeGenericType(collectionDataContract.ItemType.GetGenericArguments())); incrementCollectionCountMethod.Invoke(context, new object[] { xmlWriter, obj }); } break; } IEnumerator enumerator = ((IEnumerable)obj).GetEnumerator(); Type itemType = collectionDataContract.ItemType; bool isDictionary = false, isGenericDictionary = false; Type enumeratorType = null; Type[] keyValueTypes = null; if (collectionDataContract.Kind == CollectionKind.GenericDictionary) { isGenericDictionary = true; keyValueTypes = collectionDataContract.ItemType.GetGenericArguments(); enumeratorType = Globals.TypeOfGenericDictionaryEnumerator.MakeGenericType(keyValueTypes); Type ctorParam = Globals.TypeOfIEnumeratorGeneric.MakeGenericType(Globals.TypeOfKeyValuePair.MakeGenericType(keyValueTypes)); ConstructorInfo dictEnumCtor = enumeratorType.GetConstructor(Globals.ScanAllMembers, new Type[] { ctorParam }); IEnumerator genericDictEnumerator = (IEnumerator)dictEnumCtor.Invoke(new object[] { enumerator }); enumerator = genericDictEnumerator; } else if (collectionDataContract.Kind == CollectionKind.Dictionary) { isDictionary = true; keyValueTypes = new Type[] { Globals.TypeOfObject, Globals.TypeOfObject }; enumeratorType = Globals.TypeOfDictionaryEnumerator; IEnumerator nonGenericDictEnumerator = (IEnumerator)new CollectionDataContract.DictionaryEnumerator(((IDictionary)obj).GetEnumerator()); enumerator = nonGenericDictEnumerator; } while (enumerator.MoveNext()) { object current = enumerator.Current; _arg2Context.IncrementItemCount(1); if (!ReflectionTryWritePrimitive(_arg0XmlWriter, _arg2Context, itemType, current, null, null, ns, itemName, 0)) { ReflectionWriteStartElement(itemType, ns, ns.Value, itemName.Value, 0); if (isGenericDictionary || isDictionary) { _arg3CollectionDataContract.ItemContract.WriteXmlValue(_arg0XmlWriter, current, _arg2Context); } else { ReflectionWriteValue(itemType, current, false); } ReflectionWriteEndElement(); } } } }
protected override int ReflectionWriteMembers(XmlWriterDelegator xmlWriter, object obj, XmlObjectSerializerWriteContext context, ClassDataContract classContract, ClassDataContract derivedMostClassContract, int childElementIndex, XmlDictionaryString[] memberNames) { int memberCount = (classContract.BaseContract == null) ? 0 : ReflectionWriteMembers(xmlWriter, obj, context, classContract.BaseContract, derivedMostClassContract, childElementIndex, memberNames); childElementIndex += memberCount; Type classType = classContract.UnadaptedClassType; 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) { if (memberValue == null) { memberValue = ReflectionGetMemberValue(obj, member); } bool requiresNameAttribute = DataContractJsonSerializerImpl.CheckIfXmlNameRequiresMapping(classContract.MemberNames[i]); PrimitiveDataContract primitiveContract = member.MemberPrimitiveContract; if (requiresNameAttribute || !ReflectionTryWritePrimitive(xmlWriter, context, memberType, memberValue, memberNames[i + childElementIndex] /*name*/, null /*ns*/, primitiveContract)) { // Note: DataContractSerializer has member-conflict logic here to deal with the schema export // requirement that the same member can't be of two different types. if (requiresNameAttribute) { XmlObjectSerializerWriteContextComplexJson.WriteJsonNameWithMapping(xmlWriter, memberNames, i + childElementIndex); } else { ReflectionWriteStartElement(xmlWriter, memberNames[i + childElementIndex]); } ReflectionWriteValue(xmlWriter, context, memberType, memberValue, false /*writeXsiType*/, primitiveContractForParamType: null); ReflectionWriteEndElement(xmlWriter); } if (classContract.HasExtensionData) { context.WriteExtensionData(xmlWriter, ((IExtensibleDataObject)obj).ExtensionData, memberCount); } } } return(memberCount); }
public virtual void WriteXmlValue(XmlWriterDelegator xmlWriter, object obj, XmlObjectSerializerWriteContext context) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataContractException(System.Runtime.Serialization.SR.GetString("UnexpectedContractType", new object[] { GetClrTypeFullName(base.GetType()), GetClrTypeFullName(this.UnderlyingType) }))); }
protected override int ReflectionWriteMembers(XmlWriterDelegator xmlWriter, object obj, XmlObjectSerializerWriteContext context, ClassDataContract classContract, ClassDataContract derivedMostClassContract, int childElementIndex, XmlDictionaryString[]?memberNames) { Debug.Assert(memberNames != null); int memberCount = (classContract.BaseContract == null) ? 0 : ReflectionWriteMembers(xmlWriter, obj, context, classContract.BaseContract, derivedMostClassContract, childElementIndex, memberNames); childElementIndex += memberCount; 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) { if (memberValue == null) { memberValue = ReflectionGetMemberValue(obj, member); } bool requiresNameAttribute = DataContractJsonSerializerImpl.CheckIfXmlNameRequiresMapping(classContract.MemberNames ![i]);
public override void WriteXmlValue(XmlWriterDelegator writer, object obj, XmlObjectSerializerWriteContext context) { writer.WriteSignedByte((sbyte)obj); }
public override void WriteXmlValue(XmlWriterDelegator writer, object obj, XmlObjectSerializerWriteContext context) { // write nothing }
public override void WriteXmlValue(XmlWriterDelegator writer, object obj, XmlObjectSerializerWriteContext context) { writer.WriteUnsignedLong((ulong)obj); }
int WriteMembers(ClassDataContract classContract, ExtensionDataObject extensionData, ClassDataContract derivedMostClassContract) { int memberCount = (classContract.BaseContract == null) ? 0 : WriteMembers(classContract.BaseContract, extensionData, derivedMostClassContract); context.IncrementItemCount(classContract.Members.Count); for (int i = 0; i < classContract.Members.Count; i++, memberCount++) { DataMember member = classContract.Members[i]; Type memberType = member.MemberType; object memberValue = null; if (member.IsGetOnlyCollection) { context.StoreIsGetOnlyCollection(); } bool doWrite = true, hasMemberValue = false; if (!member.EmitDefaultValue) { hasMemberValue = true; memberValue = LoadMemberValue(member); doWrite = !IsDefaultValue(memberType, memberValue); } if (doWrite) { bool requiresNameAttribute = DataContractJsonSerializer.CheckIfXmlNameRequiresMapping(classContract.MemberNames [i]); if (requiresNameAttribute || !TryWritePrimitive(memberType, hasMemberValue ? () => memberValue : (Func <object>)null, member.MemberInfo, null /*arrayItemIndex*/, null /*nameLocal*/, i + childElementIndex)) { // Note: DataContractSerializer has member-conflict logic here to deal with the schema export // requirement that the same member can't be of two different types. if (requiresNameAttribute) { XmlObjectSerializerWriteContextComplexJson.WriteJsonNameWithMapping(writer, memberNames, i + childElementIndex); } else { WriteStartElement(null /*nameLocal*/, i + childElementIndex); } if (memberValue == null) { memberValue = LoadMemberValue(member); } WriteValue(memberType, memberValue); WriteEndElement(); } if (classContract.HasExtensionData) { context.WriteExtensionData(writer, extensionData, memberCount); } } else if (!member.EmitDefaultValue) { if (member.IsRequired) { XmlObjectSerializerWriteContext.ThrowRequiredMemberMustBeEmitted(member.Name, classContract.UnderlyingType); } } } typeIndex++; childElementIndex += classContract.Members.Count; return(memberCount); }
public override void WriteXmlValue(XmlWriterDelegator writer, object obj, XmlObjectSerializerWriteContext context) { writer.WriteBase64((byte[])obj); }
public override void WriteXmlValue(XmlWriterDelegator writer, object obj, XmlObjectSerializerWriteContext context) { writer.WriteQName((XmlQualifiedName)obj); }
public override void WriteXmlValue(XmlWriterDelegator writer, object obj, XmlObjectSerializerWriteContext context) { writer.WriteTimeSpan((TimeSpan)obj); }
public override void WriteXmlValue(XmlWriterDelegator writer, object obj, XmlObjectSerializerWriteContext context) { writer.WriteChar((char) obj); }
void InvokeOnSerialized (ClassDataContract classContract, object objSerialized, XmlObjectSerializerWriteContext context) { if (classContract.BaseContract != null) InvokeOnSerialized (classContract.BaseContract, objSerialized, context); if (classContract.OnSerialized != null) { classContract.OnSerialized.Invoke (objSerialized, new object [] {context.GetStreamingContext ()}); } }
public override void WriteXmlValue(XmlWriterDelegator xmlWriter, object obj, XmlObjectSerializerWriteContext context) { SerializationInfo serInfo = new SerializationInfo(base.UnderlyingType, XmlObjectSerializer.FormatterConverter); this.SerializationSurrogateGetObjectData(obj, serInfo, context.GetStreamingContext()); context.WriteSerializationInfo(xmlWriter, base.UnderlyingType, serInfo); }
private void WriteExceptionValue(XmlWriterDelegator writer, object value, XmlObjectSerializerWriteContext context) { /* * Every private field present in System.Exception that is serialized in the thick framework is also serialized in this method. * For classes that inherit from System.Exception all public properties are serialized. * The reason that the Members property is not used here to get the properties to serialize is because Members contains only the properties with setters. */ Type type = value.GetType(); writer.WriteXmlnsAttribute("x", new XmlDictionary(1).Add(Globals.SchemaNamespace)); WriteSystemExceptionRequiredValues(writer, value, context); PropertyInfo[] props = type.GetProperties(); foreach (PropertyInfo prop in props) { //Properties in System.Exception are handled in the call to WriteSystemExceptionRequiredValues, we don't want to repeat these properties. if (PropertyIsSystemExceptionProperty(prop)) continue; writer.WriteStartElement(prop.Name, ""); DataContract propDataContract = context.GetDataContract(prop.PropertyType); if (prop.GetValue(value) != null && propDataContract != null && !TryCheckIfNoCountIDictionary(prop.PropertyType, prop.GetValue(value))) { if (!TryWritePrimitive(prop.PropertyType, prop.GetValue(value), writer, context)) { writer.WriteAttributeString(Globals.XsiPrefix, "type", null, "a:" + propDataContract.StableName.Name); writer.WriteXmlnsAttribute("a", new XmlDictionary(1).Add(propDataContract.StableName.Namespace)); context.SerializeWithoutXsiType(propDataContract, writer, prop.GetValue(value), prop.PropertyType.TypeHandle); } } else { writer.WriteAttributeString(Globals.XsiPrefix, "nil", null, "true"); } writer.WriteEndElement(); } }
public override void WriteXmlValue(XmlWriterDelegator xmlWriter, object obj, XmlObjectSerializerWriteContext context) { throw CreateInvalidDataContractException(); }
public override void WriteXmlValue(XmlWriterDelegator xmlWriter, object obj, XmlObjectSerializerWriteContext context) { Type type = obj.GetType(); if (!(typeof(Exception).IsAssignableFrom(type))) { throw new InvalidDataContractException("Cannot use ExceptionDataContract to serialize object with type: " + type); } WriteExceptionValue(xmlWriter, obj, context); }
public override void WriteXmlElement(XmlWriterDelegator xmlWriter, object obj, XmlObjectSerializerWriteContext context, XmlDictionaryString name, XmlDictionaryString ns) { xmlWriter.WriteStartElement(name, ns); xmlWriter.WriteBase64((byte[])obj); xmlWriter.WriteEndElement(); }
public override void WriteXmlValue(XmlWriterDelegator xmlWriter, object obj, XmlObjectSerializerWriteContext context) { if (context == null) XmlObjectSerializerWriteContext.WriteRootIXmlSerializable(xmlWriter, obj); else context.WriteIXmlSerializable(xmlWriter, obj); }
public override void WriteXmlElement(XmlWriterDelegator xmlWriter, object obj, XmlObjectSerializerWriteContext context, XmlDictionaryString name, XmlDictionaryString ns) { xmlWriter.WriteGuid((Guid)obj, name, ns); }