Winify

Subversion Repositories:
Compare Path: Rev
With Path: Rev
?path1? @ 29  →  ?path2? @ 30
/trunk/Winify/Utilities/Serialization/Serialization.cs
@@ -0,0 +1,128 @@
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;
using Horizon.Utilities.Serialization;
 
namespace Winify.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
}
}