Serializzare un oggetto in XML

Ho una classe C # che ho ereditato. Ho "costruito" con successo l'oggetto. Ma devo serializzare l'oggetto in XML. C'è un modo semplice per farlo?

Sembra che la classe sia stata impostata per la serializzazione, ma non sono sicuro di come ottenere la rappresentazione XML. La definizione della mia classe è simile alla seguente:

[System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.0.30319.1")]
[System.SerializableAttribute()]
[System.Diagnostics.DebuggerStepThroughAttribute()]
[System.ComponentModel.DesignerCategoryAttribute("code")]
[System.Xml.Serialization.XmlTypeAttribute(AnonymousType = true, Namespace = "http://www.domain.com/test")]
[System.Xml.Serialization.XmlRootAttribute(Namespace = "http://www.domain.com/test", IsNullable = false)]
public partial class MyObject
{
  ...
}

Ecco cosa pensavo di poter fare, ma non funziona:

MyObject o = new MyObject();
// Set o properties
string xml = o.ToString();

Come ottengo la rappresentazione XML di questo oggetto?

Devi usare XmlSerializer per la serializzazione XML. Di seguito è riportato un frammento di esempio.

 XmlSerializer xsSubmit = new XmlSerializer(typeof(MyObject));
 var subReq = new MyObject();
 var xml = "";

 using(var sww = new StringWriter())
 {
     using(XmlWriter writer = XmlWriter.Create(sww))
     {
         xsSubmit.Serialize(writer, subReq);
         xml = sww.ToString(); // Your XML
     }
 }

Ho modificato il mio per restituire una stringa anziché utilizzare una variabile ref come di seguito.

public static string Serialize<T>(this T value)
{
    if (value == null)
    {
        return string.Empty;
    }
    try
    {
        var xmlserializer = new XmlSerializer(typeof(T));
        var stringWriter = new StringWriter();
        using (var writer = XmlWriter.Create(stringWriter))
        {
            xmlserializer.Serialize(writer, value);
            return stringWriter.ToString();
        }
    }
    catch (Exception ex)
    {
        throw new Exception("An error occurred", ex);
    }
}

Il suo utilizzo sarebbe così:

var xmlString = obj.Serialize();

La seguente funzione può essere copiata su qualsiasi oggetto per aggiungere una funzione di salvataggio XML utilizzando lo spazio dei nomi System.Xml.

/// <summary>
/// Saves to an xml file
/// </summary>
/// <param name="FileName">File path of the new xml file</param>
public void Save(string FileName)
{
    using (var writer = new System.IO.StreamWriter(FileName))
    {
        var serializer = new XmlSerializer(this.GetType());
        serializer.Serialize(writer, this);
        writer.Flush();
    }
}

Per creare l'oggetto dal file salvato, aggiungere la seguente funzione e sostituire [Tipo oggetto] con il tipo di oggetto da creare.

/// <summary>
/// Load an object from an xml file
/// </summary>
/// <param name="FileName">Xml file name</param>
/// <returns>The object created from the xml file</returns>
public static [ObjectType] Load(string FileName)
{
    using (var stream = System.IO.File.OpenRead(FileName))
    {
        var serializer = new XmlSerializer(typeof([ObjectType]));
        return serializer.Deserialize(stream) as [ObjectType];
    }
}

Classe di estensione:

using System.IO;
using System.Xml;
using System.Xml.Serialization;

namespace MyProj.Extensions
{
    public static class XmlExtension
    {
        public static string Serialize<T>(this T value)
        {
            if (value == null) return string.Empty;

            var xmlSerializer = new XmlSerializer(typeof(T));

            using (var stringWriter = new StringWriter())
            {
                using (var xmlWriter = XmlWriter.Create(stringWriter,new XmlWriterSettings{Indent = true}))
                {
                    xmlSerializer.Serialize(xmlWriter, value);
                    return stringWriter.ToString();
                }    
            }
        }
    }
}

Uso:

Foo foo = new Foo{MyProperty="I have been serialized"};

string xml = foo.Serialize();

Basta fare riferimento allo spazio dei nomi trattenere il metodo di estensione nel file che si desidera utilizzare e che funzionerà (nel mio esempio sarebbe: using MyProj.Extensions;)

Si noti che se si desidera rendere il metodo di estensione specifico solo per una determinata classe (ad es., Foo), È possibile sostituire l' Targomento nel metodo di estensione, ad es.

public static string Serialize(this Foo value){...}

È possibile utilizzare la funzione come di seguito per ottenere XML serializzati da qualsiasi oggetto.

public static bool Serialize<T>(T value, ref string serializeXml)
{
    if (value == null)
    {
        return false;
    }
    try
    {
        XmlSerializer xmlserializer = new XmlSerializer(typeof(T));
        StringWriter stringWriter = new StringWriter();
        XmlWriter writer = XmlWriter.Create(stringWriter);

        xmlserializer.Serialize(writer, value);

        serializeXml = stringWriter.ToString();

        writer.Close();
        return true;
    }
    catch (Exception ex)
    {
        return false;
    }
}

Puoi chiamarlo dal client.

Per serializzare un oggetto, eseguire:

 using (StreamWriter myWriter = new StreamWriter(path, false))
 {
     XmlSerializer mySerializer = new XmlSerializer(typeof(your_object_type));
     mySerializer.Serialize(myWriter, objectToSerialize);
 }

Ricorda inoltre che per far funzionare XmlSerializer è necessario un costruttore senza parametri.

Inizierò con la copia della risposta di Ben Gripka:

public void Save(string FileName)
{
    using (var writer = new System.IO.StreamWriter(FileName))
    {
        var serializer = new XmlSerializer(this.GetType());
        serializer.Serialize(writer, this);
        writer.Flush();
    }
}

Ho usato questo codice prima. Ma la realtà ha dimostrato che questa soluzione è un po 'problematica. Di solito la maggior parte dei programmatori semplicemente serializza le impostazioni sul salvataggio e deserializza le impostazioni sul caricamento. Questo è uno scenario ottimistico. Una volta che la serializzazione non è riuscita, per qualche motivo, il file è stato parzialmente scritto, il file XML non è completo e non è valido. Di conseguenza, la deserializzazione XML non funziona e l'applicazione potrebbe bloccarsi all'avvio. Se il file non è enorme, suggerisco prima di serializzare l'oggetto per MemoryStreamscrivere il flusso nel file. Questo caso è particolarmente importante in caso di complicata serializzazione personalizzata. Non puoi mai testare tutti i casi.

public void Save(string fileName)
{
    //first serialize the object to memory stream,
    //in case of exception, the original file is not corrupted
    using (MemoryStream ms = new MemoryStream())
    {
        var writer = new System.IO.StreamWriter(ms);    
        var serializer = new XmlSerializer(this.GetType());
        serializer.Serialize(writer, this);
        writer.Flush();

        //if the serialization succeed, rewrite the file.
        File.WriteAllBytes(fileName, ms.ToArray());
    }
}

La deserializzazione nello scenario del mondo reale dovrebbe contare con un file di serializzazione corrotto, succede qualche volta. La funzione di caricamento fornita da Ben Gripka va bene.

public static [ObjectType] Load(string fileName)
{
    using (var stream = System.IO.File.OpenRead(fileName))
    {
        var serializer = new XmlSerializer(typeof([ObjectType]));
        return serializer.Deserialize(stream) as [ObjectType];        
    }    
}

E potrebbe essere avvolto da alcuni scenari di recupero. È adatto per file di impostazioni o altri file che possono essere eliminati in caso di problemi.

public static [ObjectType] LoadWithRecovery(string fileName)
{
    try
    {
        return Load(fileName);
    }
    catch(Excetion)
    {
        File.Delete(fileName); //delete corrupted settings file
        return GetFactorySettings();
    }
}

Tutte le risposte votate sopra sono corrette. Questa è solo la versione più semplice:

private string Serialize(Object o)
{
    using (var writer = new StringWriter())
    {
        new XmlSerializer(o.GetType()).Serialize(writer, o);
        return writer.ToString();
    }
}

È un po 'più complicato che chiamare il ToStringmetodo della classe, ma non molto.

Ecco una semplice funzione drop-in che puoi usare per serializzare qualsiasi tipo di oggetto. Restituisce una stringa contenente i contenuti XML serializzati:

public string SerializeObject(object obj)
{
    System.Xml.XmlDocument xmlDoc = new System.Xml.XmlDocument();
    System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(obj.GetType());
    using (System.IO.MemoryStream ms = new System.IO.MemoryStream()) {
        serializer.Serialize(ms, obj);
        ms.Position = 0;
        xmlDoc.Load(ms);
        return xmlDoc.InnerXml;
    }
}

Ecco un buon tutorial su come farlo

Fondamentalmente dovresti usare la System.Xml.Serialization.XmlSerializerclasse per farlo.

    string FilePath = ConfigurationReader.FileLocation;   //Getting path value from web.config            
    XmlSerializer serializer = new XmlSerializer(typeof(Devices)); //typeof(object)
            MemoryStream memStream = new MemoryStream();
            serializer.Serialize(memStream, lstDevices);//lstdevices : I take result as a list.
            FileStream file = new FileStream(folderName + "\\Data.xml", FileMode.Create, FileAccess.ReadWrite); //foldername:Specify the path to store the xml file
            memStream.WriteTo(file);
            file.Close();

È possibile creare e archiviare il risultato come file xml nella posizione desiderata.

il mio codice di lavoro. Restituisce utf8 xml abilita lo spazio dei nomi vuoto.

// override StringWriter
public class Utf8StringWriter : StringWriter
{
    public override Encoding Encoding => Encoding.UTF8;
}

private string GenerateXmlResponse(Object obj)
{    
    Type t = obj.GetType();

    var xml = "";

    using (StringWriter sww = new Utf8StringWriter())
    {
        using (XmlWriter writer = XmlWriter.Create(sww))
        {
            var ns = new XmlSerializerNamespaces();
            // add empty namespace
            ns.Add("", "");
            XmlSerializer xsSubmit = new XmlSerializer(t);
            xsSubmit.Serialize(writer, obj, ns);
            xml = sww.ToString(); // Your XML
        }
    }
    return xml;
}

Esempio restituisce risposta Yandex api payment Aviso url:

<?xml version="1.0" encoding="utf-8"?><paymentAvisoResponse xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" performedDatetime="2017-09-01T16:22:08.9747654+07:00" code="0" shopId="54321" invoiceId="12345" orderSumAmount="10643" />

Ho un modo semplice per serializzare un oggetto in XML usando C #, funziona benissimo ed è altamente riutilizzabile. So che questo è un thread più vecchio, ma volevo pubblicarlo perché qualcuno potrebbe trovarlo utile.

Ecco come chiamo il metodo:

var objectToSerialize = new MyObject();
var xmlString = objectToSerialize.ToXmlString();

Ecco la classe che fa il lavoro:

Nota: poiché si tratta di metodi di estensione, devono essere in una classe statica.

using System.IO;
using System.Xml.Serialization;

public static class XmlTools
{
    public static string ToXmlString<T>(this T input)
    {
        using (var writer = new StringWriter())
        {
            input.ToXml(writer);
            return writer.ToString();
        }
    }

    private static void ToXml<T>(this T objectToSerialize, StringWriter writer)
    {
        new XmlSerializer(typeof(T)).Serialize(writer, objectToSerialize);
    }
}

Sulla base delle soluzioni precedenti, ecco una classe di estensione che è possibile utilizzare per serializzare e deserializzare qualsiasi oggetto. Qualsiasi altra attribuzione XML dipende da te.

Usalo in questo modo:

        string s = new MyObject().Serialize(); // to serialize into a string
        MyObject b = s.Deserialize<MyObject>();// deserialize from a string



internal static class Extensions
{
    public static T Deserialize<T>(this string value)
    {
        var xmlSerializer = new XmlSerializer(typeof(T));

        return (T)xmlSerializer.Deserialize(new StringReader(value));
    }

    public static string Serialize<T>(this T value)
    {
        if (value == null)
            return string.Empty;

        var xmlSerializer = new XmlSerializer(typeof(T));

        using (var stringWriter = new StringWriter())
        {
            using (var xmlWriter = XmlWriter.Create(stringWriter, new XmlWriterSettings { Indent = true }))
            {
                xmlSerializer.Serialize(xmlWriter, value);
                return stringWriter.ToString();
            }
        }
    }
}

Oppure puoi aggiungere questo metodo al tuo oggetto:

    public void Save(string filename)
    {
        var ser = new XmlSerializer(this.GetType());
        using (var stream = new FileStream(filename, FileMode.Create))
            ser.Serialize(stream, this);
    }

Ecco un codice di base che ti aiuterà a serializzare gli oggetti C # in xml:

using System;

public class clsPerson
{
  public  string FirstName;
  public  string MI;
  public  string LastName;
}

class class1
{ 
   static void Main(string[] args)
   {
      clsPerson p=new clsPerson();
      p.FirstName = "Jeff";
      p.MI = "A";
      p.LastName = "Price";
      System.Xml.Serialization.XmlSerializer x = new System.Xml.Serialization.XmlSerializer(p.GetType());
      x.Serialize(Console.Out, p);
      Console.WriteLine();
      Console.ReadLine();
   }
}    

public string ObjectToXML(object input)
{
    try
    {
        var stringwriter = new System.IO.StringWriter();
        var serializer = new XmlSerializer(input.GetType());
        serializer.Serialize(stringwriter, input);
        return stringwriter.ToString();
    }
    catch (Exception ex)
    {
        if (ex.InnerException != null)
            ex = ex.InnerException;

        return "Could not convert: " + ex.Message;
    }
}

//Usage
var res = ObjectToXML(obj)

È necessario utilizzare le seguenti classi:

using System.IO;
using System.Xml;
using System.Xml.Serialization;