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); }
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); }
private WebFormatterSerializationContext(XmlObjectSerializer xmlSerializer) { if (xmlSerializer is DataContractJsonSerializer) ContentFormat = SerializationFormat.Json; else ContentFormat = SerializationFormat.Xml; XmlSerializer = xmlSerializer; }
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; }
public FileTape(string tapeFolder) { if (string.IsNullOrEmpty(tapeFolder)) throw new ArgumentNullException("tapeFolder"); _tapeFolder = tapeFolder; _serializer = new NetDataContractSerializer(); }
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; }
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 XmlObjectSerializerHeader(string name, string ns, object objectToSerialize, XmlObjectSerializer serializer, bool mustUnderstand, string actor, bool relay) : this(serializer, mustUnderstand, actor, relay) { if (name == null) { throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("name")); } if (name.Length == 0) { throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(System.ServiceModel.SR.GetString("SFXHeaderNameCannotBeNullOrEmpty"), "name")); } if (ns == null) { throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("ns"); } if (ns.Length > 0) { NamingHelper.CheckUriParameter(ns, "ns"); } this.objectToSerialize = objectToSerialize; this.name = name; this.ns = ns; }
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); } }
private CollectionDataNode ReadUnknownCollectionData(XmlReaderDelegator xmlReader, string?dataContractName, string?dataContractNamespace) { Debug.Assert(attributes != null); var dataNode = new CollectionDataNode(); InitializeExtensionDataNode(dataNode, dataContractName, dataContractNamespace); int arraySize = attributes.ArraySZSize; XmlNodeType nodeType; while ((nodeType = xmlReader.MoveToContent()) != XmlNodeType.EndElement) { if (nodeType != XmlNodeType.Element) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateUnexpectedStateException(XmlNodeType.Element, xmlReader)); } if (dataNode.ItemName == null) { dataNode.ItemName = xmlReader.LocalName; dataNode.ItemNamespace = xmlReader.NamespaceURI; } if (xmlReader.IsStartElement(dataNode.ItemName, dataNode.ItemNamespace !)) { if (dataNode.Items == null) { dataNode.Items = new List <IDataNode?>(); } dataNode.Items.Add(ReadExtensionDataValue(xmlReader)); } else { SkipUnknownElement(xmlReader); } } xmlReader.ReadEndElement(); if (arraySize != -1) { dataNode.Size = arraySize; if (dataNode.Items == null) { if (dataNode.Size > 0) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.Format(SR.ArraySizeAttributeIncorrect, arraySize, 0))); } } else if (dataNode.Size != dataNode.Items.Count) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.Format(SR.ArraySizeAttributeIncorrect, arraySize, dataNode.Items.Count))); } } else { if (dataNode.Items != null) { dataNode.Size = dataNode.Items.Count; } else { dataNode.Size = 0; } } return(dataNode); }
// Pattern-recognition logic: the method reads XML elements into DOM. To recognize as an array, it requires that // all items have the same name and namespace. To recognize as an ISerializable type, it requires that all // items be unqualified. If the XML only contains elements (no attributes or other nodes) is recognized as a // class/class hierarchy. Otherwise it is deserialized as XML. private IDataNode ReadAndResolveUnknownXmlData(XmlReaderDelegator xmlReader, IDictionary <string, string>?namespaces, string?dataContractName, string?dataContractNamespace) { bool couldBeISerializableData = true; bool couldBeCollectionData = true; bool couldBeClassData = true; string?elementNs = null, elementName = null; var xmlChildNodes = new List <XmlNode>(); IList <XmlAttribute>?xmlAttributes = null; if (namespaces != null) { xmlAttributes = new List <XmlAttribute>(); foreach (KeyValuePair <string, string> prefixNsPair in namespaces) { xmlAttributes.Add(AddNamespaceDeclaration(prefixNsPair.Key, prefixNsPair.Value)); } } XmlNodeType nodeType; while ((nodeType = xmlReader.NodeType) != XmlNodeType.EndElement) { if (nodeType == XmlNodeType.Element) { string ns = xmlReader.NamespaceURI; string name = xmlReader.LocalName; if (couldBeISerializableData) { couldBeISerializableData = (ns.Length == 0); } if (couldBeCollectionData) { if (elementName == null) { elementName = name; elementNs = ns; } else { couldBeCollectionData = (string.CompareOrdinal(elementName, name) == 0) && (string.CompareOrdinal(elementNs, ns) == 0); } } } else if (xmlReader.EOF) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.UnexpectedEndOfFile)); } else if (IsContentNode(xmlReader.NodeType)) { couldBeClassData = couldBeISerializableData = couldBeCollectionData = false; } if (_attributesInXmlData == null) { _attributesInXmlData = new Attributes(); } _attributesInXmlData.Read(xmlReader); XmlNode childNode = Document.ReadNode(xmlReader.UnderlyingReader) !; xmlChildNodes.Add(childNode); if (namespaces == null) { if (_attributesInXmlData.XsiTypeName != null) { childNode.Attributes !.Append(AddNamespaceDeclaration(_attributesInXmlData.XsiTypePrefix, _attributesInXmlData.XsiTypeNamespace)); } if (_attributesInXmlData.FactoryTypeName != null) { childNode.Attributes !.Append(AddNamespaceDeclaration(_attributesInXmlData.FactoryTypePrefix, _attributesInXmlData.FactoryTypeNamespace)); } } } xmlReader.ReadEndElement(); if (elementName != null && couldBeCollectionData) { return(ReadUnknownCollectionData(CreateReaderOverChildNodes(xmlAttributes, xmlChildNodes), dataContractName, dataContractNamespace)); } else if (couldBeISerializableData) { return(ReadUnknownISerializableData(CreateReaderOverChildNodes(xmlAttributes, xmlChildNodes), dataContractName, dataContractNamespace)); } else if (couldBeClassData) { return(ReadUnknownClassData(CreateReaderOverChildNodes(xmlAttributes, xmlChildNodes), dataContractName, dataContractNamespace)); } else { XmlDataNode dataNode = new XmlDataNode(); InitializeExtensionDataNode(dataNode, dataContractName, dataContractNamespace); dataNode.OwnerDocument = Document; dataNode.XmlChildNodes = xmlChildNodes; dataNode.XmlAttributes = xmlAttributes; return(dataNode); } }
public override void WriteFullEndElement() { if (_depth == 0) { throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.Format(SR.IXmlSerializableWritePastSubTree, (_obj == null ? string.Empty : DataContract.GetClrTypeFullName(_obj.GetType()))))); } _xmlWriter.WriteFullEndElement(); _depth--; }
internal XmlObjectSerializerWriteContext(XmlObjectSerializer serializer, int maxItemsInObjectGraph, StreamingContext streamingContext, bool ignoreExtensionDataObject) : base(serializer, maxItemsInObjectGraph, streamingContext, ignoreExtensionDataObject) { // Known types restricts the set of types that can be deserialized _unsafeTypeForwardingEnabled = true; }
internal XmlObjectSerializerContext(XmlObjectSerializer serializer, int maxItemsInObjectGraph, StreamingContext streamingContext, bool ignoreExtensionDataObject) : this(serializer, maxItemsInObjectGraph, streamingContext, ignoreExtensionDataObject, null) { }
internal XmlObjectSerializerReadContextComplex(XmlObjectSerializer serializer, int maxItemsInObjectGraph, StreamingContext streamingContext, bool ignoreExtensionDataObject) : base(serializer, maxItemsInObjectGraph, streamingContext, ignoreExtensionDataObject) { }
internal static Exception CreateSerializationException(string message) #endif { return(XmlObjectSerializer.CreateSerializationException(message)); }
internal static Exception CreateUnexpectedStateException(XmlNodeType expectedState, XmlReaderDelegator xmlReader) #endif { return(XmlObjectSerializer.CreateSerializationExceptionWithReaderDetails(string.Format(SRSerialization.ExpectingState, expectedState), xmlReader)); }
public static void ThrowDuplicateMemberException(object obj, XmlDictionaryString[] memberNames, int memberIndex) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.Format(SR.JsonDuplicateMemberInInput, DataContract.GetClrTypeFullName(obj.GetType()), memberNames[memberIndex]))); }
internal static void ThrowRequiredMemberMissingException(XmlReaderDelegator xmlReader, int memberIndex, int requiredIndex, XmlDictionaryString[] memberNames) #endif { StringBuilder stringBuilder = new StringBuilder(); if (requiredIndex == memberNames.Length) { requiredIndex--; } for (int i = memberIndex + 1; i <= requiredIndex; i++) { if (stringBuilder.Length != 0) { stringBuilder.Append(" | "); } stringBuilder.Append(memberNames[i].Value); } throw /*System.Runtime.Serialization.*/ DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(XmlObjectSerializer.TryAddLineInfo(xmlReader, string.Format(SRSerialization.UnexpectedElementExpectingElements, xmlReader.NodeType, xmlReader.LocalName, xmlReader.NamespaceURI, stringBuilder.ToString())))); }
protected object InternalDeserialize(XmlReaderDelegator reader, string name, string ns, ref DataContract dataContract) { object retObj = null; if (TryHandleNullOrRef(reader, dataContract.UnderlyingType, name, ns, ref retObj)) { return(retObj); } bool knownTypesAddedInCurrentScope = false; if (dataContract.KnownDataContracts != null) { scopedKnownTypes.Push(dataContract.KnownDataContracts); knownTypesAddedInCurrentScope = true; } if (attributes.XsiTypeName != null) { dataContract = ResolveDataContractFromKnownTypes(attributes.XsiTypeName, attributes.XsiTypeNamespace, dataContract); if (dataContract == null) { if (DataContractResolver == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(XmlObjectSerializer.TryAddLineInfo(reader, string.Format(SRSerialization.DcTypeNotFoundOnDeserialize, attributes.XsiTypeNamespace, attributes.XsiTypeName, reader.NamespaceURI, reader.LocalName)))); } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(XmlObjectSerializer.TryAddLineInfo(reader, string.Format(SRSerialization.DcTypeNotResolvedOnDeserialize, attributes.XsiTypeNamespace, attributes.XsiTypeName, reader.NamespaceURI, reader.LocalName)))); } knownTypesAddedInCurrentScope = ReplaceScopedKnownTypesTop(dataContract.KnownDataContracts, knownTypesAddedInCurrentScope); } if (knownTypesAddedInCurrentScope) { object obj = ReadDataContractValue(dataContract, reader); scopedKnownTypes.Pop(); return(obj); } else { return(ReadDataContractValue(dataContract, reader)); } }
protected bool TryHandleNullOrRef(XmlReaderDelegator reader, Type declaredType, string name, string ns, ref object retObj) { ReadAttributes(reader); if (attributes.Ref != Globals.NewObjectId) { if (_isGetOnlyCollection) { throw /*System.Runtime.Serialization.*/ DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(string.Format(SRSerialization.ErrorDeserializing, string.Format(SRSerialization.ErrorTypeInfo, DataContract.GetClrTypeFullName(declaredType)), string.Format(SRSerialization.XmlStartElementExpected, Globals.RefLocalName)))); } else { retObj = GetExistingObject(attributes.Ref, declaredType, name, ns); reader.Skip(); return(true); } } else if (attributes.XsiNil) { reader.Skip(); return(true); } return(false); }
static void SerializePrimaryIdentity(IIdentity identity, SctClaimDictionary dictionary, XmlDictionaryWriter writer, XmlObjectSerializer serializer) { if (identity != null && identity != SecurityUtils.AnonymousIdentity) { writer.WriteStartElement(dictionary.PrimaryIdentity, dictionary.EmptyString); if (identity is WindowsIdentity) { WindowsIdentity wid = (WindowsIdentity)identity; writer.WriteStartElement(dictionary.WindowsSidIdentity, dictionary.EmptyString); WriteSidAttribute(wid.User, dictionary, writer); // This is to work around WOW64 bug Windows OS 1491447 string authenticationType = null; using (WindowsIdentity self = WindowsIdentity.GetCurrent()) { // is owner or admin? AuthenticationType could throw un-authorized exception if ((self.User == wid.Owner) || (wid.Owner != null && self.Groups.Contains(wid.Owner)) || (wid.Owner != SecurityUtils.AdministratorsSid && self.Groups.Contains(SecurityUtils.AdministratorsSid))) { authenticationType = wid.AuthenticationType; } } if (!String.IsNullOrEmpty(authenticationType)) writer.WriteAttributeString(dictionary.AuthenticationType, dictionary.EmptyString, authenticationType); writer.WriteString(wid.Name); writer.WriteEndElement(); } else if (identity is WindowsSidIdentity) { WindowsSidIdentity wsid = (WindowsSidIdentity)identity; writer.WriteStartElement(dictionary.WindowsSidIdentity, dictionary.EmptyString); WriteSidAttribute(wsid.SecurityIdentifier, dictionary, writer); if (!String.IsNullOrEmpty(wsid.AuthenticationType)) writer.WriteAttributeString(dictionary.AuthenticationType, dictionary.EmptyString, wsid.AuthenticationType); writer.WriteString(wsid.Name); writer.WriteEndElement(); } else if (identity is GenericIdentity) { GenericIdentity genericIdentity = (GenericIdentity)identity; writer.WriteStartElement(dictionary.GenericIdentity, dictionary.EmptyString); if (!String.IsNullOrEmpty(genericIdentity.AuthenticationType)) writer.WriteAttributeString(dictionary.AuthenticationType, dictionary.EmptyString, genericIdentity.AuthenticationType); writer.WriteString(genericIdentity.Name); writer.WriteEndElement(); } else { serializer.WriteObject(writer, identity); } writer.WriteEndElement(); } }
static IIdentity DeserializePrimaryIdentity(XmlDictionaryReader reader, SctClaimDictionary dictionary, XmlObjectSerializer serializer) { IIdentity identity = null; if (reader.IsStartElement(dictionary.PrimaryIdentity, dictionary.EmptyString)) { reader.ReadStartElement(); if (reader.IsStartElement(dictionary.WindowsSidIdentity, dictionary.EmptyString)) { SecurityIdentifier sid = ReadSidAttribute(reader, dictionary); string authenticationType = reader.GetAttribute(dictionary.AuthenticationType, dictionary.EmptyString); reader.ReadStartElement(); string name = reader.ReadContentAsString(); identity = new WindowsSidIdentity(sid, name, authenticationType ?? String.Empty); reader.ReadEndElement(); } else if (reader.IsStartElement(dictionary.GenericIdentity, dictionary.EmptyString)) { string authenticationType = reader.GetAttribute(dictionary.AuthenticationType, dictionary.EmptyString); reader.ReadStartElement(); string name = reader.ReadContentAsString(); identity = SecurityUtils.CreateIdentity(name, authenticationType ?? String.Empty); reader.ReadEndElement(); } else { identity = (IIdentity)serializer.ReadObject(reader); } reader.ReadEndElement(); } return identity; }
internal static void ThrowNullValueReturnedForGetOnlyCollectionException(Type type) #endif { throw /*System.Runtime.Serialization.*/ DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(string.Format(SRSerialization.NullValueReturnedForGetOnlyCollection, DataContract.GetClrTypeFullName(type)))); }
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 static void ThrowArrayExceededSizeException(int arraySize, Type type) #endif { throw /*System.Runtime.Serialization.*/ DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(string.Format(SRSerialization.ArrayExceededSize, arraySize, DataContract.GetClrTypeFullName(type)))); }
private void ThrowConversionException(string value, string type) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(XmlObjectSerializer.TryAddLineInfo(this, SR.Format(SR.XmlInvalidConversion, value, type)))); }
public XmlWriterDelegator(XmlWriter writer) { XmlObjectSerializer.CheckNull(writer, nameof(writer)); this.writer = writer; this.dictionaryWriter = writer as XmlDictionaryWriter; }
public override void Close() { throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.Format(SR.IXmlSerializableIllegalOperation))); }
internal void Add(string id, object obj) { if (_objectDictionary == null) { _objectDictionary = new Dictionary <string, object>(); } object existingObject; if (_objectDictionary.TryGetValue(id, out existingObject)) { throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.Format(SR.MultipleIdDefinition, id))); } _objectDictionary.Add(id, obj); }
internal void EndWrite() { if (_depth != 0) { throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.Format(SR.IXmlSerializableMissingEndElements, (_obj == null ? string.Empty : DataContract.GetClrTypeFullName(_obj.GetType()))))); } _obj = null; }
private void ReadRef(XmlReaderDelegator reader) { Ref = reader.ReadContentAsString(); if (string.IsNullOrEmpty(Ref)) { throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.Format(SR.InvalidXsRefDefinition, Ref))); } }
private void ReadArraySize(XmlReaderDelegator reader) { ArraySZSize = reader.ReadContentAsInt(); if (ArraySZSize < 0) { throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.Format(SR.InvalidSizeDefinition, ArraySZSize))); } }
internal DefaultMessageHeader (string name, string ns, object value, XmlObjectSerializer formatter, bool isReferenceParameter, bool mustUnderstand, string actor, bool relay) { this.name = name; this.ns = ns; this.value = value; this.formatter = formatter; this.is_ref = isReferenceParameter; this.must_understand = mustUnderstand; this.actor = actor; this.relay = relay; }
public static Claim DeserializeClaim(XmlDictionaryReader reader, SctClaimDictionary dictionary, XmlObjectSerializer serializer) { if (reader.IsStartElement(dictionary.NullValue, dictionary.EmptyString)) { reader.ReadElementString(); return null; } else if (reader.IsStartElement(dictionary.WindowsSidClaim, dictionary.EmptyString)) { string right = ReadRightAttribute(reader, dictionary); reader.ReadStartElement(); byte[] sidBytes = reader.ReadContentAsBase64(); reader.ReadEndElement(); return new Claim(ClaimTypes.Sid, new SecurityIdentifier(sidBytes, 0), right); } else if (reader.IsStartElement(dictionary.DenyOnlySidClaim, dictionary.EmptyString)) { string right = ReadRightAttribute(reader, dictionary); reader.ReadStartElement(); byte[] sidBytes = reader.ReadContentAsBase64(); reader.ReadEndElement(); return new Claim(ClaimTypes.DenyOnlySid, new SecurityIdentifier(sidBytes, 0), right); } else if (reader.IsStartElement(dictionary.X500DistinguishedNameClaim, dictionary.EmptyString)) { string right = ReadRightAttribute(reader, dictionary); reader.ReadStartElement(); byte[] rawData = reader.ReadContentAsBase64(); reader.ReadEndElement(); return new Claim(ClaimTypes.X500DistinguishedName, new X500DistinguishedName(rawData), right); } else if (reader.IsStartElement(dictionary.X509ThumbprintClaim, dictionary.EmptyString)) { string right = ReadRightAttribute(reader, dictionary); reader.ReadStartElement(); byte[] thumbprint = reader.ReadContentAsBase64(); reader.ReadEndElement(); return new Claim(ClaimTypes.Thumbprint, thumbprint, right); } else if (reader.IsStartElement(dictionary.NameClaim, dictionary.EmptyString)) { string right = ReadRightAttribute(reader, dictionary); reader.ReadStartElement(); string name = reader.ReadString(); reader.ReadEndElement(); return new Claim(ClaimTypes.Name, name, right); } else if (reader.IsStartElement(dictionary.DnsClaim, dictionary.EmptyString)) { string right = ReadRightAttribute(reader, dictionary); reader.ReadStartElement(); string dns = reader.ReadString(); reader.ReadEndElement(); return new Claim(ClaimTypes.Dns, dns, right); } else if (reader.IsStartElement(dictionary.RsaClaim, dictionary.EmptyString)) { string right = ReadRightAttribute(reader, dictionary); reader.ReadStartElement(); string rsaXml = reader.ReadString(); reader.ReadEndElement(); System.Security.Cryptography.RSACryptoServiceProvider rsa = new System.Security.Cryptography.RSACryptoServiceProvider(); rsa.FromXmlString(rsaXml); return new Claim(ClaimTypes.Rsa, rsa, right); } else if (reader.IsStartElement(dictionary.MailAddressClaim, dictionary.EmptyString)) { string right = ReadRightAttribute(reader, dictionary); reader.ReadStartElement(); string address = reader.ReadString(); reader.ReadEndElement(); return new Claim(ClaimTypes.Email, new System.Net.Mail.MailAddress(address), right); } else if (reader.IsStartElement(dictionary.SystemClaim, dictionary.EmptyString)) { reader.ReadElementString(); return Claim.System; } else if (reader.IsStartElement(dictionary.HashClaim, dictionary.EmptyString)) { string right = ReadRightAttribute(reader, dictionary); reader.ReadStartElement(); byte[] hash = reader.ReadContentAsBase64(); reader.ReadEndElement(); return new Claim(ClaimTypes.Hash, hash, right); } else if (reader.IsStartElement(dictionary.SpnClaim, dictionary.EmptyString)) { string right = ReadRightAttribute(reader, dictionary); reader.ReadStartElement(); string spn = reader.ReadString(); reader.ReadEndElement(); return new Claim(ClaimTypes.Spn, spn, right); } else if (reader.IsStartElement(dictionary.UpnClaim, dictionary.EmptyString)) { string right = ReadRightAttribute(reader, dictionary); reader.ReadStartElement(); string upn = reader.ReadString(); reader.ReadEndElement(); return new Claim(ClaimTypes.Upn, upn, right); } else if (reader.IsStartElement(dictionary.UrlClaim, dictionary.EmptyString)) { string right = ReadRightAttribute(reader, dictionary); reader.ReadStartElement(); string url = reader.ReadString(); reader.ReadEndElement(); return new Claim(ClaimTypes.Uri, new Uri(url), right); } else { return (Claim)serializer.ReadObject(reader); } }
public static MessageHeader CreateHeader (string name, string ns, object value, XmlObjectSerializer formatter, bool must_understand, string actor, bool relay) { // FIXME: how to get IsReferenceParameter ? return new DefaultMessageHeader (name, ns, value, formatter, default_is_ref, must_understand, actor, relay); }
public static void SerializeIdentities(AuthorizationContext authContext, SctClaimDictionary dictionary, XmlDictionaryWriter writer, XmlObjectSerializer serializer) { object obj; IList<IIdentity> identities; if (authContext.Properties.TryGetValue(SecurityUtils.Identities, out obj)) { identities = obj as IList<IIdentity>; if (identities != null && identities.Count > 0) { writer.WriteStartElement(dictionary.Identities, dictionary.EmptyString); for (int i = 0; i < identities.Count; ++i) { SerializePrimaryIdentity(identities[i], dictionary, writer, serializer); } writer.WriteEndElement(); } } }
private int FindElement(object obj, out bool isEmpty, out bool isWrapped) { isWrapped = false; int position = ComputeStartPosition(obj); for (int i = position; i != (position - 1); i++) { if (m_objs[i] == null) { isEmpty = true; return(i); } if (m_objs[i] == obj) { isEmpty = false; return(i); } if (i == (m_objs.Length - 1)) { isWrapped = true; i = -1; } } // m_obj must ALWAYS have at least one slot empty (null). DiagnosticUtility.DebugAssert("Object table overflow"); throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.Format(SR.ObjectTableOverflow))); }
public static IList<IIdentity> DeserializeIdentities(XmlDictionaryReader reader, SctClaimDictionary dictionary, XmlObjectSerializer serializer) { List<IIdentity> identities = null; if (reader.IsStartElement(dictionary.Identities, dictionary.EmptyString)) { identities = new List<IIdentity>(); reader.ReadStartElement(); while (reader.IsStartElement(dictionary.PrimaryIdentity, dictionary.EmptyString)) { IIdentity identity = DeserializePrimaryIdentity(reader, dictionary, serializer); if (identity != null && identity != SecurityUtils.AnonymousIdentity) { identities.Add(identity); } } reader.ReadEndElement(); } return identities; }
object InternalDeserializeInSharedTypeMode(XmlReaderDelegator xmlReader, int declaredTypeID, Type declaredType, string name, string ns) { object retObj = null; if (TryHandleNullOrRef(xmlReader, declaredType, name, ns, ref retObj)) { return(retObj); } DataContract dataContract; string assemblyName = attributes.ClrAssembly; string typeName = attributes.ClrType; if (assemblyName != null && typeName != null) { Assembly assembly; Type type; dataContract = ResolveDataContractInSharedTypeMode(assemblyName, typeName, out assembly, out type); if (dataContract == null) { if (assembly == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.GetString(SR.AssemblyNotFound, assemblyName))); } if (type == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.GetString(SR.ClrTypeNotFound, assembly.FullName, typeName))); } } //Array covariance is not supported in XSD. If declared type is array, data is sent in format of base array if (declaredType != null && declaredType.IsArray) { dataContract = (declaredTypeID < 0) ? GetDataContract(declaredType) : GetDataContract(declaredTypeID, declaredType.TypeHandle); } } else { if (assemblyName != null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(XmlObjectSerializer.TryAddLineInfo(xmlReader, SR.GetString(SR.AttributeNotFound, Globals.SerializationNamespace, Globals.ClrTypeLocalName, xmlReader.NodeType, xmlReader.NamespaceURI, xmlReader.LocalName)))); } else if (typeName != null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(XmlObjectSerializer.TryAddLineInfo(xmlReader, SR.GetString(SR.AttributeNotFound, Globals.SerializationNamespace, Globals.ClrAssemblyLocalName, xmlReader.NodeType, xmlReader.NamespaceURI, xmlReader.LocalName)))); } else if (declaredType == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(XmlObjectSerializer.TryAddLineInfo(xmlReader, SR.GetString(SR.AttributeNotFound, Globals.SerializationNamespace, Globals.ClrTypeLocalName, xmlReader.NodeType, xmlReader.NamespaceURI, xmlReader.LocalName)))); } dataContract = (declaredTypeID < 0) ? GetDataContract(declaredType) : GetDataContract(declaredTypeID, declaredType.TypeHandle); } return(ReadDataContractValue(dataContract, xmlReader)); }
public static void SerializeClaim(Claim claim, SctClaimDictionary dictionary, XmlDictionaryWriter writer, XmlObjectSerializer serializer) { // the order in which known claim types are checked is optimized for use patterns if (claim == null) { writer.WriteElementString(dictionary.NullValue, dictionary.EmptyString, string.Empty); return; } else if (ClaimTypes.Sid.Equals(claim.ClaimType)) { writer.WriteStartElement(dictionary.WindowsSidClaim, dictionary.EmptyString); WriteRightAttribute(claim, dictionary, writer); SerializeSid((SecurityIdentifier)claim.Resource, dictionary, writer); writer.WriteEndElement(); return; } else if (ClaimTypes.DenyOnlySid.Equals(claim.ClaimType)) { writer.WriteStartElement(dictionary.DenyOnlySidClaim, dictionary.EmptyString); WriteRightAttribute(claim, dictionary, writer); SerializeSid((SecurityIdentifier)claim.Resource, dictionary, writer); writer.WriteEndElement(); return; } else if (ClaimTypes.X500DistinguishedName.Equals(claim.ClaimType)) { writer.WriteStartElement(dictionary.X500DistinguishedNameClaim, dictionary.EmptyString); WriteRightAttribute(claim, dictionary, writer); byte[] rawData = ((X500DistinguishedName)claim.Resource).RawData; writer.WriteBase64(rawData, 0, rawData.Length); writer.WriteEndElement(); return; } else if (ClaimTypes.Thumbprint.Equals(claim.ClaimType)) { writer.WriteStartElement(dictionary.X509ThumbprintClaim, dictionary.EmptyString); WriteRightAttribute(claim, dictionary, writer); byte[] thumbprint = (byte[])claim.Resource; writer.WriteBase64(thumbprint, 0, thumbprint.Length); writer.WriteEndElement(); return; } else if (ClaimTypes.Name.Equals(claim.ClaimType)) { writer.WriteStartElement(dictionary.NameClaim, dictionary.EmptyString); WriteRightAttribute(claim, dictionary, writer); writer.WriteString((string)claim.Resource); writer.WriteEndElement(); return; } else if (ClaimTypes.Dns.Equals(claim.ClaimType)) { writer.WriteStartElement(dictionary.DnsClaim, dictionary.EmptyString); WriteRightAttribute(claim, dictionary, writer); writer.WriteString((string)claim.Resource); writer.WriteEndElement(); return; } else if (ClaimTypes.Rsa.Equals(claim.ClaimType)) { writer.WriteStartElement(dictionary.RsaClaim, dictionary.EmptyString); WriteRightAttribute(claim, dictionary, writer); writer.WriteString(((RSA)claim.Resource).ToXmlString(false)); writer.WriteEndElement(); return; } else if (ClaimTypes.Email.Equals(claim.ClaimType)) { writer.WriteStartElement(dictionary.MailAddressClaim, dictionary.EmptyString); WriteRightAttribute(claim, dictionary, writer); writer.WriteString(((MailAddress)claim.Resource).Address); writer.WriteEndElement(); return; } else if (claim == Claim.System) { writer.WriteElementString(dictionary.SystemClaim, dictionary.EmptyString, string.Empty); return; } else if (ClaimTypes.Hash.Equals(claim.ClaimType)) { writer.WriteStartElement(dictionary.HashClaim, dictionary.EmptyString); WriteRightAttribute(claim, dictionary, writer); byte[] hash = (byte[])claim.Resource; writer.WriteBase64(hash, 0, hash.Length); writer.WriteEndElement(); return; } else if (ClaimTypes.Spn.Equals(claim.ClaimType)) { writer.WriteStartElement(dictionary.SpnClaim, dictionary.EmptyString); WriteRightAttribute(claim, dictionary, writer); writer.WriteString((string)claim.Resource); writer.WriteEndElement(); return; } else if (ClaimTypes.Upn.Equals(claim.ClaimType)) { writer.WriteStartElement(dictionary.UpnClaim, dictionary.EmptyString); WriteRightAttribute(claim, dictionary, writer); writer.WriteString((string)claim.Resource); writer.WriteEndElement(); return; } else if (ClaimTypes.Uri.Equals(claim.ClaimType)) { writer.WriteStartElement(dictionary.UrlClaim, dictionary.EmptyString); WriteRightAttribute(claim, dictionary, writer); writer.WriteString(((Uri)claim.Resource).AbsoluteUri); writer.WriteEndElement(); return; } else { // this is an extensible claim... need to delegate to xml object serializer serializer.WriteObject(writer, claim); } }
private void RemoveAt(int position) { int cacheSize = m_objs.Length; int lastVacantPosition = position; for (int next = (position == cacheSize - 1) ? 0 : position + 1; next != position; next++) { if (m_objs[next] == null) { m_objs[lastVacantPosition] = null; m_ids[lastVacantPosition] = 0; m_isWrapped[lastVacantPosition] = false; return; } int nextStartPosition = ComputeStartPosition(m_objs[next]); // If we wrapped while placing an object, then it must be that the start position wasn't wrapped to begin with bool isNextStartPositionWrapped = next < position && !m_isWrapped[next]; bool isLastVacantPositionWrapped = lastVacantPosition < position; // We want to avoid moving objects in the cache if the next bucket position is wrapped, but the last vacant position isn't // and we want to make sure to move objects in the cache when the last vacant position is wrapped but the next bucket position isn't if ((nextStartPosition <= lastVacantPosition && !(isNextStartPositionWrapped && !isLastVacantPositionWrapped)) || (isLastVacantPositionWrapped && !isNextStartPositionWrapped)) { m_objs[lastVacantPosition] = m_objs[next]; m_ids[lastVacantPosition] = m_ids[next]; // A wrapped object might become unwrapped if it moves from the front of the array to the end of the array m_isWrapped[lastVacantPosition] = m_isWrapped[next] && next > lastVacantPosition; lastVacantPosition = next; } if (next == (cacheSize - 1)) { next = -1; } } // m_obj must ALWAYS have at least one slot empty (null). DiagnosticUtility.DebugAssert("Object table overflow"); throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.Format(SR.ObjectTableOverflow))); }
public static XmlSyndicationContent CreateXmlContent(object dataContractObject, XmlObjectSerializer dataContractSerializer) { return new XmlSyndicationContent(Atom10Constants.XmlMediaType, dataContractObject, dataContractSerializer); }
private void ReadId(XmlReaderDelegator reader) { Id = reader.ReadContentAsString(); if (string.IsNullOrEmpty(Id)) { throw /*System.Runtime.Serialization.*/ DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(string.Format(SRSerialization.InvalidXsIdDefinition, Id))); } }
protected object?InternalDeserialize(XmlReaderDelegator reader, string?name, string?ns, Type declaredType, ref DataContract dataContract) { object?retObj = null; if (TryHandleNullOrRef(reader, dataContract.UnderlyingType, name, ns, ref retObj)) { return(retObj); } bool knownTypesAddedInCurrentScope = false; if (dataContract.KnownDataContracts != null) { scopedKnownTypes.Push(dataContract.KnownDataContracts); knownTypesAddedInCurrentScope = true; } Debug.Assert(attributes != null); if (attributes.XsiTypeName != null) { DataContract?tempDataContract = ResolveDataContractFromKnownTypes(attributes.XsiTypeName, attributes.XsiTypeNamespace, dataContract, declaredType); if (tempDataContract == null) { if (DataContractResolver == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(XmlObjectSerializer.TryAddLineInfo(reader, SR.Format(SR.DcTypeNotFoundOnDeserialize, attributes.XsiTypeNamespace, attributes.XsiTypeName, reader.NamespaceURI, reader.LocalName)))); } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(XmlObjectSerializer.TryAddLineInfo(reader, SR.Format(SR.DcTypeNotResolvedOnDeserialize, attributes.XsiTypeNamespace, attributes.XsiTypeName, reader.NamespaceURI, reader.LocalName)))); } dataContract = tempDataContract; knownTypesAddedInCurrentScope = ReplaceScopedKnownTypesTop(dataContract.KnownDataContracts, knownTypesAddedInCurrentScope); } if (dataContract.IsISerializable && attributes.FactoryTypeName != null) { DataContract?factoryDataContract = ResolveDataContractFromKnownTypes(attributes.FactoryTypeName, attributes.FactoryTypeNamespace, dataContract, declaredType); if (factoryDataContract != null) { if (factoryDataContract.IsISerializable) { dataContract = factoryDataContract; knownTypesAddedInCurrentScope = ReplaceScopedKnownTypesTop(dataContract.KnownDataContracts, knownTypesAddedInCurrentScope); } else { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.Format(SR.FactoryTypeNotISerializable, DataContract.GetClrTypeFullName(factoryDataContract.UnderlyingType), DataContract.GetClrTypeFullName(dataContract.UnderlyingType)))); } } } if (knownTypesAddedInCurrentScope) { object?obj = ReadDataContractValue(dataContract, reader); scopedKnownTypes.Pop(); return(obj); } else { return(ReadDataContractValue(dataContract, reader)); } }
protected virtual void WriteNull(XmlWriterDelegator xmlWriter) { XmlObjectSerializer.WriteNull(xmlWriter); }
public static XmlNode[] ReadNodes(XmlReader xmlReader) { if (xmlReader == null) { throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("xmlReader"); } XmlDocument doc = new XmlDocument(); List <XmlNode> nodeList = new List <XmlNode>(); if (xmlReader.MoveToFirstAttribute()) { do { if (IsValidAttribute(xmlReader)) { XmlNode node = doc.ReadNode(xmlReader); if (node == null) { throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.GetString(SR.UnexpectedEndOfFile))); } nodeList.Add(node); } } while (xmlReader.MoveToNextAttribute()); } xmlReader.MoveToElement(); if (!xmlReader.IsEmptyElement) { int startDepth = xmlReader.Depth; xmlReader.Read(); while (xmlReader.Depth > startDepth && xmlReader.NodeType != XmlNodeType.EndElement) { XmlNode node = doc.ReadNode(xmlReader); if (node == null) { throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.GetString(SR.UnexpectedEndOfFile))); } nodeList.Add(node); } } return(nodeList.ToArray()); }
public XmlReaderDelegator(XmlReader reader) { XmlObjectSerializer.CheckNull(reader, "reader"); this.reader = reader; this.dictionaryReader = reader as XmlDictionaryReader; }
public static MessageHeader CreateHeader (string name, string ns, object value, XmlObjectSerializer formatter, bool must_understand, string actor) { return CreateHeader (name, ns, value, formatter, must_understand, actor, default_relay); }
internal void InternalWriteObjectContent(XmlWriterDelegator writer, object graph, DataContractResolver dataContractResolver) { if (MaxItemsInObjectGraph == 0) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.Format(SR.ExceededMaxItemsQuota, MaxItemsInObjectGraph))); } DataContract contract = RootContract; Type declaredType = contract.UnderlyingType; Type graphType = (graph == null) ? declaredType : graph.GetType(); if (_serializationSurrogateProvider != null) { graph = SurrogateToDataContractType(_serializationSurrogateProvider, graph, declaredType, ref graphType); } if (dataContractResolver == null) { dataContractResolver = this.DataContractResolver; } if (graph == null) { if (IsRootXmlAny(_rootName, contract)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.Format(SR.IsAnyCannotBeNull, declaredType))); } WriteNull(writer); } else { if (declaredType == graphType) { if (contract.CanContainReferences) { XmlObjectSerializerWriteContext context = XmlObjectSerializerWriteContext.CreateContext(this, contract , dataContractResolver ); context.HandleGraphAtTopLevel(writer, graph, contract); context.SerializeWithoutXsiType(contract, writer, graph, declaredType.TypeHandle); } else { contract.WriteXmlValue(writer, graph, null); } } else { XmlObjectSerializerWriteContext context = null; if (IsRootXmlAny(_rootName, contract)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.Format(SR.IsAnyCannotBeSerializedAsDerivedType, graphType, contract.UnderlyingType))); } contract = GetDataContract(contract, declaredType, graphType); context = XmlObjectSerializerWriteContext.CreateContext(this, RootContract , dataContractResolver ); if (contract.CanContainReferences) { context.HandleGraphAtTopLevel(writer, graph, contract); } context.OnHandleIsReference(writer, contract, graph); context.SerializeWithXsiTypeAtTopLevel(contract, writer, graph, declaredType.TypeHandle, graphType); } } }
public SingleParameterBodyWriter(object body, XmlObjectSerializer serializer) : base(false) { if (body != null && serializer == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("serializer"); } this.body = body; this.serializer = serializer; }
public static void Serialize(object instance, out string xmlContent, out string serializerType) { SerializerTypes serializerTypeValue = SerializerTypes.Primitive; xmlContent = string.Empty; Type instanceType = typeof(object); if (instance != null) { if (instanceType.IsPrimitive || instanceType == typeof(string)) { xmlContent = string.Format("<{0}>{1}</{0}>", instanceType.Name, instance); } else if (instanceType.GetCustomAttributes(typeof(SerializableAttribute), true).FirstOrDefault() != null) { serializerTypeValue = SerializerTypes.XmlSerializer; StringWriter sww = new StringWriter(); XmlWriter writer = XmlWriter.Create(sww); System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(instanceType); serializer.Serialize(sww, instanceType); xmlContent = sww.ToString(); } else { serializerTypeValue = SerializerTypes.XmlObjectSerializer; XmlObjectSerializer serializer = new XmlObjectSerializer(); xmlContent = serializer.Serialize(instance, instanceType).OuterXml; } } serializerType = string.Format(SerializerTypeFormat, serializerTypeValue, instanceType.AssemblyQualifiedName); }