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