private object ReadValue(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
{
var contentHeaders = content == null ? null : content.Headers;
if (contentHeaders != null && contentHeaders.ContentLength == 0)
{
return(GetDefaultValueForType(type));
}
var encoding = SelectCharacterEncoding(contentHeaders);
try
{
var serializer = XmlSerializer.Create(type, new XmlSerializationOptions(encoding: encoding, shouldIndent: Indent));
return(serializer.Deserialize(readStream));
}
catch (Exception ex)
{
if (formatterLogger == null)
{
throw;
}
formatterLogger.LogError(string.Empty, ex);
return(GetDefaultValueForType(type));
}
}
public void TheFirstNonGenericFactoryMethodReturnsTheCorrectTypeOfXmlSerializer()
{
var genericSerializer = new XmlSerializer <XmlSerializerFactoryTests>();
var interfaceSerializer = XmlSerializer.Create(typeof(XmlSerializerFactoryTests));
Assert.That(interfaceSerializer.GetType(), Is.EqualTo(genericSerializer.GetType()));
}
/// <summary>
/// Serializes the specified <paramref name="source"/> to an object of <see cref="Stream"/>.
/// </summary>
/// <param name="source">The object to serialize to XML format.</param>
/// <param name="objectType">The type of the object to serialize.</param>
/// <returns>A stream of the serialized <paramref name="source"/>.</returns>
public override Stream Serialize(object source, Type objectType)
{
Validator.ThrowIfNull(source, nameof(source));
Validator.ThrowIfNull(objectType, nameof(objectType));
var serializer = XmlSerializer.Create(Options.Settings);
return(serializer.Serialize(source, objectType));
}
/// <summary>
/// Deserializes the specified <paramref name="value" /> into an object of <paramref name="objectType"/>.
/// </summary>
/// <param name="value">The stream from which to deserialize the object graph.</param>
/// <param name="objectType">The type of the deserialized object.</param>
/// <returns>An object of <paramref name="objectType"/>.</returns>
public override object Deserialize(Stream value, Type objectType)
{
Validator.ThrowIfNull(value, nameof(value));
Validator.ThrowIfNull(objectType, nameof(objectType));
var serializer = XmlSerializer.Create(Options.Settings);
return(serializer.Deserialize(value, objectType));
}
public void CanSerializeArray(dynamic item)
{
var serializer = XmlSerializer.Create(item.GetType());
var xml = serializer.Serialize(item);
dynamic roundTrip = serializer.Deserialize(xml);
Assert.That(roundTrip.Data, Is.EqualTo(item.Data));
}
private void WriteValue(Type type, object value, Stream writeStream, HttpContent content)
{
var encoding = SelectCharacterEncoding(content != null ? content.Headers : null);
using (var writer = new StreamWriter(writeStream, encoding, 1024, true))
{
var serializer = XmlSerializer.Create(type, new XmlSerializationOptions(encoding: encoding, shouldIndent: Indent));
serializer.Serialize(writer, value);
}
}
/// <inheritdoc />
public object DeserializeFromString(string data, Type type)
{
Guard.Against.Null(data, nameof(data));
Guard.Against.Null(type, nameof(type));
var serializer = Options.IsNull()
? XmlSerializer.Create(type)
: XmlSerializer.Create(type, Options);
return(serializer.Deserialize(data));
}
/// <inheritdoc />
public string SerializeToString(object item, Type type)
{
Guard.Against.Null(item, nameof(item));
Guard.Against.Null(type, nameof(type));
var serializer = Options.IsNull()
? XmlSerializer.Create(type)
: XmlSerializer.Create(type, Options);
return(serializer.Serialize(item));
}
/// <inheritdoc />
public object DeserializeFromStream(Stream stream, Type type)
{
Guard.Against.Null(stream, nameof(stream));
Guard.Against.Null(type, nameof(type));
var serializer = Options.IsNull()
? XmlSerializer.Create(type)
: XmlSerializer.Create(type, Options);
return(serializer.Deserialize(stream));
}
/// <inheritdoc />
public void SerializeToStream(Stream stream, object item, Type type)
{
Guard.Against.Null(stream, nameof(stream));
Guard.Against.Null(item, nameof(item));
Guard.Against.Null(type, nameof(type));
var serializer = Options.IsNull()
? XmlSerializer.Create(type)
: XmlSerializer.Create(type, Options);
serializer.Serialize(stream, item);
}
/// <summary>
/// Deserialize the configuration object that will be returned by the
/// <see cref="XmlSerializerSectionHandler.Create"/> method.
/// </summary>
/// <param name="section">An xml node that represents configuration object in the *.config file.</param>
/// <param name="configType">The type of the object to be returned by the <see cref="XmlSerializerSectionHandler.Create"/> method.</param>
/// <returns>The deserialized object.</returns>
protected override object Deserialize(XmlNode section, Type configType)
{
try
{
var serializer = XmlSerializer.Create(configType, o => o.SetRootElementName(section.Name));
return(serializer.Deserialize(section.OuterXml));
}
catch (Exception ex)
{
throw new InvalidConfigurationException(string.Format("Error deserializing '{0}' element as a '{1}' type.", section.Name, configType), ex, section.OuterXml);
}
}
/// <inheritdoc />
public object DeserializeFromString(string data, Type type)
{
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
var serializer = Options == null
? XmlSerializer.Create(type)
: XmlSerializer.Create(type, Options);
return(serializer.Deserialize(data));
}
/// <inheritdoc />
public string SerializeToString(object item, Type type)
{
if (item == null)
{
throw new ArgumentNullException(nameof(item));
}
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
var serializer = Options == null
? XmlSerializer.Create(type)
: XmlSerializer.Create(type, Options);
return(serializer.Serialize(item));
}
private static void PerformTest(object objectToSerialize, Func <object, object> getTargetValue, Func <XElement, object> getTargetNodeValue, object expectedTargetNodeValue, Type[] extraTypes)
{
var serializer = XmlSerializer.Create(objectToSerialize.GetType(), options => options.Indent().AlwaysEmitTypes(), extraTypes);
var xml = serializer.Serialize(objectToSerialize);
Console.WriteLine(xml);
var roundTrip = serializer.Deserialize(xml);
var targetValue = getTargetValue(roundTrip);
var expectedTargetValue = getTargetValue(objectToSerialize);
Assert.That(targetValue, Is.EqualTo(expectedTargetValue));
var targetNodeValue = getTargetNodeValue(XDocument.Parse(xml).Root);
Assert.That(targetNodeValue, Is.EqualTo(expectedTargetNodeValue));
}
/// <inheritdoc />
public void SerializeToStream(Stream stream, object item, Type type)
{
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
if (item == null)
{
throw new ArgumentNullException(nameof(item));
}
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
var serializer = Options == null
? XmlSerializer.Create(type)
: XmlSerializer.Create(type, Options);
serializer.Serialize(stream, item);
}
/// <summary>
/// Serialize the <paramref name="item"/> object, as type <paramref name="type"/>
/// to a string.
/// </summary>
/// <param name="item">The object to serialize.</param>
/// <param name="type">The type to serialize the object as.</param>
/// <returns>A string representing the <paramref name="item"/> object.</returns>
public string SerializeToString(object item, Type type)
{
var serializer = XmlSerializer.Create(type, _createOptions(type));
return(serializer.Serialize(item));
}
/// <summary>
/// Deserialize from the <paramref name="stream"/> stream as type
/// <paramref name="type"/>.
/// </summary>
/// <param name="stream">The stream to deserialize from.</param>
/// <param name="type">The type to deserialize as.</param>
/// <returns>An instance of type <paramref name="type"/>.</returns>
public object DeserializeFromStream(Stream stream, Type type)
{
var serializer = XmlSerializer.Create(type, _createOptions(type));
return(serializer.Deserialize(stream));
}
/// <summary>
/// Serialize the <paramref name="item"/> object, as type <paramref name="type"/>
/// to the <paramref name="stream"/> stream.
/// </summary>
/// <param name="stream">The stream to serialize to.</param>
/// <param name="item">The object to serialize.</param>
/// <param name="type">The type to serialize the object as.</param>
public void SerializeToStream(Stream stream, object item, Type type)
{
var serializer = XmlSerializer.Create(type, _createOptions(type));
serializer.Serialize(stream, item);
}
/// <summary>
/// Deserialize from the string as type <paramref name="type"/>.
/// </summary>
/// <param name="data">The string containing a representation of an object of type <paramref name="type"/>.</param>
/// <param name="type">The type to deserialize as.</param>
/// <returns>An instance of type <paramref name="type"/>.</returns>
public object DeserializeFromString(string data, Type type)
{
var serializer = XmlSerializer.Create(type, _createOptions(type));
return(serializer.Deserialize(data));
}
public string Serialize(TraceResult traceResult)
{
var serializer = XmlSerializer.Create(traceResult.GetType());
return(serializer.Serialize(traceResult));
}
