c# xmlns Converter XML String para Objeto




xml text to object c# (10)

Eu estou recebendo seqüências de caracteres XML em um soquete e gostaria de convertê-los em objetos C #.

As mensagens são da forma:

<msg>
   <id>1</id>
   <action>stop</action>
</msg>

Eu sou novo em .net, e não tenho certeza da melhor prática para realizar isso. Eu usei JAXB para Java antes, e não tinha certeza se havia algo similar, ou se isso seria tratado de uma maneira diferente.


Tente este método para converter Xml para um objeto. É feito exatamente para o que você está fazendo:

protected T FromXml<T>(String xml)
{
    T returnedXmlClass = default(T);

    try
    {
        using (TextReader reader = new StringReader(xml))
        {
            try
            {
                returnedXmlClass = 
                    (T)new XmlSerializer(typeof(T)).Deserialize(reader);
            }
            catch (InvalidOperationException)
            {
                // String passed is not XML, simply return defaultXmlClass
            }
        }
    }
    catch (Exception ex)
    {
    }

    return returnedXmlClass ;        
}

Chame-o usando este código:

YourStrongTypedEntity entity = FromXml<YourStrongTypedEntity>(YourMsgString);

public string Serialize<T>(T settings)
{
    XmlSerializer serializer = new XmlSerializer(typeof(T));
    StringWriter outStream = new StringWriter();
    serializer.Serialize(outStream, settings);
    return outStream.ToString();
}

Você precisa usar a ferramenta xsd.exe que é instalada com o SDK do Windows em um diretório semelhante a:

C:\Program Files\Microsoft SDKs\Windows\v6.0A\bin

E em computadores de 64 bits:

C:\Program Files (x86)\Microsoft SDKs\Windows\v6.0A\bin

E nos computadores com Windows 10:

C:\Program Files (x86)\Microsoft SDKs\Windows\v7.0A\bin

Na primeira execução, você usa o xsd.exe e converte seu XML de amostra em um arquivo XSD (arquivo de esquema XML):

xsd yourfile.xml

Isto dá-lhe seu yourfile.xsd , que em uma segunda etapa, você pode converter novamente usando xsd.exe em uma classe C #:

xsd yourfile.xsd /c

Isso deve dar a você um arquivo yourfile.cs que conterá uma classe C # que você pode usar para desserializar o arquivo XML que você está obtendo - algo como:

XmlSerializer serializer = new XmlSerializer(typeof(msg));
msg resultingMessage = (msg)serializer.Deserialize(new XmlTextReader("yourfile.xml"));

Deve funcionar muito bem na maioria dos casos.

Atualização: o serializador XML tomará qualquer fluxo como sua entrada - um arquivo ou um fluxo de memória ficará bem:

XmlSerializer serializer = new XmlSerializer(typeof(msg));
MemoryStream memStream = new MemoryStream(Encoding.UTF8.GetBytes(inputString));
msg resultingMessage = (msg)serializer.Deserialize(memStream);

ou use um StringReader:

XmlSerializer serializer = new XmlSerializer(typeof(msg));
StringReader rdr = new StringReader(inputString);
msg resultingMessage = (msg)serializer.Deserialize(rdr);


Apenas no caso de alguém achar isso útil:

public static class XmlConvert
{
    public static string SerializeObject<T>(T dataObject)
    {
        if (dataObject == null)
        {
            return string.Empty;
        }
        try
        {
            using (StringWriter stringWriter = new System.IO.StringWriter())
            {
                var serializer = new XmlSerializer(typeof(T));
                serializer.Serialize(stringWriter, dataObject);
                return stringWriter.ToString();
            }
        }
        catch (Exception ex)
        {
            return string.Empty;
        }
    }

    public static T DeserializeObject<T>(string xml)
         where T : new()
    {
        if (string.IsNullOrEmpty(xml))
        {
            return new T();
        }
        try
        {
            using (var stringReader = new StringReader(xml))
            {
                var serializer = new XmlSerializer(typeof(T));
                return (T)serializer.Deserialize(stringReader);
            }
        }
        catch (Exception ex)
        {
            return new T();
        }
    }
}

Você pode chamá-lo usando:

MyCustomObject myObject = new MyCustomObject();
string xmlString = XmlConvert.SerializeObject(myObject)
myObject = XmlConvert.DeserializeObject<MyCustomObject>(xmlString);

Basta executar o Visual Studio 2013 como administração ... Copie o conteúdo do arquivo Xml .. Vá para o Visual Studio 2013> Editar> Colar especial> Colar Xml como classes C # Ele criará suas classes c # de acordo com o conteúdo do arquivo Xml.


Além das outras respostas, você pode usar naturalmente a classe XmlDocument , para leitura semelhante a XML DOM, ou o XmlReader , leitor somente de avanço rápido, para fazer isso "manualmente".


Você pode gerar uma classe conforme descrito acima ou gravá-las manualmente:

[XmlRoot("msg")]
public class Message
{
    [XmlElement("id")]
    public string Id { get; set; }
    [XmlElement("action")]
    public string Action { get; set; }
}

Em seguida, você pode usar o ExtendedXmlSerializer para serializar e desserializar.

Instalação Você pode instalar o ExtendedXmlSerializer a partir do nuget ou executar o seguinte comando:

Install-Package ExtendedXmlSerializer

Serialização:

var serializer = new ConfigurationContainer().Create();
var obj = new Message();
var xml = serializer.Serialize(obj);

Desserialização

var obj2 = serializer.Deserialize<Message>(xml);

Este suporte serializador:

  • XML de desserialização do XMLSerializer padrão
  • Classe de serialização, struct, classe genérica, tipo primitivo, lista genérica e dicionário, matriz, enum
  • Classe de serialização com interface de propriedade
  • Referência circular de serialização e ID de referência
  • Desserialização da versão antiga do xml
  • Criptografia de propriedade
  • Serializador personalizado
  • Suporte XmlElementAttribute e XmlRootAttribute
  • POCO - todas as configurações (migrações, serializador personalizado ...) estão fora da classe

O ExtendedXmlSerializer suporta .NET 4.5 ou superior e .NET Core . Você pode integrá-lo com WebApi e AspCore.


Simplificando a ótima resposta de Damian,

public static T ParseXml<T>(this string value) where T : class
{
    var xmlSerializer = new XmlSerializer(typeof(T));
    using (var textReader = new StringReader(value))
    {
        return (T) xmlSerializer.Deserialize(textReader);
    }
}

Outra maneira com um avançado xsd para c # classes geração Tools: xsd2code.com. Esta ferramenta é muito útil e poderosa. Ele tem muito mais personalização do que a ferramenta xsd.exe do Visual Studio. O Xsd2Code ++ pode ser personalizado para usar Listas ou Arrays e suporta esquemas grandes com muitas instruções de Importação.

Nota de alguns recursos,

  • Gera objetos de negócios do esquema XSD ou do arquivo XML para código C # ou Visual Basic flexível.
  • Quadro de suporte 2.0 a 4.x
  • Suporte forte coleção digitada (List, ObservableCollection, MyCustomCollection).
  • Suporta propriedades automáticas.
  • Gerar métodos de leitura e gravação de XML (serialização / desserialização).
  • Suporte de ligação de dados (WPF, Xamarin).
  • WCF (atributo DataMember).
  • Suporte a codificação XML (UTF-8/32, ASCII, Unicode, Custom).
  • Caso de camelo / suporte de caso Pascal.
  • suporte a restrição ([StringLengthAttribute = true / false], [RegularExpressionAttribute = verdadeiro / falso], [RangeAttribute = verdadeiro / falso]).
  • Suporta arquivos XSD grandes e complexos.
  • Suporte do DotNet Core & Standard




xml-serialization