private protected XmlSerializerBase(XmlSerializationOptions options)
{
if (!options.AllFlagsDefined())
{
Throw.EnumArgumentOutOfRange(Argument.options, options);
}
Options = options;
}
public void ConstructorPassesValuesCorrectly()
{
var name = "notdefault";
var options = new XmlSerializationOptions(encoding: Encoding.UTF32);
var serializer = new XSerializerXmlSerializer(name, options);
serializer.Name.Should().Be(name);
serializer.Options.Should().NotBeNull();
serializer.Options.Should().BeSameAs(options);
}
public static XmlSerializationOptions Default()
{
XmlSerializationOptions d = new XmlSerializationOptions();
d.AddNamespace("", "");
d.DisableEncryption();
d.EmitNil();
d.EncryptRootObject();
d.IgnoreCaseForEnum();
d.Indent();
d.SerializeCharAsInt();
d.ShouldTreatEmptyElementAsString();
d.ShouldUseAttributeDefinedInInterface();
return(d);
}
public bool Serialize <T> (T obj1, T obj2, Stream stream, XmlSerializationOptions options)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
var encoding = options != null ? options.Encoding ?? Helper.UTF8Unsigned : Helper.UTF8Unsigned;
var update_writer = new UpdateTextWriter(new StreamWriter(stream, encoding));
var context = new UpdateContext(obj2, stream, encoding);
using (var xml_writer = XmlWriter.Create(update_writer, new XmlWriterSettings {
Encoding = encoding, OmitXmlDeclaration = true
})) {
xml_serializer.Serialize(obj1, xml_writer, context);
}
return(context.Delineated);
}
static ScriptService()
{
CommandsByName = Assembly.GetEntryAssembly().GetTypes().Where(type => !type.IsAbstract && type.GetInterfaces().Any(interf => interf == typeof(IScriptCommand))).Select(type =>
{
var command = (AbstractScriptCommand)Activator.CreateInstance(type);
return(new CommandInfo
{
Name = type.Name,
Type = type,
ParamName1 = command.ParamName1,
ParamName2 = command.ParamName2
});
}
).ToDictionary(info => info.Name, info => info);
XmlSerializationOptions options = new XmlSerializationOptions(shouldIndent: true);
Serializer = new XmlSerializer <Script>(options);
}
/// <summary>
/// Serializes the object passed in <paramref name="obj"/> into the specified <paramref name="fileName"/>.
/// </summary>
/// <param name="fileName">Name of the file to create for serialization.</param>
/// <param name="obj">The <see cref="object"/> to serialize.</param>
/// <param name="options">Options for serialization. This parameter is optional.
/// <br/>Default value: <see cref="XmlSerializationOptions.CompactSerializationOfPrimitiveArrays"/>, <see cref="XmlSerializationOptions.EscapeNewlineCharacters"/></param>
/// <exception cref="ArgumentNullException"><paramref name="fileName"/> must not be null.</exception>
/// <exception cref="IOException">File cannot be created or write error.</exception>
/// <exception cref="NotSupportedException">Serialization is not supported with provided <paramref name="options"/></exception>
/// <exception cref="ReflectionException">The object hierarchy to serialize contains circular reference.</exception>
public static void Serialize(string fileName, object obj, XmlSerializationOptions options = defaultOptions)
{
if (fileName == null)
{
Throw.ArgumentNullException(Argument.fileName);
}
XmlWriter xmlWriter = XmlWriter.Create(fileName, new XmlWriterSettings
{
Indent = true,
NewLineHandling = NewLineHandling.Entitize,
Encoding = Encoding.UTF8
});
using (xmlWriter)
{
Serialize(xmlWriter, obj, options);
xmlWriter.Flush();
}
}
/// <summary>
/// Serializes the object passed in <paramref name="obj"/> into the provided <see cref="Stream"/>.
/// </summary>
/// <param name="stream">A <see cref="Stream"/> used to write the XML document. The stream will not be closed after serialization.</param>
/// <param name="obj">The <see cref="object"/> to serialize.</param>
/// <param name="options">Options for serialization. This parameter is optional.
/// <br/>Default value: <see cref="XmlSerializationOptions.CompactSerializationOfPrimitiveArrays"/>, <see cref="XmlSerializationOptions.EscapeNewlineCharacters"/></param>
/// <exception cref="ArgumentNullException"><paramref name="stream"/> must not be null.</exception>
/// <exception cref="NotSupportedException"><para>Serialization is not supported with provided <paramref name="options"/></para>
/// <para>- or -</para>
/// <para>The stream does not support writing.</para></exception>
/// <exception cref="ReflectionException">The object hierarchy to serialize contains circular reference.</exception>
/// <exception cref="IOException">An I/O error occurred.</exception>
/// <exception cref="ObjectDisposedException">The stream is already closed.</exception>
public static void Serialize(Stream stream, object obj, XmlSerializationOptions options = defaultOptions)
{
if (stream == null)
{
Throw.ArgumentNullException(Argument.stream);
}
XmlWriterSettings settings = new XmlWriterSettings
{
Indent = true,
CloseOutput = false,
// NewLineHandling = NewLineHandling.Entitize - entitizes only /r and not /n. Deserialize preserves now not entitized newlines and escaping still can be enabled in options
};
using (XmlWriter writer = XmlWriter.Create(stream, settings))
{
Serialize(writer, obj, options);
writer.Flush();
}
}
private void KGySerializeObjects(object[] referenceObjects, XmlSerializationOptions options, bool alsoAsContent = true)
{
Console.WriteLine($"------------------KGySoft XmlSerializer (Items Count: {referenceObjects.Length}; options: {options.ToString<XmlSerializationOptions>()})--------------------");
try
{
XElement xElement = new XElement("test");
StringBuilder sb = new StringBuilder();
using (XmlWriter writer = XmlWriter.Create(sb, new XmlWriterSettings {
OmitXmlDeclaration = true, Indent = true
}))
{
writer.WriteStartElement("test");
foreach (var item in referenceObjects)
{
xElement.Add(KGyXmlSerializer.Serialize(item, options));
KGyXmlSerializer.Serialize(writer, item, options);
if (!alsoAsContent)
{
continue;
}
// content serialization test for element
if (item == null)
{
Console.WriteLine("Skipping null");
continue;
}
XElement xItem = new XElement("itemContent");
StringBuilder sbItem = new StringBuilder();
using (XmlWriter itemWriter = XmlWriter.Create(sbItem, new XmlWriterSettings {
OmitXmlDeclaration = true, Indent = true
}))
{
KGyXmlSerializer.SerializeContent(xItem, item, options);
Console.WriteLine(xItem);
Console.WriteLine();
itemWriter.WriteStartElement("itemContent");
KGyXmlSerializer.SerializeContent(itemWriter, item, options);
itemWriter.WriteFullEndElement();
}
object deserXElement;
object deserReader;
using (XmlReader itemReader = XmlReader.Create(new StringReader(sbItem.ToString()), new XmlReaderSettings {
IgnoreWhitespace = true
}))
{
var itemType = item.GetType();
deserXElement = itemType.IsArray ? item.DeepClone() : Reflector.CreateInstance(itemType);
KGyXmlSerializer.DeserializeContent(xItem, deserXElement);
deserReader = itemType.IsArray ? item.DeepClone() : Reflector.CreateInstance(itemType);
itemReader.Read(); // to node "itemContent"
KGyXmlSerializer.DeserializeContent(itemReader, deserReader);
itemReader.ReadEndElement();
}
AssertDeepEquals(item, deserXElement);
AssertDeepEquals(item, deserReader);
Assert.AreEqual(xItem.ToString(), sbItem.ToString(), "XElement and XmlWriter serializers are not compatible");
}
writer.WriteEndDocument();
writer.Flush();
}
Console.WriteLine(xElement);
List <object> deserializedObjects = new List <object>();
// deserialize by reader - if file already contains unescaped newlines: // new XmlTextReader(new StringReader(sb.ToString()));
using (XmlReader reader = XmlReader.Create(new StringReader(sb.ToString()), new XmlReaderSettings {
IgnoreWhitespace = true
}))
{
try
{
reader.Read(); // test
foreach (XElement element in xElement.Elements())
{
object deserXElement = KGyXmlSerializer.Deserialize(element);
object deserReader = KGyXmlSerializer.Deserialize(reader);
AssertDeepEquals(deserXElement, deserReader);
deserializedObjects.Add(deserXElement);
}
}
finally
{
reader.Close();
}
}
AssertItemsEqual(referenceObjects, deserializedObjects.ToArray());
Assert.AreEqual(xElement.ToString(), sb.ToString(), "XElement and XmlWriter serializers are not compatible");
}
catch (Exception e)
{
Console.WriteLine($"KGySoft serialization failed: {e}");
throw;
}
}
public void Serialize(Stream output, XPathItemFactory itemFactory, XmlQualifiedName method) {
if (this.Content == null) throw new InvalidOperationException("Content cannot be null.");
XPathItem item = this.Content;
if (method == ExtensionMethods.Base64Binary) {
byte[] buffer = (!item.IsNode && item.XmlType.TypeCode == XmlTypeCode.Base64Binary) ?
(byte[])item.TypedValue :
Convert.FromBase64String(item.Value);
output.Write(buffer, 0, buffer.Length);
} else if (method == ExtensionMethods.HexBinary) {
byte[] buffer = (!item.IsNode && item.XmlType.TypeCode == XmlTypeCode.HexBinary) ?
(byte[])item.TypedValue :
fromBinHexString(item.Value);
output.Write(buffer, 0, buffer.Length);
} else {
XmlSerializationOptions serialization = new XmlSerializationOptions {
Indent = this.Indent,
OmitXmlDeclaration = this.OmitXmlDeclaration,
MediaType = this.MediaType,
Method = method,
DocTypePublic = this.DocTypePublic,
DocTypeSystem = this.DocTypeSystem,
Encoding = this.Encoding,
ByteOrderMark = this.ByteOrderMark
};
itemFactory.Serialize(item, output, serialization);
}
}
public void ToXml(XmlTextWriter writer, UGUI nextOwner, XmlSerializationOptions options)
{
writer.WriteNamedValue("InventorySerial", InventorySerial);
writer.WriteStartElement("TaskInventory");
{
foreach (ObjectPartInventoryItem item in Values)
{
writer.WriteStartElement("TaskInventoryItem");
{
writer.WriteUUID("AssetID", (options & XmlSerializationOptions.AdjustForNextOwner) != 0 ? item.NextOwnerAssetID : item.AssetID);
writer.WriteNamedValue("BasePermissions", (uint)item.Permissions.Base);
writer.WriteNamedValue("CreationDate", item.CreationDate.AsUInt);
writer.WriteUUID("CreatorID", item.Creator.ID);
if (!string.IsNullOrEmpty(item.Creator.CreatorData))
{
writer.WriteNamedValue("CreatorData", item.Creator.CreatorData);
}
writer.WriteNamedValue("Description", item.Description);
writer.WriteNamedValue("EveryonePermissions", (uint)item.Permissions.EveryOne);
writer.WriteNamedValue("Flags", (uint)item.Flags);
if ((options & XmlSerializationOptions.WriteOwnerInfo) != XmlSerializationOptions.None)
{
writer.WriteNamedValue("GroupID", item.Group.ID);
}
else
{
writer.WriteNamedValue("GroupID", UUID.Zero);
}
writer.WriteNamedValue("GroupPermissions", (uint)item.Permissions.Group);
writer.WriteNamedValue("InvType", (uint)item.InventoryType);
writer.WriteUUID("ItemID", item.ID);
writer.WriteUUID("OldItemID", UUID.Zero);
writer.WriteUUID("LastOwnerID", item.LastOwner.ID);
writer.WriteNamedValue("Name", item.Name);
writer.WriteNamedValue("NextPermissions", (uint)item.Permissions.NextOwner);
if ((options & XmlSerializationOptions.WriteOwnerInfo) != XmlSerializationOptions.None)
{
writer.WriteUUID("OwnerID", item.Owner.ID);
writer.WriteNamedValue("CurrentPermissions", (uint)item.Permissions.Current);
}
else if ((options & XmlSerializationOptions.AdjustForNextOwner) != XmlSerializationOptions.None)
{
writer.WriteUUID("OwnerID", nextOwner.ID);
writer.WriteNamedValue("CurrentPermissions", (uint)item.Permissions.NextOwner);
}
else
{
writer.WriteUUID("OwnerID", UUID.Zero);
writer.WriteNamedValue("CurrentPermissions", (uint)item.Permissions.Current);
}
writer.WriteUUID("ParentID", item.ParentFolderID);
writer.WriteUUID("ParentPartID", item.ParentFolderID);
var grantinfo = item.PermsGranter;
writer.WriteUUID("PermsGranter", grantinfo.PermsGranter.ID);
writer.WriteNamedValue("PermsMask", (uint)grantinfo.PermsMask);
writer.WriteNamedValue("Type", (int)item.AssetType);
writer.WriteNamedValue("OwnerChanged", (options & XmlSerializationOptions.AdjustForNextOwner) != XmlSerializationOptions.None);
UEI experienceID = item.ExperienceID;
if (experienceID != UEI.Unknown)
{
writer.WriteNamedValue("ExperienceID", experienceID.ToString());
}
{
ObjectPartInventoryItem.CollisionFilterParam p = item.CollisionFilter;
if (p.ID != UUID.Zero || p.Name?.Length != 0)
{
writer.WriteStartElement("CollisionFilter");
writer.WriteNamedValue("Name", p.Name);
writer.WriteNamedValue("ID", p.ID);
writer.WriteNamedValue("Type", p.Type.ToString());
writer.WriteEndElement();
}
}
}
writer.WriteEndElement();
}
}
writer.WriteEndElement();
}
public void ToXml(XmlTextWriter writer, XmlSerializationOptions options)
{
ToXml(writer, UGUI.Unknown, options);
}
public void ToXml(XmlTextWriter writer, UGUI nextOwner, Vector3 offsetpos, XmlSerializationOptions options = XmlSerializationOptions.None, bool writeOffsetPos = true)
{
List <ObjectPart> parts = Values;
writer.WriteStartElement("SceneObjectGroup");
if (writeOffsetPos)
{
Vector3 opos = Position - offsetpos;
writer.WriteAttributeString("x", opos.X.ToString(System.Globalization.CultureInfo.InvariantCulture));
writer.WriteAttributeString("y", opos.Y.ToString(System.Globalization.CultureInfo.InvariantCulture));
writer.WriteAttributeString("z", opos.Z.ToString(System.Globalization.CultureInfo.InvariantCulture));
}
if ((options & XmlSerializationOptions.WriteXml2) == 0)
{
writer.WriteStartElement("RootPart");
}
RootPart.ToXml(writer, options);
if ((options & XmlSerializationOptions.WriteXml2) == 0)
{
writer.WriteEndElement();
}
writer.WriteStartElement("OtherParts");
foreach (ObjectPart p in parts)
{
if (p.ID != RootPart.ID)
{
if ((options & XmlSerializationOptions.WriteXml2) == 0)
{
writer.WriteStartElement("Part");
}
p.ToXml(writer, nextOwner, options);
if ((options & XmlSerializationOptions.WriteXml2) == 0)
{
writer.WriteEndElement();
}
}
}
writer.WriteEndElement();
bool haveScriptState = false;
foreach (ObjectPart p in parts)
{
foreach (ObjectPartInventoryItem i in p.Inventory.Values)
{
IScriptState scriptState = i.ScriptState;
if (scriptState != null)
{
if (!haveScriptState)
{
writer.WriteStartElement("GroupScriptStates");
haveScriptState = true;
}
writer.WriteStartElement("SavedScriptState");
writer.WriteAttributeString("UUID", i.ID.ToString());
scriptState.ToXml(writer);
writer.WriteEndElement();
}
}
}
if (haveScriptState)
{
writer.WriteEndElement();
}
writer.WriteEndElement();
}
public static AssetData Asset(this ObjectGroup grp, UGUI nextOwner, Vector3 offsetpos, XmlSerializationOptions options = XmlSerializationOptions.None, bool writeOffsetPos = true)
{
using (var ms = new MemoryStream())
{
using (var writer = ms.UTF8XmlTextWriter())
{
grp.ToXml(writer, nextOwner, offsetpos, options, writeOffsetPos);
writer.Flush();
}
return(new AssetData
{
ID = UUID.Random,
Type = AssetType.Object,
Data = ms.ToArray()
});
}
}
/// <summary>
/// Initializes a new instance of the <see cref="XSerializerXmlSerializer"/> class.
/// </summary>
/// <param name="name">The name of the serializer, used to when selecting which serializer to use.</param>
/// <param name="options">Options for customizing the XmlSerializer.</param>
public XSerializerXmlSerializer(string name = "default", XmlSerializationOptions options = null)
{
Name = name ?? "default";
Options = options;
}
public static AssetData Asset(this ObjectGroup grp, XmlSerializationOptions options = XmlSerializationOptions.None) => grp.Asset(UGUI.Unknown, Vector3.Zero, options, false);
/// <summary> /// Serializes the object passed in <paramref name="obj"/> parameter into a new <see cref="XElement"/> object. /// </summary> /// <param name="obj">The object to serialize.</param> /// <param name="options">Options for serialization. This parameter is optional. /// <br/>Default value: <see cref="XmlSerializationOptions.CompactSerializationOfPrimitiveArrays"/>, <see cref="XmlSerializationOptions.EscapeNewlineCharacters"/></param> /// <returns>An <see cref="XElement"/> instance that contains the serialized object. /// Result can be deserialized by <see cref="Deserialize(XElement)"/> method.</returns> /// <exception cref="NotSupportedException">Root object is a read-only collection.</exception> /// <exception cref="ReflectionException">The object hierarchy to serialize contains circular reference.<br/>-or-<br/> /// Serialization is not supported with provided <paramref name="options"/></exception> public static XElement Serialize(object obj, XmlSerializationOptions options = defaultOptions) => new XElementSerializer(options).Serialize(obj);
public static AssetData Asset(this List <ObjectGroup> objlist, UGUI nextOwner, XmlSerializationOptions options)
{
if (objlist.Count == 1)
{
return(objlist[0].Asset(nextOwner, options));
}
Vector3 basepos = objlist[0].Position;
using (var ms = new MemoryStream())
{
using (var writer = ms.UTF8XmlTextWriter())
{
writer.WriteStartElement("CoalescedObject");
foreach (var grp in objlist)
{
grp.ToXml(writer, nextOwner, basepos, options);
}
writer.WriteEndElement();
writer.Flush();
}
return(new AssetData
{
ID = UUID.Random,
Type = AssetType.Object,
Data = ms.ToArray()
});
}
}
public static AssetData Asset(this List <ObjectGroup> objlist, XmlSerializationOptions options) => objlist.Asset(UGUI.Unknown, options);
private void KGySerializeObject(object obj, XmlSerializationOptions options, bool randomContent = false)
{
Type type = obj.GetType();
Console.WriteLine($"------------------KGySoft XmlSerializer ({type} - options: {options.ToString<XmlSerializationOptions>()})--------------------");
try
{
// XElement - as object
//Console.WriteLine(".....As object.....");
XElement xElement = KGyXmlSerializer.Serialize(obj, options);
Console.WriteLine(xElement);
object deserializedObject = KGyXmlSerializer.Deserialize(xElement);
AssertDeepEquals(obj, deserializedObject);
// XmlReader/Writer - as object
StringBuilder sb = new StringBuilder();
using (XmlWriter writer = XmlWriter.Create(sb, new XmlWriterSettings {
Indent = true, OmitXmlDeclaration = true
}))
{
KGyXmlSerializer.Serialize(writer, obj, options);
}
// deserialize by reader - if file already contains unescaped newlines: // new XmlTextReader(new StringReader(sb.ToString()));
using (var reader = XmlReader.Create(new StringReader(sb.ToString()), new XmlReaderSettings {
CloseInput = true
}))
{
deserializedObject = KGyXmlSerializer.Deserialize(reader);
}
AssertDeepEquals(obj, deserializedObject);
if (!randomContent)
{
Assert.AreEqual(xElement.ToString(), sb.ToString(), "XElement and XmlWriter Serialize are not compatible");
}
// XElement - as component
//Console.WriteLine();
//Console.WriteLine(".....As component.....");
var xElementComp = new XElement("test");
KGyXmlSerializer.SerializeContent(xElementComp, obj, options);
//Console.WriteLine(xElementComp);
deserializedObject = type.IsArray ? Array.CreateInstance(type.GetElementType(), ((Array)obj).Length) : Reflector.CreateInstance(type);
KGyXmlSerializer.DeserializeContent(xElementComp, deserializedObject);
AssertDeepEquals(obj, deserializedObject);
// XmlReader/Writer - as component
sb = new StringBuilder();
using (var writer = XmlWriter.Create(sb, new XmlWriterSettings {
Indent = true, OmitXmlDeclaration = true
}))
{
writer.WriteStartElement("test");
KGyXmlSerializer.SerializeContent(writer, obj, options);
writer.WriteFullEndElement();
writer.Flush();
}
// deserialize by reader - if file already contains unescaped newlines: // new XmlTextReader(new StringReader(sb.ToString()));
using (var reader = XmlReader.Create(new StringReader(sb.ToString()), new XmlReaderSettings {
CloseInput = true, IgnoreWhitespace = true
}))
{
deserializedObject = type.IsArray ? Array.CreateInstance(type.GetElementType(), ((Array)obj).Length) : Reflector.CreateInstance(type);
reader.Read(); // to node "test"
KGyXmlSerializer.DeserializeContent(reader, deserializedObject);
reader.ReadEndElement();
}
AssertDeepEquals(obj, deserializedObject);
Assert.AreEqual(xElementComp.ToString(), sb.ToString(), "XElement and XmlWriter SerializeContent are not compatible");
}
catch (Exception e)
{
Console.WriteLine($"KGySoft serialization failed: {e}");
throw;
}
}
public XElementSerializer(XmlSerializationOptions options) : base(options)
{
}
public void Serialize(TextWriter output, XPathItemFactory itemFactory) {
if (this.Content == null)
return;
XmlSerializationOptions serialization = new XmlSerializationOptions {
Method = this.Method,
};
itemFactory.Serialize(this.Content, output, serialization);
}
public void ToXml(XmlTextWriter writer, UGUI nextOwner, XmlSerializationOptions options = XmlSerializationOptions.None)
{
ToXml(writer, nextOwner, Vector3.Zero, options, false);
}
/// <summary> /// Saves public properties or collection elements of an object given in <paramref name="obj"/> parameter /// into an already existing <see cref="XElement"/> object given in <paramref name="parent"/> parameter /// with provided <paramref name="options"/>. /// </summary> /// <param name="obj">The object, which inner content should be serialized. Parameter value must not be <see langword="null"/>.</param> /// <param name="parent">The parent under that the object will be saved. Its content can be deserialized by <see cref="DeserializeContent(XElement,object)"/> method.</param> /// <param name="options">Options for serialization. This parameter is optional. /// <br/>Default value: <see cref="XmlSerializationOptions.CompactSerializationOfPrimitiveArrays"/>, <see cref="XmlSerializationOptions.EscapeNewlineCharacters"/></param> /// <exception cref="ArgumentNullException"><paramref name="obj"/> and <paramref name="parent"/> must not be <see langword="null"/>.</exception> /// <exception cref="NotSupportedException">Serialization is not supported with provided <paramref name="options"/></exception> /// <exception cref="ReflectionException">The object hierarchy to serialize contains circular reference.</exception> /// <remarks> /// If the provided object in <paramref name="obj"/> parameter is a collection, then elements will be serialized, too. /// If you want to serialize a primitive type, then use the <see cref="Serialize(object,XmlSerializationOptions)"/> method. /// </remarks> public static void SerializeContent(XElement parent, object obj, XmlSerializationOptions options = defaultOptions) => new XElementSerializer(options).SerializeContent(parent, obj);
public static AssetData Asset(this ObjectGroup grp, UGUI nextOwner, XmlSerializationOptions options = XmlSerializationOptions.None) => grp.Asset(nextOwner, Vector3.Zero, options, false);
public XmlWriterSerializer(XmlSerializationOptions options) : base(options)
{
}
/// <summary> /// Saves public properties or collection elements of an object given in <paramref name="obj"/> parameter /// by an already opened <see cref="XmlWriter"/> object given in <paramref name="writer"/> parameter /// with provided <paramref name="options"/>. /// </summary> /// <param name="obj">The object, which inner content should be serialized. Parameter value must not be <see langword="null"/>.</param> /// <param name="writer">A preconfigured <see cref="XmlWriter"/> object that will be used for serialization. The writer must be in proper state to serialize <paramref name="obj"/> properly /// and will not be closed or flushed after serialization.</param> /// <param name="options">Options for serialization. This parameter is optional. /// <br/>Default value: <see cref="XmlSerializationOptions.CompactSerializationOfPrimitiveArrays"/>, <see cref="XmlSerializationOptions.EscapeNewlineCharacters"/></param> /// <exception cref="ArgumentNullException"><paramref name="obj"/> and <paramref name="writer"/> must not be <see langword="null"/>.</exception> /// <exception cref="NotSupportedException">Serialization is not supported with provided <paramref name="options"/></exception> /// <exception cref="ReflectionException">The object hierarchy to serialize contains circular reference.</exception> /// <remarks> /// If the provided object in <paramref name="obj"/> parameter is a collection, then elements will be serialized, too. /// If you want to serialize a primitive type, then use the <see cref="Serialize(XmlWriter,object,XmlSerializationOptions)"/> method. /// </remarks> public static void SerializeContent(XmlWriter writer, object obj, XmlSerializationOptions options = defaultOptions) => new XmlWriterSerializer(options).SerializeContent(writer, obj);
