private void Initialize(Type type,
IEnumerable <Type>?knownTypes,
int maxItemsInObjectGraph,
bool ignoreExtensionDataObject,
bool preserveObjectReferences,
DataContractResolver?dataContractResolver,
bool serializeReadOnlyTypes)
{
ArgumentNullException.ThrowIfNull(type);
_rootType = type;
if (knownTypes != null)
{
_knownTypeList = new List <Type>();
foreach (Type knownType in knownTypes)
{
_knownTypeList.Add(knownType);
}
}
if (maxItemsInObjectGraph < 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException(nameof(maxItemsInObjectGraph), SR.ValueMustBeNonNegative));
}
_maxItemsInObjectGraph = maxItemsInObjectGraph;
_ignoreExtensionDataObject = ignoreExtensionDataObject;
_preserveObjectReferences = preserveObjectReferences;
_dataContractResolver = dataContractResolver;
_serializeReadOnlyTypes = serializeReadOnlyTypes;
}
/// <summary>
/// Serializes the specified object and writes the XML document to a file using the specified XmlWriter.
/// </summary>
/// <param name="xmlDictionaryWriter"></param>
/// <param name="value"></param>
/// <param name="dataContractResolver"></param>
/// <typeparam name="TValue"></typeparam>
public static void Serialize <TValue>(XmlDictionaryWriter?xmlDictionaryWriter, TValue?value,
DataContractResolver?dataContractResolver = null)
{
if (xmlDictionaryWriter is null)
{
return;
}
Serialize(typeof(TValue), xmlDictionaryWriter, value, dataContractResolver);
}
/// <summary>
/// Serializes the specified object and writes the XML document to a file using the specified XmlWriter.
/// </summary>
/// <param name="type"></param>
/// <param name="xmlDictionaryWriter"></param>
/// <param name="value"></param>
/// <param name="dataContractResolver"></param>
public static void Serialize(Type type, XmlDictionaryWriter?xmlDictionaryWriter, object?value,
DataContractResolver?dataContractResolver = null)
{
if (xmlDictionaryWriter is null)
{
return;
}
GetSerializer(type).WriteObject(xmlDictionaryWriter, value, dataContractResolver);
}
internal XmlObjectSerializerContext(XmlObjectSerializer serializer, int maxItemsInObjectGraph, StreamingContext streamingContext, bool ignoreExtensionDataObject,
DataContractResolver?dataContractResolver)
{
this.serializer = serializer;
_itemCount = 1;
_maxItemsInObjectGraph = maxItemsInObjectGraph;
_streamingContext = streamingContext;
_ignoreExtensionDataObject = ignoreExtensionDataObject;
_dataContractResolver = dataContractResolver;
}
private void Initialize(Type type, XmlDictionaryString?rootName, XmlDictionaryString?rootNamespace,
IEnumerable <Type>?knownTypes,
int maxItemsInObjectGraph,
bool ignoreExtensionDataObject,
bool preserveObjectReferences,
DataContractResolver?dataContractResolver,
bool serializeReadOnlyTypes)
{
Initialize(type, knownTypes, maxItemsInObjectGraph, ignoreExtensionDataObject, preserveObjectReferences, dataContractResolver, serializeReadOnlyTypes);
// validate root name and namespace are both non-null
_rootName = rootName;
_rootNamespace = rootNamespace;
}
public object?ReadObject(XmlDictionaryReader reader, bool verifyObjectName, DataContractResolver?dataContractResolver)
{
return(ReadObjectHandleExceptions(new XmlReaderDelegator(reader), verifyObjectName, dataContractResolver));
}
public void WriteObject(XmlDictionaryWriter writer, object?graph, DataContractResolver?dataContractResolver)
{
WriteObjectHandleExceptions(new XmlWriterDelegator(writer), graph, dataContractResolver);
}
internal override void InternalWriteObject(XmlWriterDelegator writer, object?graph, DataContractResolver?dataContractResolver)
{
InternalWriteStartObject(writer, graph);
InternalWriteObjectContent(writer, graph, dataContractResolver);
InternalWriteEndObject(writer);
}
internal static XmlObjectSerializerWriteContext CreateContext(DataContractSerializer serializer, DataContract rootTypeDataContract, DataContractResolver?dataContractResolver)
{
return((serializer.PreserveObjectReferences || serializer.SerializationSurrogateProvider != null)
? new XmlObjectSerializerWriteContextComplex(serializer, rootTypeDataContract, dataContractResolver)
: new XmlObjectSerializerWriteContext(serializer, rootTypeDataContract, dataContractResolver));
}
internal object?ReadObjectHandleExceptions(XmlReaderDelegator reader, bool verifyObjectName, DataContractResolver?dataContractResolver)
{
try
{
CheckNull(reader, nameof(reader));
return(InternalReadObject(reader, verifyObjectName, dataContractResolver));
}
catch (XmlException ex)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(GetTypeInfoError(SR.ErrorDeserializing, GetDeserializeType(), ex), ex));
}
catch (FormatException ex)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(GetTypeInfoError(SR.ErrorDeserializing, GetDeserializeType(), ex), ex));
}
}
internal virtual object?InternalReadObject(XmlReaderDelegator reader, bool verifyObjectName, DataContractResolver?dataContractResolver)
{
return(InternalReadObject(reader, verifyObjectName));
}
internal virtual void InternalWriteObject(XmlWriterDelegator writer, object?graph, DataContractResolver?dataContractResolver)
{
InternalWriteObject(writer, graph);
}
/// <summary>
/// Deserializes the XML document contained by the specified XmlReader.
/// </summary>
/// <param name="xmlDictionaryReader"></param>
/// <param name="verifyObjectName"></param>
/// <param name="dataContractResolver"></param>
/// <typeparam name="TValue"></typeparam>
/// <returns></returns>
public static TValue?Deserialize <TValue>(XmlDictionaryReader?xmlDictionaryReader, bool verifyObjectName = true,
DataContractResolver?dataContractResolver = null) =>
xmlDictionaryReader is null
? default
: (TValue?)Deserialize(typeof(TValue), xmlDictionaryReader, verifyObjectName, dataContractResolver);
internal XmlObjectSerializerWriteContextComplex(DataContractSerializer serializer, DataContract rootTypeDataContract, DataContractResolver?dataContractResolver)
: base(serializer, rootTypeDataContract, dataContractResolver)
{
this.preserveObjectReferences = serializer.PreserveObjectReferences;
_serializationSurrogateProvider = serializer.SerializationSurrogateProvider;
}
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);
}
dataContractResolver ??= 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;
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);
}
}
}
internal override object?InternalReadObject(XmlReaderDelegator xmlReader, bool verifyObjectName, DataContractResolver?dataContractResolver)
{
if (MaxItemsInObjectGraph == 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.Format(SR.ExceededMaxItemsQuota, MaxItemsInObjectGraph)));
}
dataContractResolver ??= DataContractResolver;
if (verifyObjectName)
{
if (!InternalIsStartObject(xmlReader))
{
XmlDictionaryString?expectedName;
XmlDictionaryString?expectedNs;
if (_rootName == null)
{
expectedName = RootContract.TopLevelElementName;
expectedNs = RootContract.TopLevelElementNamespace;
}
else
{
expectedName = _rootName;
expectedNs = _rootNamespace;
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationExceptionWithReaderDetails(SR.Format(SR.ExpectingElement, expectedNs, expectedName), xmlReader));
}
}
else if (!IsStartElement(xmlReader))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationExceptionWithReaderDetails(SR.Format(SR.ExpectingElementAtDeserialize, XmlNodeType.Element), xmlReader));
}
DataContract contract = RootContract;
if (contract.IsPrimitive && object.ReferenceEquals(contract.UnderlyingType, _rootType) /*handle Nullable<T> differently*/)
{
return(contract.ReadXmlValue(xmlReader, null));
}
if (IsRootXmlAny(_rootName, contract))
{
return(XmlObjectSerializerReadContext.ReadRootIXmlSerializable(xmlReader, (contract as XmlDataContract) !, false /*isMemberType*/));
}
XmlObjectSerializerReadContext context = XmlObjectSerializerReadContext.CreateContext(this, contract, dataContractResolver);
return(context.InternalDeserialize(xmlReader, _rootType, contract, null, null));
}
internal void WriteObjectHandleExceptions(XmlWriterDelegator writer, object?graph, DataContractResolver?dataContractResolver)
{
try
{
CheckNull(writer, nameof(writer));
{
InternalWriteObject(writer, graph, dataContractResolver);
}
}
catch (XmlException ex)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(GetTypeInfoError(SR.ErrorSerializing, GetSerializeType(graph), ex), ex));
}
catch (FormatException ex)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(GetTypeInfoError(SR.ErrorSerializing, GetSerializeType(graph), ex), ex));
}
}
protected XmlObjectSerializerWriteContext(DataContractSerializer serializer, DataContract rootTypeDataContract, DataContractResolver?resolver)
: base(serializer, rootTypeDataContract, resolver)
{
this.serializeReadOnlyTypes = serializer.SerializeReadOnlyTypes;
// Known types restricts the set of types that can be deserialized
_unsafeTypeForwardingEnabled = true;
}
internal XmlObjectSerializerReadContextComplex(DataContractSerializer serializer, DataContract rootTypeDataContract, DataContractResolver?dataContractResolver)
: base(serializer, rootTypeDataContract, dataContractResolver)
{
_mode = SerializationMode.SharedContract;
_preserveObjectReferences = serializer.PreserveObjectReferences;
_serializationSurrogateProvider = serializer.SerializationSurrogateProvider;
}
internal XmlObjectSerializerContext(DataContractSerializer serializer, DataContract rootTypeDataContract, DataContractResolver?dataContractResolver)
: this(serializer,
serializer.MaxItemsInObjectGraph,
new StreamingContext(StreamingContextStates.All),
serializer.IgnoreExtensionDataObject,
dataContractResolver
)
{
this.rootTypeDataContract = rootTypeDataContract;
this.serializerKnownTypeList = serializer._knownTypeList;
}
internal XmlObjectSerializerReadContext(DataContractSerializer serializer, DataContract rootTypeDataContract, DataContractResolver?dataContractResolver)
: base(serializer, rootTypeDataContract, dataContractResolver)
{
this.attributes = new Attributes();
}