C# Serialization.XmlObjectSerializer类代码示例

		public XmlObjectSerializerBodyWriter (
			object body, XmlObjectSerializer formatter)
			: base (true)
		{
			this.body = body;
			this.formatter = formatter;
		}

 private XmlObjectSerializerHeader(XmlObjectSerializer serializer, bool mustUnderstand, string actor, bool relay)
 {
     this.syncRoot = new object();
     if (actor == null)
     {
         throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("actor");
     }
     this.mustUnderstand = mustUnderstand;
     this.relay = relay;
     this.serializer = serializer;
     this.actor = actor;
     if (actor == EnvelopeVersion.Soap12.UltimateDestinationActor)
     {
         this.isOneOneSupported = false;
         this.isOneTwoSupported = true;
     }
     else if (actor == EnvelopeVersion.Soap12.NextDestinationActorValue)
     {
         this.isOneOneSupported = false;
         this.isOneTwoSupported = true;
     }
     else if (actor == EnvelopeVersion.Soap11.NextDestinationActorValue)
     {
         this.isOneOneSupported = true;
         this.isOneTwoSupported = false;
     }
     else
     {
         this.isOneOneSupported = true;
         this.isOneTwoSupported = true;
         this.isNoneSupported = true;
     }
 }

        public static object Deserialize(string xmlContent, string serializerType)
        {
            object returnValue = null;
            SerializerTypes serializerTypeValue;
            Type instanceType;
            GetSerializerDetails(serializerType, out serializerTypeValue, out instanceType);

            if (serializerTypeValue == SerializerTypes.XmlSerializer)
            {
                StringReader sww = new StringReader(xmlContent);
                XmlReader reader = XmlReader.Create(sww);
                System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(instanceType);
                returnValue = serializer.Deserialize(reader);
            }
            else if (serializerTypeValue == SerializerTypes.XmlObjectSerializer)
            {
                XmlObjectSerializer serializer = new XmlObjectSerializer();
                returnValue = serializer.Deserialize(xmlContent, true);
            }
            else
            {
                if (instanceType == typeof(string))
                {
                    returnValue = xmlContent;
                }
                else
                {
                    var method = instanceType.GetMethod("Parse", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public);
                    returnValue = method.Invoke(null, new object[] { xmlContent });
                }
            }
            return returnValue;
        }

        public MessageSubscribtionInfo(DataContractKey contractKey, ICallHandler handler, XmlObjectSerializer serializer, bool receiveSelfPublish, IEnumerable<BusHeader> filterHeaders)
        {
            _handler = handler;
            _serializer = serializer;

            _filterInfo = new MessageFilterInfo(contractKey, receiveSelfPublish, filterHeaders);
        }

 private WebFormatterSerializationContext(XmlObjectSerializer xmlSerializer)
 {
     if (xmlSerializer is DataContractJsonSerializer)
         ContentFormat = SerializationFormat.Json;
     else
         ContentFormat = SerializationFormat.Xml;
     XmlSerializer = xmlSerializer;
 }

 public static MessageHeader CreateHeader(string name, string ns, object value, XmlObjectSerializer serializer, bool mustUnderstand, string actor, bool relay)
 {
     if (serializer == null)
     {
         throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("serializer"));
     }
     return new XmlObjectSerializerHeader(name, ns, value, serializer, mustUnderstand, actor, relay);
 }

 internal XmlObjectSerializerContext(XmlObjectSerializer serializer, int maxItemsInObjectGraph, StreamingContext streamingContext, bool ignoreExtensionDataObject, DataContractResolver dataContractResolver)
 {
     this.serializer = serializer;
     this.itemCount = 1;
     this.maxItemsInObjectGraph = maxItemsInObjectGraph;
     this.streamingContext = streamingContext;
     this.ignoreExtensionDataObject = ignoreExtensionDataObject;
     this.dataContractResolver = dataContractResolver;
 }

 public XmlObjectSerializerFault(FaultCode code, FaultReason reason, object detail, XmlObjectSerializer serializer, string actor, string node)
 {
     this.code = code;
     this.reason = reason;
     this.detail = detail;
     this.serializer = serializer;
     this.actor = actor;
     this.node = node;
 }

 internal XmlObjectSerializerContext(XmlObjectSerializer serializer, int maxItemsInObjectGraph, StreamingContext streamingContext, bool ignoreExtensionDataObject, System.Runtime.Serialization.DataContractResolver dataContractResolver)
 {
     this.scopedKnownTypes = new ScopedKnownTypes();
     this.serializer = serializer;
     this.itemCount = 1;
     this.maxItemsInObjectGraph = maxItemsInObjectGraph;
     this.streamingContext = streamingContext;
     this.ignoreExtensionDataObject = ignoreExtensionDataObject;
     this.dataContractResolver = dataContractResolver;
 }

        public JsonSerializer(Type type, XmlObjectSerializer fallbackSerializer, bool isCompress,
            SerializeContentTypes contentType)
        {
            this.type = type;
            this.isCustomSerialization = true;
            this.fallbackSerializer = fallbackSerializer;

            m_IsCompress = isCompress;
            m_ContentType = contentType;
        }

        /// <remarks>
        /// DataContractJsonSerializer : XmlObjectSerializer (abstract)
        /// DataContractSerializer : XmlObjectSerializer (abstract)
        /// </remarks>
        private string WriteObject(Location location, XmlObjectSerializer serializer)
        {
            var memoryStream = new System.IO.MemoryStream();

            serializer.WriteObject(memoryStream, location);

            memoryStream.Position = 0;
            var reader = new System.IO.StreamReader(memoryStream);
            var output = reader.ReadToEnd();
            return output;
        }

        static byte[] Serialize(object result, XmlObjectSerializer serializer)
        {
            byte[] body;
            using (var stream = new MemoryStream())
            {
                serializer.WriteObject(stream, result);
                body = stream.ToArray();
            }

            //hack to remove the type info from the json
            var bodyString = Encoding.UTF8.GetString(body);

            var toReplace = $", {result.GetType().Assembly.GetName().Name}";

            bodyString = bodyString.Replace(toReplace, ", ServiceControl");

            body = Encoding.UTF8.GetBytes(bodyString);
            return body;
        }

        public static ClaimSet DeserializeClaimSet(XmlDictionaryReader reader, SctClaimDictionary dictionary, XmlObjectSerializer serializer, XmlObjectSerializer claimSerializer)
        {
            if (reader.IsStartElement(dictionary.NullValue, dictionary.EmptyString))
            {
                reader.ReadElementString();
                return null;
            }
            else if (reader.IsStartElement(dictionary.X509CertificateClaimSet, dictionary.EmptyString))
            {
                reader.ReadStartElement();
                byte[] rawData = reader.ReadContentAsBase64();
                reader.ReadEndElement();
                return new X509CertificateClaimSet(new X509Certificate2(rawData), false);
            }
            else if (reader.IsStartElement(dictionary.SystemClaimSet, dictionary.EmptyString))
            {
                reader.ReadElementString();
                return ClaimSet.System;
            }
            else if (reader.IsStartElement(dictionary.WindowsClaimSet, dictionary.EmptyString))
            {
                reader.ReadElementString();
                return ClaimSet.Windows;
            }
            else if (reader.IsStartElement(dictionary.AnonymousClaimSet, dictionary.EmptyString))
            {
                reader.ReadElementString();
                return ClaimSet.Anonymous;
            }
            else if (reader.IsStartElement(dictionary.ClaimSet, dictionary.EmptyString))
            {
                ClaimSet issuer = null;
                List<Claim> claims = new List<Claim>();
                reader.ReadStartElement();

                if (reader.IsStartElement(dictionary.PrimaryIssuer, dictionary.EmptyString))
                {
                    reader.ReadStartElement();
                    issuer = DeserializeClaimSet(reader, dictionary, serializer, claimSerializer);
                    reader.ReadEndElement();
                }

                while (reader.IsStartElement())
                {
                    reader.ReadStartElement();
                    claims.Add(DeserializeClaim(reader, dictionary, claimSerializer));
                    reader.ReadEndElement();
                }

                reader.ReadEndElement();
                return issuer != null ? new DefaultClaimSet(issuer, claims) : new DefaultClaimSet(claims);
            }
            else
            {
                return (ClaimSet)serializer.ReadObject(reader);
            }
        }

		object ReadHeaderObject (Type type, XmlObjectSerializer serializer, XmlDictionaryReader reader)
		{
			// FIXME: it's a nasty workaround just to avoid UniqueId output as a string.
			// Seealso MessageHeader.DefaultMessageHeader.OnWriteHeaderContents().
			// Note that msg.Headers.GetHeader<UniqueId> () simply fails (on .NET too) and it is useless. The API is lame by design.
			if (type == typeof (UniqueId))
				return new UniqueId (reader.ReadElementContentAsString ());
			else
				return serializer.ReadObject (reader);
		}

 internal XmlObjectSerializerReadContextComplex(XmlObjectSerializer serializer, int maxItemsInObjectGraph, StreamingContext streamingContext, bool ignoreExtensionDataObject)
     : base(serializer, maxItemsInObjectGraph, streamingContext, ignoreExtensionDataObject)
 {
 }