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); }