private string SerializeGame([NotNull] MGM.Game.Game game)
{
var memoryStream = new MemoryStream();
Serializer.WriteObject(memoryStream, game);
return(Encoding.UTF8.GetString(memoryStream.ToArray()));
}
private void Store(string fileName, object graph)
{
XmlWriter writer = null;
try {
if (File.Exists(fileName))
{
File.Copy(fileName, GetBackupFileName(fileName), true);
File.Delete(fileName);
}
writer = XmlWriter.Create(fileName);
//writer = new XmlTextWriter(fileName, Encoding.UTF8);
//writer.Formatting = Formatting.Indented;
//writer.Namespaces = false;
NetDataContractSerializer ser = new NetDataContractSerializer();
ser.AssemblyFormat = FormatterAssemblyStyle.Simple;
//DataContractSerializer ser = new DataContractSerializer(typeof (ArrayList));
ser.WriteObject(writer, graph);
}
catch (Exception) {
throw;
}
finally {
if (writer != null)
{
writer.Close();
}
}
}
private static void SaveResultsToFile(ScheduledJob job, FileStream fs)
{
XmlObjectSerializer netDataContractSerializer = new NetDataContractSerializer();
netDataContractSerializer.WriteObject(fs, job);
fs.Flush();
}
public static string Serialize(object value)
{
if (value == null)
{
return(String.Empty);
}
else
{
using (var m = new MemoryStream())
{
var w = XmlTextWriter.Create(
m,
new XmlWriterSettings()
{
Indent = true,
Encoding = Encoding.Unicode,
NamespaceHandling = NamespaceHandling.OmitDuplicates,
});
var s = new NetDataContractSerializer();
s.WriteObject(w, value);
w.Flush();
w.Close();
// Don't forget to skip byte order mark
var buffer = m.ToArray();
var prelen = Encoding.Unicode.GetPreamble().Length;
return(System.Text.Encoding.Unicode.GetString(buffer, prelen, buffer.Length - prelen));
}
}
}
public static void WriteObject <T>(T data, string fileName, ExceptionHandler exceptionHandler)
{
try
{
using (var fs = new FileStream(fileName, FileMode.Create))
{
var settings = new XmlWriterSettings {
Indent = true
};
using (var writer = XmlWriter.Create(fs, settings))
{
var ser = new NetDataContractSerializer();
ser.WriteObject(writer, data);
writer.Close();
}
}
}
catch (Exception exc)
{
if (exceptionHandler != null)
{
exceptionHandler($"{nameof(XmlIO)}.{nameof(ReadObject)}<{typeof(T).Name}>", exc);
}
else
{
throw;
}
}
}
static void DeserializeAndReserialize(string path)
{
Console.WriteLine(
"Deserializing new version to old version");
FileStream fs = new FileStream(path,
FileMode.Open);
XmlDictionaryReader reader = XmlDictionaryReader.
CreateTextReader(fs, new XmlDictionaryReaderQuotas());
// Create the serializer.
NetDataContractSerializer ser =
new NetDataContractSerializer();
// Deserialize version 1 of the data.
PurchaseOrder PO_V1 =
(PurchaseOrder)ser.ReadObject(reader, false);
Console.WriteLine("Order Date:{0}",
PO_V1.PurchaseDate.ToLongDateString());
fs.Close();
Console.WriteLine(
"Reserialize the object with extension data intact");
// First change the order date.
DateTime newDate = PO_V1.PurchaseDate.AddDays(10);
PO_V1.PurchaseDate = newDate;
// Create a new FileStream to write with.
FileStream writer = new FileStream(path, FileMode.Create);
// Serialize the object with changed data.
ser.WriteObject(writer, PO_V1);
writer.Close();
}
public static void SaveToDevice <T>(T obj, String path, Action userCallback) where T : class
{
if (_storageDevice == null)
{
Console.WriteLine("Storage Device was null");
if (userCallback != null)
{
userCallback();
}
return;
}
_storageDevice.BeginOpenContainer(Constants.Locations.ContainerName, openResult => {
using (var sd = _storageDevice.EndOpenContainer(openResult)) {
var serializer = new NetDataContractSerializer();
var writerSettings = new XmlWriterSettings {
Indent = true, CloseOutput = true
};
using (var writer = XmlWriter.Create(sd.CreateFile(path), writerSettings)) {
serializer.WriteObject(writer, obj);
}
if (userCallback != null)
{
userCallback();
}
}
}, null);
}
static void Main(string[] args)
{
// create a new Person object
Person myPerson = new Person("Adam Freeman", "London");
// open the stream to the file we want to store the data in
Stream myStream = new MemoryStream();
// create the serialize
NetDataContractSerializer serializer = new NetDataContractSerializer();
// serialize the Person object
serializer.WriteObject(myStream, myPerson);
// reset the cursor on the stream and read the serialized data
myStream.Seek(0, SeekOrigin.Begin);
StreamReader myReader = new StreamReader(myStream);
Console.WriteLine(myReader.ReadToEnd());
// reset the cursor and deserialize the object
myStream.Seek(0, SeekOrigin.Begin);
Person myDeserializedPerson = (Person)serializer.ReadObject(myStream);
// wait for input before exiting
Console.WriteLine("Press enter to finish");
Console.ReadLine();
}
private bool TryNetDataContractSerializer(Type type)
{
using (var m = new MemoryStream())
{
var w = XmlTextWriter.Create(
m,
new XmlWriterSettings()
{
Indent = true,
Encoding = Encoding.Unicode,
NamespaceHandling = NamespaceHandling.OmitDuplicates,
});
var s = new NetDataContractSerializer(
new StreamingContext(),
int.MaxValue,
false,
System.Runtime.Serialization.Formatters.FormatterAssemblyStyle.Simple,
null);
var o = Activator.CreateInstance(type, true);
s.WriteObject(w, o);
w.Flush();
w.Close();
// Don't forget to skip byte order mark
var buffer = m.ToArray();
var prelen = Encoding.Unicode.GetPreamble().Length;
var xml = System.Text.Encoding.Unicode.GetString(buffer, prelen, buffer.Length - prelen);
}
return(true);
}
/// <summary>
/// /// <summary>
/// Serialization routines used only to mimic SQL persistance to ensure there are no errors during unit testing of the in memory store.
/// Obtained from https://referencesource.microsoft.com/#System.Activities.DurableInstancing/System/Activities/DurableInstancing/SerializationUtilities.cs,6929c9045420df05
/// </summary>
/// </summary>
/// <param name="stream"></param>
/// <param name="propertyBag"></param>
void DefaultSerializePropertyBag(Stream stream, Dictionary <XName, object> propertyBag)
{
using (XmlDictionaryWriter dictionaryWriter = XmlDictionaryWriter.CreateBinaryWriter(stream, null, null, false))
{
dictionaryWriter.WriteStartElement("Properties");
foreach (KeyValuePair <XName, object> property in propertyBag)
{
dictionaryWriter.WriteStartElement("Property");
try
{
serializer.WriteObject(dictionaryWriter, property);
}
catch (System.Runtime.Serialization.InvalidDataContractException ex)
{
throw new SerializationFailedException("This can be caused by many issues. Ensure you have a default constructor and check the inner exception for more info. See also: https://stackoverflow.com/questions/10077121/datacontract-exception-cannot-be-serialized", ex);
}
dictionaryWriter.WriteEndElement();
}
dictionaryWriter.WriteEndElement();
}
}
public void WriteXml(XmlWriter writer)
{
if (this.Value != null)
{
NetDataContractSerializer serializer = this.CreateSerializer();
serializer.WriteObject(writer, this.Value);
}
}
public void Save(string path, IShape shape)
{
using (var f = File.OpenWrite(path))
{
var s = new NetDataContractSerializer();
s.WriteObject(f, shape);
}
}
private static void SaveStatusToFile(ScheduledJob job, FileStream fs)
{
StatusInfo statusInfo = new StatusInfo(job.InstanceId, job.Name, job.Location, job.Command, job.StatusMessage, job.JobStateInfo.State, job.HasMoreData, job.PSBeginTime, job.PSEndTime, job.Definition);
XmlObjectSerializer netDataContractSerializer = new NetDataContractSerializer();
netDataContractSerializer.WriteObject(fs, statusInfo);
fs.Flush();
}
public void WriteProducts(ICollection<Product> products)
{
var serializer = new NetDataContractSerializer();
using (FileStream fs = new FileStream(path, FileMode.Create))
{
serializer.WriteObject(fs, products);
}
}
public void Write(ICollection <Film> films)
{
var serializer = new NetDataContractSerializer();
using (FileStream fs = new FileStream(path, FileMode.Create))
{
serializer.WriteObject(fs, films);
}
}
public static byte[] Serialize(object value)
{
var ns = new NetDataContractSerializer();
using (var s = new MemoryStream())
{
ns.WriteObject(s, value);
return(s.ToArray());
}
}
public string Serialize(T obj)
{
var ser = new NetDataContractSerializer();
using (var stream = new MemoryStream())
{
ser.WriteObject(stream, obj);
return(Encoding.ASCII.GetString(stream.ToArray()));
}
}
public static void Save(Plugin plg)
{
MySerialization oMainFormSerialize = new MySerialization(plg);
NetDataContractSerializer dcs = new NetDataContractSerializer();
using (Stream oStream = File.Create(plg.SerializePath)) {
dcs.WriteObject(oStream, oMainFormSerialize);
}
}
static void Serialize7(Root r, Stream fs, Stopwatch sw)
{
NetDataContractSerializer ser = new NetDataContractSerializer();
XmlDictionaryWriter xw = XmlDictionaryWriter.CreateTextWriter(fs);
sw.Start();
ser.WriteObject(xw, r);
sw.Stop();
xw.Close();
}
/// <summary>
/// Serializes the specified object to XML.
/// </summary>
/// <param name="item">The object to serialize. Must have <see cref="DataContractAttribute" /> applied.</param>
/// <returns>An <see cref="XElement" /> representing the specified object.</returns>
/// <exception cref="InvalidDataContractException"><paramref name="item" /> is not a valid data contract.</exception>
public static XElement Serialize(object item)
{
NetDataContractSerializer serializer = CreateSerializer(Enumerable.Empty <SerializerProxyMap>());
XDocument doc = new XDocument();
using (XmlWriter writer = doc.CreateWriter())
{
serializer.WriteObject(writer, item);
}
return(doc.Root);
}
public XElement ToElement(object val, Func <Type, XNamespace> getNamespace)
{
var serializer = new NetDataContractSerializer();
using (var ms = new MemoryStream())
{
serializer.WriteObject(ms, val);
ms.Seek(0, SeekOrigin.Begin);
return(XElement.Load(new XmlTextReader(ms)));
}
}
/// <summary>
/// Serializes the specified object to a complete XML document.</summary>
/// <typeparam name="T">
/// The type of the object to serialize.</typeparam>
/// <param name="obj">
/// The object to serialize.</param>
/// <returns>
/// A <see cref="String"/> containing the complete XML document resulting from the
/// serialization of <paramref name="obj"/>.</returns>
/// <exception cref="SerializationException">
/// <paramref name="obj"/> could not be serialized.</exception>
/// <remarks>
/// <b>Serialize</b> uses a <see cref="NetDataContractSerializer"/> and an <see
/// cref="XmlWriter"/> using the settings returned by <see
/// cref="XmlUtility.CreateWriterSettings"/>.</remarks>
public static string Serialize <T>(T obj)
{
var builder = new StringBuilder();
var settings = XmlUtility.CreateWriterSettings();
using (var writer = XmlWriter.Create(builder, settings)) {
var serializer = new NetDataContractSerializer();
serializer.WriteObject(writer, obj);
}
return(builder.ToString());
}
public static void WriteObject(string fileName)
{
Console.WriteLine("Creating a Person object and serializing it.");
// Creating the serializer
ComplexNumber number = new ComplexNumberWithMagnitude(3, 4);
FileStream fs = new FileStream(fileName, FileMode.Create);
XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(fs);
NetDataContractSerializer ser = new NetDataContractSerializer();
ser.WriteObject(writer, number);
writer.Close();
}
//<snippet1>
public static void WriteObject(string fileName)
{
Console.WriteLine(
"Creating a Person object and serializing it.");
Person p1 = new Person("Zighetti", "Barbara", 101);
FileStream fs = new FileStream(fileName, FileMode.Create);
XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(fs);
NetDataContractSerializer ser =
new NetDataContractSerializer();
ser.WriteObject(writer, p1);
writer.Close();
}
//</snippet14>
public void CannotSerialize()
{
//<snippet15>
FileStream fs = new FileStream("mystuff.xml", FileMode.Create, FileAccess.ReadWrite);
XElement myElement = new XElement("Parent", new XElement("child1", "form"),
new XElement("child2", "base"),
new XElement("child3", "formbase")
);
NetDataContractSerializer dcs = new NetDataContractSerializer();
dcs.WriteObject(fs, myElement);
//</snippet15>
}
//Сохранение состояния библиотеки в файл
public void Serialize(String FileName)
{
var serializer = new NetDataContractSerializer();
var xmlWriterSettings = new XmlWriterSettings {
Indent = true
};
using (var xmlWriter =
XmlWriter.Create(FileName, xmlWriterSettings))
{
serializer.WriteObject(xmlWriter, this);
}
}
public static string SerializeWithNetDcs(object obj)
{
using (var ms = new MemoryStream())
{
using (var sr = new StreamReader(ms, Encoding.UTF8))
{
var serializer = new NetDataContractSerializer();
serializer.WriteObject(ms, obj);
ms.Position = 0;
return(sr.ReadToEnd());
}
}
}
public static void Serialize(LambdaExpression expression, Object paramValue)
{
// Serialize Expression
var serializedExpression = new ExpressionSerializer(new TypeResolver(assemblies)).Serialize(expression);
File.WriteAllText(expressionfile, serializedExpression.ToString());
// Serialize Parameter
using (fs = new FileStream(paramfile, FileMode.Create, FileAccess.ReadWrite))
{
paramSerializer.WriteObject(fs, paramValue);
}
}
public static byte[] SerializeXmlBinary(object obj)
{
using (var ms = new MemoryStream())
{
using (var wtr = XmlDictionaryWriter.CreateBinaryWriter(ms))
{
var serializer = new NetDataContractSerializer();
serializer.WriteObject(wtr, obj);
ms.Flush();
}
return(ms.ToArray());
}
}
public void Update(T dto)
{
if (!scope.IsRegistered <IDtoPortalHandleUpdate <T> >())
{
throw new DtoPortalDalNotRegisteredException();
}
var dal = scope.Resolve <IDtoPortalHandleUpdate <T> >();
// Update a serialized object
// Simulate going to the application server
NetDataContractSerializer serializer = new NetDataContractSerializer();
// Client to server
MemoryStream ms = new MemoryStream();
serializer.WriteObject(ms, dto);
ms.Seek(0, 0);
var newDto = (T)serializer.ReadObject(ms);
dal.Update(newDto);
// Server to client
ms = new MemoryStream();
serializer.WriteObject(ms, newDto);
ms.Seek(0, 0);
// Context get's send to DtoBase.OnDeserialized
// So that as each Dto is deserialized we send it
// to the BO that created the corresponding BO
serializer.Context = new StreamingContext(StreamingContextStates.CrossMachine, updateManager);
var returnDto = (T)serializer.ReadObject(ms);
}