public static string Serialize(object obj, bool preserveReferences, Type[] extraTypes = null)
{
using (var stringWriter = new StringWriter())
{
using (var reader = XmlWriter.Create(stringWriter))
{
var settings = new DataContractSerializerSettings();
if (extraTypes != null)
{
settings.KnownTypes = extraTypes;
}
settings.PreserveObjectReferences = preserveReferences;
var serializer = new DataContractSerializer(obj.GetType(), settings);
serializer.WriteObject(reader, obj);
}
return(stringWriter.ToString());
}
}
private Dictionary <string, InstanceValue> Deserialize(string s)
{
try
{
DataContractSerializerSettings settings = new DataContractSerializerSettings
{
PreserveObjectReferences = true,
KnownTypes = _knownTypes
};
var serializer = new DataContractSerializer(typeof(Dictionary <string, InstanceValue>), settings);
using var stream = new MemoryStream(Convert.FromBase64String(s));
return((Dictionary <string, InstanceValue>)serializer.ReadObject(stream));
}
catch (Exception e)
{
throw;
}
}
[SuppressMessage("Microsoft.Usage", "CA2202:Do not dispose objects multiple times")] //This is fine. XmlWriter disposes the FileStream, but calling twice is a NOP.
public void SerializeProject(ComProject project)
{
var filepath = Path.Combine(Target, FileName(project));
using (var stream = new FileStream(filepath, FileMode.Create, FileAccess.Write))
using (var xmlWriter = XmlWriter.Create(stream, WriterSettings))
using (var writer = XmlDictionaryWriter.CreateDictionaryWriter(xmlWriter))
{
writer.WriteStartDocument();
var settings = new DataContractSerializerSettings
{
RootNamespace = XmlDictionaryString.Empty,
PreserveObjectReferences = true
};
var serializer = new DataContractSerializer(typeof(ComProject), settings);
serializer.WriteObject(writer, project);
}
}
public void IDataContractSurrogate()
{
_dbContext.Configuration.ProxyCreationEnabled = true;
_dbContext.Configuration.LazyLoadingEnabled = true;
DataContractSerializerSettings settings = new DataContractSerializerSettings()
{
DataContractSurrogate = new OrderDataContractSurrogate()
};
DataContractSerializer serializer = new DataContractSerializer(typeof(IEnumerable <Order>), settings);
var tester = new XmlDataContractSerializerTester <IEnumerable <Order> >(serializer, true);
var orders = _dbContext.Orders.ToList();
tester.SerializeAndDeserialize(orders);
}
/// <summary>
/// Initializes a new instance of <see cref="XmlDataContractSerializerInputFormatter"/>.
/// </summary>
/// <param name="options">The <see cref="MvcOptions"/>.</param>
public XmlDataContractSerializerInputFormatter(MvcOptions options)
{
_options = options;
SupportedEncodings.Add(UTF8EncodingWithoutBOM);
SupportedEncodings.Add(UTF16EncodingLittleEndian);
SupportedMediaTypes.Add(MediaTypeHeaderValues.ApplicationXml);
SupportedMediaTypes.Add(MediaTypeHeaderValues.TextXml);
SupportedMediaTypes.Add(MediaTypeHeaderValues.ApplicationAnyXmlSyntax);
_serializerSettings = new DataContractSerializerSettings();
WrapperProviderFactories = new List <IWrapperProviderFactory>
{
new SerializableErrorWrapperProviderFactory(),
};
}
public async Task WriteAsync_WritesWhenConfiguredWithKnownTypes()
{
// Arrange
var sampleInt = 10;
var sampleString = "TestString";
var KnownTypeName = "SomeDummyClass";
var InstanceNamespace = "http://www.w3.org/2001/XMLSchema-instance";
var expectedOutput = string.Format(
"<DummyClass xmlns:i=\"{1}\" xmlns=\"\" i:type=\"{0}\"><SampleInt>{2}</SampleInt>"
+ "<SampleString>{3}</SampleString></DummyClass>",
KnownTypeName,
InstanceNamespace,
sampleInt,
sampleString);
var sampleInput = new SomeDummyClass
{
SampleInt = sampleInt,
SampleString = sampleString
};
var settings = new DataContractSerializerSettings
{
KnownTypes = new[] { typeof(SomeDummyClass) }
};
var formatter = new XmlDataContractSerializerOutputFormatter
{
SerializerSettings = settings
};
var outputFormatterContext = GetOutputFormatterContext(sampleInput, typeof(DummyClass));
// Act
await formatter.WriteAsync(outputFormatterContext);
// Assert
var body = outputFormatterContext.HttpContext.Response.Body;
body.Position = 0;
var content = new StreamReader(body).ReadToEnd();
XmlAssert.Equal(expectedOutput, content);
}
public async Task WriteAsync_WritesWhenConfiguredWithRootName()
{
// Arrange
var sampleInt = 10;
var SubstituteRootName = "SomeOtherClass";
var SubstituteRootNamespace = "http://tempuri.org";
var InstanceNamespace = "http://www.w3.org/2001/XMLSchema-instance";
var expectedOutput = string.Format(
CultureInfo.InvariantCulture,
"<{0} xmlns:i=\"{2}\" xmlns=\"{1}\"><SampleInt xmlns=\"\">{3}</SampleInt></{0}>",
SubstituteRootName,
SubstituteRootNamespace,
InstanceNamespace,
sampleInt);
var sampleInput = new DummyClass {
SampleInt = sampleInt
};
var dictionary = new XmlDictionary();
var settings = new DataContractSerializerSettings
{
RootName = dictionary.Add(SubstituteRootName),
RootNamespace = dictionary.Add(SubstituteRootNamespace)
};
var formatter = new XmlDataContractSerializerOutputFormatter
{
SerializerSettings = settings
};
var outputFormatterContext = GetOutputFormatterContext(sampleInput, sampleInput.GetType());
// Act
await formatter.WriteAsync(outputFormatterContext);
// Assert
var body = outputFormatterContext.HttpContext.Response.Body;
body.Position = 0;
var content = new StreamReader(body).ReadToEnd();
XmlAssert.Equal(expectedOutput, content);
}
public string Serialize(string path)
{
//string path = defaultPath + this.Name + ".xml";
//XmlSerializer ser = new XmlSerializer(typeof(Supermarket));
var dcss = new DataContractSerializerSettings {
PreserveObjectReferences = true
};
var dcs = new DataContractSerializer(typeof(Supermarket), dcss);
File.WriteAllText(path, string.Empty);
using (FileStream st = new FileStream(path, FileMode.OpenOrCreate))
{
//ser.Serialize(st, this);
dcs.WriteObject(st, this);
}
return(path);
}
private static DataContractSerializer GetSerializer()
{
#if FEATURE_DCS_SETTINGS
var settings = new DataContractSerializerSettings
{
PreserveObjectReferences = true,
};
return(new DataContractSerializer(typeof(SimpleTypeRestrictions), settings));
#else
return(new DataContractSerializer(
typeof(SimpleTypeRestrictions),
null,
int.MaxValue,
false,
true,
null));
#endif
}
public void Serialize(BaseAssemblyMetadata data, string path)
{
using (FileStream fs = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.None))
{
//XmlWriterSettings sets = new XmlWriterSettings { Indent = true, IndentChars = "\t" };
//sets.CloseOutput = true;
//XmlWriter writer = XmlWriter.Create(fs, sets);
//DataContractSerializer ser;
//if (data is AssemblyMetadata)
//{
// ser = new DataContractSerializer(typeof(AssemblyMetadata));
//}
//else
//{
// ser = new DataContractSerializer(typeof(T));
//}
//ser.WriteObject(writer, data);
//writer.Close();
List <Type> lista = new List <Type>
{
typeof(System.FlagsAttribute),
typeof(System.Reflection.DefaultMemberAttribute),
typeof(System.AttributeUsageAttribute),
typeof(System.ObsoleteAttribute),
typeof(System.SerializableAttribute),
typeof(System.Runtime.Serialization.KnownTypeAttribute)
};
DataContractSerializerSettings DCsettings = new DataContractSerializerSettings {
PreserveObjectReferences = true, KnownTypes = lista
};
DataContractSerializer ser = new DataContractSerializer(typeof(BaseAssemblyMetadata), DCsettings);
var XmlWriterSettings = new XmlWriterSettings()
{
Indent = true,
IndentChars = "\t"
};
using (var XmlWriter = System.Xml.XmlWriter.Create(fs, XmlWriterSettings))
{
ser.WriteObject(XmlWriter, data);
}
}
}
public bool Deserialize(string path)
{
/*if (path == "")
* path = defaultPath + "section.xml";*/
//XmlSerializer ser = new XmlSerializer(typeof(SectionGoods));
var dcss = new DataContractSerializerSettings {
PreserveObjectReferences = true
};
var dcs = new DataContractSerializer(typeof(SectionGoods), dcss);
try
{
if (File.Exists(path))
{
using (FileStream st = new FileStream(path, FileMode.Open))
{
SectionGoods goods = new SectionGoods();
//goods = (SectionGoods)ser.Deserialize(st);
goods = (SectionGoods)dcs.ReadObject(st);
this.Clear();
this.Count = goods.Count;
this.Name = goods.Name;
this.head = goods.head;
}
return(true);
}
else
{
Console.WriteLine("Файла не существует.");
return(false);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
return(false);
}
}
public async Task StoreAsync <T>(StorageFolder folder, string name, T value, DataContractSerializerSettings settings)
{
// Validate parameters
if (folder == null)
{
throw new ArgumentNullException("folder");
}
if (string.IsNullOrEmpty(name))
{
throw new ArgumentNullException("name");
}
// Create the new file, overwriting the existing data, then pass on
StorageFile file = await folder.CreateFileAsync(name, CreationCollisionOption.ReplaceExisting);
await StoreAsync <T>(file, value, settings);
}
public string Serialize(string path)
{
//XmlSerializer ser = new XmlSerializer(typeof(SectionGoods));
//XmlSerializer ser = new XmlSerializer(typeof(SectionGoods), new System.Type[] { typeof(SectionGoods) });
/*string path = defaultPath + this.Name + ".xml";*/
var dcss = new DataContractSerializerSettings {
PreserveObjectReferences = true
};
var dcs = new DataContractSerializer(typeof(SectionGoods), dcss);
File.WriteAllText(path, string.Empty);
using (FileStream tw = new FileStream(path, FileMode.OpenOrCreate))
{
//ser.Serialize(tw, this);
dcs.WriteObject(tw, this);
}
return(path);
}
/// <summary> Deserializes an object from an XML file. </summary>
public static T FromXmlFile <T>(string fileName, IEnumerable <Type> known_types = null)
{
DataContractSerializerSettings s = new DataContractSerializerSettings()
{
PreserveObjectReferences = true
};
s.KnownTypes = known_types;
s.SerializeReadOnlyTypes = true; //?
using (FileStream fs = new FileStream(fileName, FileMode.Open))
{
using (XmlDictionaryReader reader = XmlDictionaryReader.CreateTextReader(fs, new XmlDictionaryReaderQuotas()))
{
DataContractSerializer ser = new DataContractSerializer(typeof(T), s);
T result = (T)ser.ReadObject(reader, true);
return(result);
}
}
}
public bool Deserialize(string path)
{
/*if (path == "")
* path = defaultPath + "supermarket.xml";*/
//XmlSerializer ser = new XmlSerializer(typeof(Supermarket));
var dcss = new DataContractSerializerSettings {
PreserveObjectReferences = true
};
var dcs = new DataContractSerializer(typeof(Supermarket), dcss);
try
{
if (File.Exists(path))
{
using (FileStream st = new FileStream(path, FileMode.OpenOrCreate))
{
//Supermarket sp = (Supermarket)ser.Deserialize(st);
Supermarket sp = new Supermarket();
sp = (Supermarket)dcs.ReadObject(st);
this.Clear();
this.Name = sp.Name;
this.QueueSize = sp.QueueSize;
this.AllExistSections = sp.AllExistSections;
}
return(true);
}
else
{
return(false);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
return(false);
}
}
/// <summary>
/// Writes a given BDD to a stream.
/// </summary>
/// <param name="bdd">
/// The bdd.
/// </param>
/// <param name="stream">
/// The stream.
/// </param>
public override void Write(BinaryDecisionDiagram bdd, FileStream stream)
{
var listOfNodes = (from lAssembly in AppDomain.CurrentDomain.GetAssemblies()
from lType in lAssembly.GetTypes()
where typeof(BDDNode).IsAssignableFrom(lType)
select lType).ToArray();
var setting = new DataContractSerializerSettings {
PreserveObjectReferences = true, KnownTypes = listOfNodes
};
var xmlSettings = new XmlWriterSettings {
Indent = true
};
var serializer = new DataContractSerializer(typeof(BinaryDecisionDiagram), setting);
using (XmlWriter w = XmlWriter.Create(stream, xmlSettings))
{
serializer.WriteObject(XmlWriter.Create(w, xmlSettings), bdd);
}
}
//public static T Deserialize<T>(string filePath)
//{
// return (T)Deserialize(typeof(T), filePath, null);
//}
//public static object Deserialize(Type type, string filePath, DataContractSerializerSettings settings)
//{
// using (FileStream stream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read))
// {
// return Deserialize(type, stream, settings);
// }
//}
public static object Deserialize(Type type, Stream stream, DataContractSerializerSettings settings)
{
DataContractSerializer ser = new DataContractSerializer(type, settings);
if (stream.Length > 0)
{
try
{
return(ser.ReadObject(stream));
}
catch (Exception e)
{
Kooboo.Common.Logging.Logger.Error(e.Message, e);
return(null);
}
}
else
{
return(null);
}
}
/// <summary>
/// Initializes a new instance of <see cref="XmlDataContractSerializerOutputFormatter"/>
/// </summary>
/// <param name="writerSettings">The settings to be used by the <see cref="DataContractSerializer"/>.</param>
public XmlDataContractSerializerOutputFormatter(XmlWriterSettings writerSettings)
{
if (writerSettings == null)
{
throw new ArgumentNullException(nameof(writerSettings));
}
SupportedEncodings.Add(Encoding.UTF8);
SupportedEncodings.Add(Encoding.Unicode);
SupportedMediaTypes.Add(MediaTypeHeaderValues.ApplicationXml);
SupportedMediaTypes.Add(MediaTypeHeaderValues.TextXml);
WriterSettings = writerSettings;
_serializerSettings = new DataContractSerializerSettings();
WrapperProviderFactories = new List <IWrapperProviderFactory>();
WrapperProviderFactories.Add(new EnumerableWrapperProviderFactory(WrapperProviderFactories));
WrapperProviderFactories.Add(new SerializableErrorWrapperProviderFactory());
}
public async Task StoreAsync <T>(StorageFile file, T value, DataContractSerializerSettings settings)
{
if (file == null)
{
throw new ArgumentNullException("file");
}
// Write the object to a MemoryStream using the DataContractSerializer
using (MemoryStream dataStream = new MemoryStream())
{
DataContractSerializer serializer = new DataContractSerializer(typeof(T), settings);
serializer.WriteObject(dataStream, value);
// Save the data to the file stream
using (Stream fileStream = await file.OpenStreamForWriteAsync())
{
dataStream.Seek(0, SeekOrigin.Begin);
await dataStream.CopyToAsync(fileStream);
}
}
}
public void SaveToFile(string filename)
{
var settings = new DataContractSerializerSettings
{
PreserveObjectReferences = true
};
var serializer = new DataContractSerializer(typeof(Project), settings);
var xmlSettings = new XmlWriterSettings
{
Indent = true
};
using (var file = XmlWriter.Create(new FileStream(filename, FileMode.Create), xmlSettings))
{
serializer.WriteObject(file, this);
}
IsDirty = false;
ProjectDirtied?.Invoke(IsDirty);
}
public void Contact_NewSerializes()
{
DataContractSerializerSettings dcs_set = new DataContractSerializerSettings();
dcs_set.PreserveObjectReferences = true;
DataContractSerializer dcs =
new DataContractSerializer(typeof(Contact), dcs_set);
Contact init = new Contact();
MemoryStream cache = new MemoryStream();
dcs.WriteObject(cache, init);
cache.Seek(0, SeekOrigin.Begin);
Person final = dcs.ReadObject(cache) as Contact;
Assert.That(
init,
Is.EqualTo(final).Using(new ContactComparer()),
"Contact did not round-trip.");
}
public void IDataContractSurrogate()
{
dbContext.Configuration.ProxyCreationEnabled = true;
dbContext.Configuration.LazyLoadingEnabled = true;
//var tester =
// new XmlDataContractSerializerTester<IEnumerable<Order>>
// (
// new DataContractSerializer(typeof(IEnumerable<Order>)),
// true
// );
//var orders = dbContext.Orders.ToList();
//tester.SerializeAndDeserialize(orders);
var formatterSettings = new DataContractSerializerSettings()
{
DataContractSurrogate = new OrderSurrogate()
};
var formatter = new DataContractSerializer(typeof(IEnumerable <Order>), formatterSettings);
var tester = new XmlDataContractSerializerTester <IEnumerable <Order> >(formatter, true);
var orders = dbContext.Orders.ToList();
var res = tester.SerializeAndDeserialize(orders);
Assert.IsTrue(res.Any());
foreach (var o in res)
{
Assert.IsNotNull(o.Customer);
Assert.IsNotNull(o.Employee);
Assert.IsTrue(o.GetType() == typeof(Order));
Assert.IsTrue(o.Customer.GetType() == typeof(Customer));
Assert.IsTrue(o.Employee.GetType() == typeof(Employee));
}
}
public void Write(BaseAssemblyMetadata obj, string filePath)
{
List <Type> lista = new List <Type>
{
typeof(System.FlagsAttribute),
typeof(System.Reflection.DefaultMemberAttribute),
typeof(System.AttributeUsageAttribute),
typeof(System.ObsoleteAttribute),
typeof(System.SerializableAttribute),
typeof(System.Runtime.Serialization.KnownTypeAttribute),
typeof(AssemblyMetadataDTO),
typeof(MethodMetadataDTO),
typeof(NamespaceMetadataDTO),
typeof(ParameterMetadataDTO),
typeof(PropertyMetadataDTO),
typeof(TypeMetadataDTO),
typeof(FieldMetadataDTO)
};
DataContractSerializerSettings DCSsettings = new DataContractSerializerSettings {
PreserveObjectReferences = true
};
XmlWriterSettings XmlWriterSettings = new XmlWriterSettings()
{
Indent = true,
IndentChars = "\t"
};
DataContractSerializer serializer = new DataContractSerializer(typeof(AssemblyMetadataDTO), lista);
using (FileStream stream = File.Create(filePath))
{
serializer.WriteObject(stream, new AssemblyMetadataDTO(obj));
}
}
public async Task ReadAsync_ReadsWhenConfiguredWithKnownTypes()
{
// Arrange
var expectedInt = 10;
var expectedString = "TestString";
var KnownTypeName = "SomeDummyClass";
var InstanceNamespace = "http://www.w3.org/2001/XMLSchema-instance";
var input = string.Format(
CultureInfo.InvariantCulture,
"<DummyClass i:type=\"{0}\" xmlns:i=\"{1}\"><SampleInt>{2}</SampleInt>"
+ "<SampleString>{3}</SampleString></DummyClass>",
KnownTypeName,
InstanceNamespace,
expectedInt,
expectedString);
var settings = new DataContractSerializerSettings
{
KnownTypes = new[] { typeof(SomeDummyClass) }
};
var formatter = new XmlDataContractSerializerInputFormatter(new MvcOptions())
{
SerializerSettings = settings
};
var contentBytes = Encoding.UTF8.GetBytes(input);
var context = GetInputFormatterContext(contentBytes, typeof(DummyClass));
// Act
var result = await formatter.ReadAsync(context);
// Assert
Assert.NotNull(result);
Assert.False(result.HasError);
var model = Assert.IsType <SomeDummyClass>(result.Model);
Assert.Equal(expectedInt, model.SampleInt);
Assert.Equal(expectedString, model.SampleString);
}
/// <summary>
/// Initializes a new instance of <see cref="XmlDataContractSerializerOutputFormatter"/>.
/// </summary>
/// <param name="writerSettings">The settings to be used by the <see cref="DataContractSerializer"/>.</param>
/// <param name="loggerFactory">The <see cref="ILoggerFactory"/>.</param>
public XmlDataContractSerializerOutputFormatter(XmlWriterSettings writerSettings, ILoggerFactory loggerFactory)
{
if (writerSettings == null)
{
throw new ArgumentNullException(nameof(writerSettings));
}
SupportedEncodings.Add(Encoding.UTF8);
SupportedEncodings.Add(Encoding.Unicode);
SupportedMediaTypes.Add(MediaTypeHeaderValues.ApplicationXml);
SupportedMediaTypes.Add(MediaTypeHeaderValues.TextXml);
SupportedMediaTypes.Add(MediaTypeHeaderValues.ApplicationAnyXmlSyntax);
WriterSettings = writerSettings;
_serializerSettings = new DataContractSerializerSettings();
WrapperProviderFactories = WrapperProviderFactoriesExtensions.GetDefaultProviderFactories();
WrapperProviderFactories.Add(new EnumerableWrapperProviderFactory(WrapperProviderFactories));
_logger = loggerFactory?.CreateLogger(GetType());
}
public async Task ReadAsync_ReadsWhenConfiguredWithRootName()
{
// Arrange
var expectedInt = 10;
var SubstituteRootName = "SomeOtherClass";
var SubstituteRootNamespace = "http://tempuri.org";
var input = string.Format(
CultureInfo.InvariantCulture,
"<{0} xmlns=\"{1}\"><SampleInt xmlns=\"\">{2}</SampleInt></{0}>",
SubstituteRootName,
SubstituteRootNamespace,
expectedInt);
var dictionary = new XmlDictionary();
var settings = new DataContractSerializerSettings
{
RootName = dictionary.Add(SubstituteRootName),
RootNamespace = dictionary.Add(SubstituteRootNamespace)
};
var formatter = new XmlDataContractSerializerInputFormatter(new MvcOptions())
{
SerializerSettings = settings
};
var contentBytes = Encoding.UTF8.GetBytes(input);
var context = GetInputFormatterContext(contentBytes, typeof(DummyClass));
// Act
var result = await formatter.ReadAsync(context);
// Assert
Assert.NotNull(result);
Assert.False(result.HasError);
var model = Assert.IsType <DummyClass>(result.Model);
Assert.Equal(expectedInt, model.SampleInt);
}
private static void DataContractSerializeCycles()
{
var firstNode = new Node <int> {
Value = 1
};
var secondNode = new Node <int> {
Value = 2
};
firstNode.Next = secondNode;
secondNode.Previous = firstNode;
var settings = new DataContractSerializerSettings()
{
PreserveObjectReferences = true
};
using (var stream = File.Create(path))
{
var serializer = new DataContractSerializer(typeof(Node <int>), settings);
serializer.WriteObject(stream, firstNode);
}
}
public bool Deserialize(string path)
{
/*if (path == "")
* path = defaultPath + "good.xml";*/
var dcss = new DataContractSerializerSettings {
PreserveObjectReferences = true
};
var dcs = new DataContractSerializer(typeof(Goods), dcss);
//XmlSerializer ser = new XmlSerializer(typeof(Goods));
if (File.Exists(path))
{
using (FileStream st = new FileStream(path, FileMode.Open))
{
try
{
//Goods des = (Goods)ser.Deserialize(st);
Goods des = (Goods)dcs.ReadObject(st);
this.Name = des.Name;
this.Price = des.Price;
this.Next = des.Next;
this.Previous = des.Previous;
}
catch
{
return(false);
}
}
return(true);
}
else
{
return(false);
}
}
private void SaveModel(string path)
{
DataContractSerializerSettings dcSettings = new DataContractSerializerSettings();
dcSettings.KnownTypes = new Type[] { typeof(Expression), typeof(ExprGenerator), typeof(Conditional), typeof(Modification) };
DataContractSerializer ser = new DataContractSerializer(typeof(PolyEModel), dcSettings);
XmlWriterSettings xmlSettings = new XmlWriterSettings();
xmlSettings.CloseOutput = true;
xmlSettings.Indent = true;
xmlSettings.IndentChars = " ";
xmlSettings.NewLineChars = Environment.NewLine;
//xmlSettings.NewLineHandling = NewLineHandling.Entitize;
xmlSettings.NewLineOnAttributes = false;
xmlSettings.WriteEndDocumentOnClose = false;
using (XmlWriter stream = XmlWriter.Create(path, xmlSettings))
{
ser.WriteObject(stream, _model);
stream.Close();
}
}
public async Task <T> RetrieveAsync <T>(StorageFile file, DataContractSerializerSettings settings)
{
// Validate parameters
if (file == null)
{
throw new ArgumentNullException("file");
}
// Open the file from the file stream
using (Stream fileStream = await file.OpenStreamForReadAsync())
{
// Copy the file to a MemoryStream (as we can do this async)
using (MemoryStream memoryStream = new MemoryStream())
{
await fileStream.CopyToAsync(memoryStream);
memoryStream.Seek(0, SeekOrigin.Begin);
try
{
DataContractSerializer serializer = new DataContractSerializer(typeof(T), settings);
return((T)serializer.ReadObject(memoryStream));
}
catch (Exception exc)
{
exc.Data.Add("File", file.Path);
exc.Data.Add("DataType", typeof(T).ToString());
Logger.Log(LogSeverity.Warning, this, "Unable to deserialize object.", exc);
throw exc;
}
}
}
}
public DataContractSerializer(Type type, DataContractSerializerSettings settings);
