// public DataSourceXml(): this(new XmlSerializerSettings())
/// <summary>
/// Initializes a new instance of the <see cref="DataSourceXml"/> class.
/// </summary>
/// <param name="type">The type.</param>
/// <exception cref="ArgumentOutOfRangeException">type - null</exception>
public DataSourceXml(SettingsType type)
{
switch (type)
{
case SettingsType.DataTransfer:
Settings = new XmlSerializerSettings()
{
Indent = false, NullValueHandling = XmlNullValueHandling.Ignore, OmitXmlDeclaration = true
};
break;
case SettingsType.ManualEditing:
Settings = new XmlSerializerSettings()
{
Indent = true, NullValueHandling = XmlNullValueHandling.Include, OmitXmlDeclaration = false
};
break;
case SettingsType.Both:
Settings = new XmlSerializerSettings()
{
Indent = true, NullValueHandling = XmlNullValueHandling.Ignore, OmitXmlDeclaration = false
};
break;
default:
throw new ArgumentOutOfRangeException(nameof(type), type, null);
}
}
/// <summary>
/// The actual implementation of the Matches method as required by the
/// <code>NUnit.Framework.Contraints.Constrant</code> class.
///
/// The actual Matches(Object) method simply calls through to this type
/// specific method.
/// </summary>
/// <param name="actual_">The actual output of the XMlSerializer</param>
/// <returns></returns>
public bool Matches(T actual_)
{
var outputXml = new StringBuilder();
var xmlWriter = XmlWriter.Create(outputXml, XmlSerializerSettings.GetDefaultWriterSettings());
using (xmlWriter)
{
_serializer.Serialize(actual_, xmlWriter);
xmlWriter.Close();
}
_actualXml = outputXml.ToString();
if (_referenceXml.Equals(_actualXml))
{
return(true);
}
var error = new StringBuilder();
error.AppendLine("XML Serialization was incorrect.");
error.AppendLine("Expected: ");
error.AppendLine(_referenceXml);
error.AppendLine("Actual: ");
error.AppendLine(_actualXml);
_errorMessage = error.ToString();
return(false);
}
public static XmlSerializer CreateSerializer([NotNull] Type type, XmlSerializerSettings settings = null)
{
XmlSerializer serializer = __serializersCache.GetOrAdd(type, e => settings == null
? __factory.Value.CreateSerializer(e)
: __factory.Value.CreateSerializer(e, settings.Overrides, settings.ExtraTypes, settings.Root, settings.DefaultNamespace, settings.Location));
return(serializer ?? throw new SerializationException($"Could not create a serializer for the type {type.FullName}."));
}
private XmlSerializer GetSerializer()
{
var settings = new XmlSerializerSettings
{
ContractResolver = new XmlContractResolver(NamingConventions.CamelCase)
};
return(new XmlSerializer(settings));
}
public static IEnumerable <XmlConvertMethod> GetMethods(XmlSerializerSettings settings)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
throw new NotImplementedException();
}
public static T Deserialize <T>(string value, XmlSerializerSettings settings = null, T defaultValue = default(T))
{
if (string.IsNullOrWhiteSpace(value))
{
return(defaultValue);
}
XmlSerializer serializer = CreateSerializer(typeof(T), settings);
return((T)Deserialize(value, serializer, (object)defaultValue));
}
public static object Deserialize(string value, [NotNull] Type type, XmlSerializerSettings settings = null, object defaultValue = null)
{
if (string.IsNullOrWhiteSpace(value))
{
return(defaultValue);
}
XmlSerializer serializer = CreateSerializer(type, settings);
return(Deserialize(value, serializer, defaultValue));
}
public static string Serialize <T>([NotNull] T value, XmlSerializerSettings settings = null, XmlWriterSettings writerSettings = null)
{
if (value.IsNull())
{
return(null);
}
XmlSerializer serializer = CreateSerializer <T>(settings);
return(Serialize(value, serializer, writerSettings ?? XmlWriterHelper.CreateSettings()));
}
public static string Serialize(object value, XmlSerializerSettings settings = null, XmlWriterSettings writerSettings = null)
{
if (value.IsNull())
{
return(null);
}
XmlSerializer serializer = CreateSerializer(value.GetType(), settings);
return(Serialize(value, serializer, writerSettings ?? XmlWriterHelper.CreateSettings()));
}
public static string Serialize(object entity, string rootElementName, XmlSerializerSettings settings)
{
XmlDataSerializer serializer = new XmlDataSerializer(settings);
if (string.IsNullOrEmpty(rootElementName))
{
return(serializer.Serialize(entity));
}
else
{
return(serializer.Serialize(entity, rootElementName));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="XmlFormatterOptions"/> class.
/// </summary>
/// <remarks>
/// The following table shows the initial property values for an instance of <see cref="XmlFormatterOptions"/>.
/// <list type="table">
/// <listheader>
/// <term>Property</term>
/// <description>Initial Value</description>
/// </listheader>
/// <item>
/// <term><see cref="Settings"/></term>
/// <description><see cref="XmlSerializerSettings"/></description>
/// </item>
/// <item>
/// <term><see cref="SynchronizeWithXmlConvert"/></term>
/// <description><c>true</c></description>
/// </item>
/// <item>
/// <term><see cref="IncludeExceptionStackTrace"/></term>
/// <description><c>false</c></description>
/// </item>
/// </list>
/// </remarks>
public XmlFormatterOptions()
{
Settings = new XmlSerializerSettings();
XmlSerializerSettings.DefaultConverters = list =>
{
list.AddExceptionDescriptorConverter();
list.AddExceptionConverter(() => IncludeExceptionStackTrace);
list.AddEnumerableConverter();
list.AddUriConverter();
list.AddDateTimeConverter();
list.AddTimeSpanConverter();
list.AddStringConverter();
};
}
public NetBikeXmlMediaTypeFormatter(XmlSerializerSettings settings)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
serializer = new XmlSerializer(settings);
SupportedEncodings.Add(new UTF8Encoding(false, true));
SupportedEncodings.Add(new UnicodeEncoding(false, true, true));
SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/xml"));
SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/xml"));
}
public void WriteFooWithGlobalInlcludeNullHandlingTest()
{
var value = new Foo
{
Id = 1,
Name = null
};
var settings = new XmlSerializerSettings
{
OmitXmlDeclaration = true,
NullValueHandling = XmlNullValueHandling.Include,
ContractResolver = new XmlContractResolver(NamingConventions.CamelCase)
};
var actual = GetConverter().ToXml(value, settings: settings);
var expected = @"<xml><id>1</id><name p2:nil=""true"" xmlns:p2=""http://www.w3.org/2001/XMLSchema-instance"" /><reference p2:nil=""true"" xmlns:p2=""http://www.w3.org/2001/XMLSchema-instance"" /><enumValue p2:nil=""true"" xmlns:p2=""http://www.w3.org/2001/XMLSchema-instance"" /></xml>";
Assert.That(actual, IsXml.Equals(expected).WithIgnore(XmlComparisonType.NamespacePrefix));
}
/// <summary>
/// Asigna la configuración de la instancia a crear.
/// </summary>
/// <param name="config">Instancia de la configuracion. Tiene que ser serializable en xml</param>
/// <param name="rootName">Nombre a usar para el root de xml al serializar la configuración</param>
public virtual void SetConfiguration(object config, string rootName)
{
XmlSerializerSettings set = new XmlSerializerSettings();
set.UniqueSerializationForInstance = false;
set.WriteRootTypeDefinition = false;
if (string.IsNullOrEmpty(rootName))
{
this.ComponentConfiguration = XmlHelper.Serialize(config, null, set);
}
else
{
this.ComponentConfiguration = XmlHelper.Serialize(config, rootName, set);
_configuration = config;
}
if (config != null)
{
_configurationType = config.GetType();
}
}
private static XmlSerializationContext CreateContext(Type valueType, XmlMember member, XmlContract contract, XmlSerializerSettings settings)
{
if (settings == null)
{
settings = new XmlSerializerSettings
{
OmitXmlDeclaration = true,
ContractResolver = new XmlContractResolver(NamingConventions.CamelCase)
};
}
if (contract == null)
{
contract = settings.ContractResolver.ResolveContract(valueType);
}
if (member == null)
{
member = contract.Root;
}
return(new XmlSerializationContext(settings, member, contract));
}
/// <summary>
/// Applies the specified <paramref name="settings"/> to the function delegate <see cref="XmlConvert.DefaultSettings"/>.
/// </summary>
/// <param name="settings">The XML serializer settings.</param>
public static void ApplyToDefaultSettings(this XmlSerializerSettings settings)
{
XmlConvert.DefaultSettings = () => settings;
}
/// <summary>
/// Initializes a new instance of the <see cref="DataSourceXml"/> class.
/// </summary>
/// <param name="settings">The settings.</param>
/// <exception cref="ArgumentNullException">settings</exception>
public DataSourceXml(XmlSerializerSettings settings)
{
Settings = settings ?? throw new ArgumentNullException(nameof(settings));
}
public static TValue ParseXml <TValue>(this IXmlConverter converter, string xmlString, XmlMember member = null, XmlContract contract = null, XmlSerializerSettings settings = null)
{
return((TValue)ParseXml(converter, typeof(TValue), xmlString, member, contract, settings));
}
public static string ToXml <TValue>(this IXmlConverter converter, TValue value, XmlMember member = null, XmlContract contract = null, XmlSerializerSettings settings = null)
{
return(ToXml(converter, typeof(TValue), value, member, contract, settings));
}
public static XmlSerializer CreateSerializer <T>(XmlSerializerSettings settings = null)
{
return(CreateSerializer(typeof(T), settings));
}
public static object ParseXml(this IXmlConverter converter, Type valueType, string xmlString, XmlMember member = null, XmlContract contract = null, XmlSerializerSettings settings = null)
{
var context = CreateContext(valueType, member, contract, settings);
using (var input = new StringReader(xmlString))
using (var reader = XmlReader.Create(input, context.Settings.GetReaderSettings()))
{
while (reader.NodeType != XmlNodeType.Element && reader.Read())
{
}
if (reader.Name != "xml")
{
Assert.Fail("Expected start element \"xml\".");
}
var isAttribute = context.Member.MappingType == XmlMappingType.Attribute;
if (isAttribute)
{
reader.MoveToAttribute(context.Member.Name.LocalName, context.Member.Name.NamespaceUri);
}
var value = converter.ReadXml(reader, context);
if (isAttribute)
{
reader.MoveToElement();
if (reader.NodeType != XmlNodeType.Element || reader.Name != "xml")
{
Assert.Fail("Expected element \"xml\".");
}
}
else if (reader.NodeType != XmlNodeType.None)
{
Assert.Fail("Expected end of xml.");
}
return(value);
}
}
public static string ToXml(this IXmlConverter converter, Type valueType, object value, XmlMember member = null, XmlContract contract = null, XmlSerializerSettings settings = null)
{
var builder = new StringBuilder();
var context = CreateContext(valueType, member, contract, settings);
using (var output = new StringWriter(builder))
using (var writer = XmlWriter.Create(output, context.Settings.GetWriterSettings()))
{
writer.WriteStartElement("xml");
var isAttribute = context.Member.MappingType == XmlMappingType.Attribute;
if (isAttribute)
{
writer.WriteStartAttribute(context.Member.Name);
}
converter.WriteXml(writer, value, context);
if (isAttribute)
{
writer.WriteEndAttribute();
}
writer.WriteEndElement();
}
return(builder.ToString());
}
public static TObj Deserialize <TObj>(string rootElementName, XmlReader reader, XmlSerializerSettings settings)
{
XmlDataSerializer serializer = new XmlDataSerializer(settings);
return((TObj)serializer.Deserialize(typeof(TObj), rootElementName, reader));
}
public static TObj Deserialize <TObj>(string rootElementName, string xmlObject, XmlSerializerSettings settings)
{
XmlDataSerializer serializer = new XmlDataSerializer(settings);
return((TObj)serializer.Deserialize(typeof(TObj), rootElementName, xmlObject));
}
public static TObj Deserialize <TObj>(string xml, XmlSerializerSettings settings)
{
XmlDataSerializer serializer = new XmlDataSerializer(settings);
return((TObj)serializer.Deserialize(typeof(TObj), xml));
}
public static object Deserialize(Type rootType, string rootElementName, string xmlObject, XmlSerializerSettings settings)
{
XmlDataSerializer serializer = new XmlDataSerializer(settings);
return(serializer.Deserialize(rootType, rootElementName, xmlObject));
}
public static object Deserialize(string xmlObject, XmlSerializerSettings settings)
{
XmlDataSerializer serializer = new XmlDataSerializer(settings);
return(serializer.Deserialize(xmlObject));
}
