Zzz – Rev 1

?pathlinks?

Blame – Last modification – View Log – Download

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Xml;
using System.Xml.Schema;
using System.Xml.Serialization;

namespace Zzz.Utilities.Serialization
{
    public static class Serialization
    {
        #region Public Methods

        public static async Task<SerializationState> Deserialize<T>(string file, string targetNamespace,
                                                                    string schemeUri,
                                                                    CancellationToken cancellationToken)
        {
            var xmlSerializer = new XmlSerializer(typeof(T));

            var validationEventArgs = new List<ValidationEventArgs>();

            void XmlReaderSettingsValidationEventHandler(object sender, ValidationEventArgs e)
            {
                validationEventArgs.Add(e);
            }

            T servers;

            var settings = new XmlReaderSettings();

            try
            {
                settings.Async = true;
                settings.DtdProcessing = DtdProcessing.Parse;
                settings.ValidationType = ValidationType.Schema;

                settings.ValidationFlags = XmlSchemaValidationFlags.ProcessInlineSchema |
                                           XmlSchemaValidationFlags.ProcessSchemaLocation |
                                           XmlSchemaValidationFlags.ReportValidationWarnings |
                                           XmlSchemaValidationFlags.ProcessIdentityConstraints;

                settings.Schemas = new XmlSchemaSet();

                settings.ValidationEventHandler += XmlReaderSettingsValidationEventHandler;

                settings.Schemas.Add(targetNamespace, schemeUri);

                using (var fileStream =
                       await Miscellaneous.GetFileStream(file, FileMode.Open, FileAccess.Read, FileShare.Read,
                           cancellationToken))
                {
                    using (var xmlReader = XmlReader.Create(fileStream,
                               settings))
                    {
                        var stringBuilder = new StringBuilder();

                        using (var stringWriter = new StringWriter(stringBuilder))
                        {
                            while (await xmlReader.ReadAsync())
                            {
                                await stringWriter.WriteAsync(await xmlReader.ReadOuterXmlAsync());
                            }
                        }

                        using (var stringReader = new StringReader(stringBuilder.ToString()))
                        {
                            servers =
                                (T)xmlSerializer
                                    .Deserialize(stringReader);
                        }
                    }
                }
            }
            catch (Exception exception)
            {
                return new SerializationFailure(exception, validationEventArgs);
            }
            finally
            {
                settings.ValidationEventHandler -=
                    XmlReaderSettingsValidationEventHandler;
            }

            return new SerializationSuccess<T>(servers, validationEventArgs);
        }

        public static async Task<SerializationState> Serialize<T>(T servers, string file, string name, string subset,
                                                                  CancellationToken cancellationToken)
        {
            var xmlSerializer = new XmlSerializer(typeof(T));

            try
            {
                using (var memoryStream = new MemoryStream())
                {
                    using (var xmlWriter =
                           XmlWriter.Create(memoryStream,
                               new XmlWriterSettings
                               {
                                   Async = true,
                                   Indent = true,
                                   IndentChars = "    ",
                                   OmitXmlDeclaration = false
                               }))
                    {
                        await xmlWriter.WriteDocTypeAsync(name,
                            null,
                            null,
                            subset);

                        xmlSerializer.Serialize(xmlWriter, servers);

                        using (var fileStream =
                               await Miscellaneous.GetFileStream(file, FileMode.Create, FileAccess.Write,
                                   FileShare.Write,
                                   cancellationToken))
                        {
                            memoryStream.Position = 0L;

                            await memoryStream.CopyToAsync(fileStream);
                        }
                    }
                }
            }
            catch (Exception exception)
            {
                return new SerializationFailure(exception);
            }

            return new SerializationSuccess<T>();
        }

        #endregion
    }
}

---

Generated by GNU Enscript 1.6.5.90.