C# XmlWriterDelegator.WriteAttributeString方法代码示例

        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;
        }

        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();
            }
        }

 internal override void InternalWriteStartObject(XmlWriterDelegator writer, object graph)
 {
     if (this.rootNameRequiresMapping)
     {
         writer.WriteStartElement("a", "item", "item");
         writer.WriteAttributeString(null, "item", null, this.RootName.Value);
     }
     else
     {
         writer.WriteStartElement(this.RootName, XmlDictionaryString.Empty);
     }
 }

 internal static void WriteJsonNull(XmlWriterDelegator writer)
 {
     writer.WriteAttributeString(null, "type", null, "null");
 }

 internal override void InternalWriteStartObject(XmlWriterDelegator writer, object graph)
 {
     if (_rootNameRequiresMapping)
     {
         writer.WriteStartElement("a", JsonGlobals.itemString, JsonGlobals.itemString);
         writer.WriteAttributeString(null, JsonGlobals.itemString, null, RootName.Value);
     }
     else
     {
         writer.WriteStartElement(RootName, XmlDictionaryString.Empty);
     }
 }

 internal static void WriteJsonNull(XmlWriterDelegator writer)
 {
     writer.WriteAttributeString(null, JsonGlobals.typeString, null, JsonGlobals.nullString); //  prefix //  namespace 
 }

 public override void WriteJsonValueCore(XmlWriterDelegator jsonWriter, object obj, XmlObjectSerializerWriteContextComplexJson context, RuntimeTypeHandle declaredTypeHandle)
 {
     jsonWriter.WriteAttributeString(null, JsonGlobals.typeString, null, JsonGlobals.objectString);
 }

 public override void WriteJsonValueCore(XmlWriterDelegator jsonWriter, object obj, XmlObjectSerializerWriteContextComplexJson context, RuntimeTypeHandle declaredTypeHandle)
 {
     jsonWriter.WriteAttributeString(null, "type", null, "object");
     this.JsonFormatWriterDelegate(jsonWriter, obj, context, this.TraditionalClassDataContract, this.MemberNames);
 }

 private void WriteTypeInfo(XmlWriterDelegator writer, string typeInformation)
 {
     writer.WriteAttributeString(null, "__type", null, typeInformation);
 }

 internal static void WriteJsonNameWithMapping(XmlWriterDelegator xmlWriter, XmlDictionaryString[] memberNames, int index)
 {
     xmlWriter.WriteStartElement("a", "item", "item");
     xmlWriter.WriteAttributeString(null, "item", null, memberNames[index].Value);
 }

 internal override void WriteExtensionDataTypeInfo(XmlWriterDelegator xmlWriter, IDataNode dataNode)
 {
     Type dataType = dataNode.DataType;
     if ((dataType == Globals.TypeOfClassDataNode) || (dataType == Globals.TypeOfISerializableDataNode))
     {
         xmlWriter.WriteAttributeString(null, "type", null, "object");
         base.WriteExtensionDataTypeInfo(xmlWriter, dataNode);
     }
     else if (dataType == Globals.TypeOfCollectionDataNode)
     {
         xmlWriter.WriteAttributeString(null, "type", null, "array");
     }
     else if ((dataType != Globals.TypeOfXmlDataNode) && (((dataType == Globals.TypeOfObject) && (dataNode.Value != null)) && RequiresJsonTypeInfo(base.GetDataContract(dataNode.Value.GetType()))))
     {
         base.WriteExtensionDataTypeInfo(xmlWriter, dataNode);
     }
 }