public static void Save(FunctionStack functionStack, string fileName)
{
NetDataContractSerializer bf = new NetDataContractSerializer();
using (Stream stream = File.OpenWrite(fileName))
{
bf.Serialize(stream, functionStack);
}
}
public static T Clone <T>(this T graph)
{
var serializer = new NetDataContractSerializer();
using var stream = new MemoryStream();
serializer.Serialize(stream, graph);
stream.Seek(0, SeekOrigin.Begin);
return((T)serializer.Deserialize(stream));
}
public void Serialize(List <Stadium> list)
{
NetDataContractSerializer formatter = new NetDataContractSerializer();
using (FileStream fs = new FileStream("Stadiums.xml", FileMode.Create))
{
formatter.Serialize(fs, list);
}
}
public void Write(ICollection <Film> films)
{
var serializer = new NetDataContractSerializer();
using (FileStream fs = new FileStream(path, FileMode.Create))
{
serializer.WriteObject(fs, films);
}
}
public string Serialize(T obj)
{
var ser = new NetDataContractSerializer();
using (var stream = new MemoryStream())
{
ser.WriteObject(stream, obj);
return(Encoding.ASCII.GetString(stream.ToArray()));
}
}
//Security Warning: The following code is intentionally vulnerable to a serialization vulnerability
public T Deserialize(string data)
{
var ser = new NetDataContractSerializer();
var bytes = Encoding.ASCII.GetBytes(data);
using (var stream = new MemoryStream(bytes))
{
return((T)ser.ReadObject(stream));
}
}
public static void Serialize(SerialObject so, Stream outputStream)
{
NetDataContractSerializer dcs = new NetDataContractSerializer()
{
SurrogateSelector = new ActorSurrogatorSelector(),
Binder = new ActorBinder()
};
dcs.Serialize(outputStream, so);
}
public static object Deserialize(byte[] array)
{
using (MemoryStream memStream = new MemoryStream(array))
using (GZipStream zipStream = new GZipStream(memStream, CompressionMode.Decompress))
using (XmlDictionaryReader xmlDictionaryReader = XmlDictionaryReader.CreateBinaryReader(zipStream, XmlDictionaryReaderQuotas.Max))
{
NetDataContractSerializer serializer = new NetDataContractSerializer();
return(serializer.ReadObject(xmlDictionaryReader));
}
}
internal void Save()
{
var serializer = new NetDataContractSerializer();
using (var file = File.Create(FileName))
using (var stream = new GZipStream(file, CompressionMode.Compress))
{
serializer.Serialize(stream, this);
}
}
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);
}
}
//</snippet9>
//<snippet10>
public static void Constructor3()
{
// Create an instance of the NetDataContractSerializer
// specifying the name and namespace as strings.
NetDataContractSerializer ser =
new NetDataContractSerializer(
"Customer",
"http://www.contoso.com");
// Other code not shown.
}
public static SerialObject DeSerialize(Stream inputStream)
{
CheckArg.Stream(inputStream);
inputStream.Seek(0, SeekOrigin.Begin);
NetDataContractSerializer dcs = new NetDataContractSerializer();
dcs.SurrogateSelector = new ActorSurrogatorSelector();
dcs.Binder = new ActorBinder();
return((SerialObject)dcs.ReadObject(inputStream));
}
public static object DeSerializeXmlBinary(byte[] bytes)
{
using (var rdr = XmlDictionaryReader.CreateBinaryReader(bytes, XmlDictionaryReaderQuotas.Max))
{
var serializer = new NetDataContractSerializer {
AssemblyFormat = FormatterAssemblyStyle.Simple
};
return(serializer.ReadObject(rdr));
}
}
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();
}
public static byte[] Serialize(object value)
{
var ns = new NetDataContractSerializer();
using (var s = new MemoryStream())
{
ns.WriteObject(s, value);
return(s.ToArray());
}
}
public static object MyNetDataContractDeserializer(string str)
{
var s = new NetDataContractSerializer();
byte[] serializedData = Encoding.UTF8.GetBytes(str);
MemoryStream ms = new MemoryStream(serializedData);
object obj = s.Deserialize(ms);
return(obj);
}
/// <summary>
/// Désérialise un stream.
/// </summary>
/// <param name="stream">Le stream contenant les données.</param>
/// <param name="binder">Le lieur de types.</param>
/// <returns>L'objet déserialisé.</returns>
public static object Deserialize(Stream stream, SerializationBinder binder)
{
var rdr = XmlDictionaryReader.CreateTextReader(stream, XmlDictionaryReaderQuotas.Max);
var ser = new NetDataContractSerializer()
{
Binder = binder,
};
return(ser.ReadObject(rdr));
}
public ICollection<Product> ReadProducts()
{
if (!File.Exists(path))
return null;
using (FileStream fs = new FileStream(path, FileMode.Open))
{
var serializer = new NetDataContractSerializer();
return serializer.ReadObject(fs) as ISet<Product>;
}
}
public Boolean LoadInstance(Guid instanceId, out IDictionary <XName, InstanceValue> instanceData, out IDictionary <XName, InstanceValue> instanceMetadata)
{
try
{
instanceData = new Dictionary <XName, InstanceValue>();
instanceMetadata = new Dictionary <XName, InstanceValue>();
String fileName = String.Format("{0}.xml", instanceId);
String fullPath = Path.Combine(_dataDirectory, fileName);
if (!File.Exists(fullPath))
{
return(false);
}
NetDataContractSerializer serializer = new NetDataContractSerializer();
//load instance data
XElement xml = XElement.Load(fullPath);
var xElement = xml.Element("InstanceData");
if (xElement != null)
{
var entries =
(from e in xElement.Elements("Entry")
select e).ToList();
foreach (XElement entry in entries)
{
LoadSingleEntry(serializer, instanceData, entry);
}
//load instance metadata
fileName = String.Format("{0}.meta.xml", instanceId);
fullPath = Path.Combine(_dataDirectory, fileName);
xml = XElement.Load(fullPath);
var element = xml.Element("InstanceMetadata");
if (element != null)
{
entries =
(from e in element.Elements("Entry")
select e).ToList();
}
foreach (XElement entry in entries)
{
LoadSingleEntry(serializer, instanceMetadata, entry);
}
}
}
catch (Exception exception)
{
Dev2Logger.Error(exception);
throw new InstancePersistenceException(exception.Message, exception);
}
return(true);
}
static Root DeSerialize8(Stream fs, Stopwatch sw)
{
NetDataContractSerializer ser = new NetDataContractSerializer();
XmlDictionaryReader xr = XmlDictionaryReader.CreateBinaryReader(fs, XmlDictionaryReaderQuotas.Max);
sw.Start();
var obj = (Root)ser.ReadObject(xr);
sw.Stop();
return(obj);
}
/// <summary>
/// Это пока не надо
/// </summary>
/// <param name="driver"></param>
/// <param name="path"></param>
private static void saveCookies(IWebDriver driver, string path)
{
IReadOnlyCollection <Cookie> cookes = driver.Manage().Cookies.AllCookies;
NetDataContractSerializer serializer = new NetDataContractSerializer();
using (FileStream fs = File.Create("cookies"))
{
serializer.Serialize(fs, cookes);
}
}
/// <summary>
/// Deserializes an object from the specified XML document.</summary>
/// <typeparam name="T">
/// The type of the object to deserialize.</typeparam>
/// <param name="document">
/// The complete XML document from which to deserialize the object.</param>
/// <returns>
/// The <typeparamref name="T"/> object resulting from the deserialization of <paramref
/// name="document"/>.</returns>
/// <exception cref="InvalidCastException">
/// The top-level object of <paramref name="document"/> is not of type <typeparamref
/// name="T"/>.</exception>
/// <remarks>
/// <b>Deserialize</b> uses a <see cref="NetDataContractSerializer"/> using <see
/// cref="FormatterAssemblyStyle.Simple"/> assembly mode, and an <see cref="XmlReader"/>
/// using the settings returned by <see cref="XmlUtility.CreateReaderSettings"/>.</remarks>
public static T Deserialize <T>(string document)
{
var settings = XmlUtility.CreateReaderSettings();
using (var textReader = new StringReader(document))
using (var reader = XmlReader.Create(textReader, settings)) {
var serializer = new NetDataContractSerializer();
serializer.AssemblyFormat = FormatterAssemblyStyle.Simple;
return((T)serializer.ReadObject(reader));
}
}
public Boolean LoadInstance(Guid instanceId,
out IDictionary <XName, InstanceValue> instanceData,
out IDictionary <XName, InstanceValue> instanceMetadata)
{
Boolean result = false;
try
{
instanceData = new Dictionary <XName, InstanceValue>();
instanceMetadata = new Dictionary <XName, InstanceValue>();
String fileName = String.Format("{0}.xml", instanceId);
String fullPath = Path.Combine(_dataDirectory, fileName);
if (!File.Exists(fullPath))
{
return(result);
}
NetDataContractSerializer serializer =
new NetDataContractSerializer();
//load instance data
XElement xml = XElement.Load(fullPath);
var entries =
(from e in xml.Element("InstanceData").Elements("Entry")
select e).ToList();
foreach (XElement entry in entries)
{
LoadSingleEntry(serializer, instanceData, entry);
}
//load instance metadata
fileName = String.Format("{0}.meta.xml", instanceId);
fullPath = Path.Combine(_dataDirectory, fileName);
xml = XElement.Load(fullPath);
entries =
(from e in xml.Element(
"InstanceMetadata").Elements("Entry")
select e).ToList();
foreach (XElement entry in entries)
{
LoadSingleEntry(serializer, instanceMetadata, entry);
}
result = true;
}
catch (IOException exception)
{
Console.WriteLine(
"LoadInstance Exception: {0}", exception.Message);
throw exception;
}
return(result);
}
private XmlObjectSerializer GetSerializer()
{
var res = new NetDataContractSerializer(
new StreamingContext(),
int.MaxValue,
false,
System.Runtime.Serialization.Formatters.FormatterAssemblyStyle.Full,
null);
return(res);
}
/*
* /// <summary>
* /// Converts an XElement to an XML DOM element.
* /// </summary>
* /// <param name="element">The XElement to be converted.</param>
* /// <returns>An XNML DOM element.</returns>
* public static XmlElement ConvertToXmlElement(this XElement element)
* {
* using (var xmlReader = element.CreateReader())
* {
* var xmlDoc = new AsXmlDocument();
* xmlDoc.Load(xmlReader);
* return xmlDoc.DocumentElement;
* }
* }
*/
/// <summary>
/// Serializes a CLR object (ref or value) to an XML representation.
/// </summary>
/// <param name="clrObject">The CLR object.</param>
/// <returns>An XML representation of the serialized object.</returns>
public static XmlElement SerializeClrObjectToXml(this object clrObject)
{
var xmlserializer = new NetDataContractSerializer();
var memStream = new MemoryStream();
xmlserializer.Serialize(memStream, clrObject);
var doc = new XmlDocument();
doc.Load(memStream.StreamAtStart());
return(doc.DocumentElement);
}
private static string SerializeToBinary(object obj)
{
using (var stream = new MemoryStream())
{
var serializer = new NetDataContractSerializer();
serializer.Serialize(stream, obj);
stream.Flush();
stream.Position = 0;
return(Convert.ToBase64String(stream.ToArray()));
}
}
//</snippet8>
//<snippet9>
public static void Constructor2()
{
// Create an instance of the StreamingContext to hold
// context data.
StreamingContext sc = new StreamingContext
(StreamingContextStates.CrossAppDomain);
// Create a DatatContractSerializer with the collection.
NetDataContractSerializer ser2 = new NetDataContractSerializer(sc);
// Other code not shown.
}
public BinaryStateSerializer(ILogger logger)
{
if (logger == null)
{
throw new ArgumentNullException("logger");
}
this.logger = logger;
netDataContractSerializer = new NetDataContractSerializer();
load();
}
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 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);
}
