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);