Może po prostu zapiszesz xml do pliku i użyjesz xsd?

1. Zapisz plik na dysk (nazwałem go foo.xml)
2. Wygeneruj XSD: xsd foo.xml
3. Wygeneruj C#: xsd foo.xsd /classes

Et voila-i plik kodu C#, który powinien być w stanie odczytać dane za pomocą XmlSerializer:

    XmlSerializer ser = new XmlSerializer(typeof(Cars));
    Cars cars;
    using (XmlReader reader = XmlReader.Create(path))
    {
        cars = (Cars) ser.Deserialize(reader);
    }

(include the generated foo.cs w projekcie)

Masz dwie możliwości.

Metoda 1. XSD narzędzie

1. Open Developer Command Prompt
   Można go znaleźć w Start Menu > Programs > Microsoft Visual Studio 2012 > Visual Studio Tools Lub jeśli masz System Windows 8, możesz po prostu zacząć wpisywać Wiersz polecenia programisty w ekran startowy
2. Zmień lokalizację w katalogu plików XML wpisując cd /D "C:\path\to\xml"
3. Utwórz plik XSD z pliku xml wpisując xsd file.xml
4. Utwórz klasy C# wpisując xsd /c file.xsd

I to wszystko! Wygenerowałeś klasy C# z pliku xml w C:\path\to\xml\file.cs

Metoda 2-wklej specjalne

1. Skopiuj zawartość pliku XML do schowka
2. Dodaj do swojego rozwiązania nowy, pusty plik klasy (Shift+Alt+C )
3. otwórz ten plik i w menu kliknij Edit > Paste special > Paste XML As Classes
   

I to wszystko!

Użycie

Użycie jest bardzo proste z tą klasą pomocniczą:

using System;
using System.IO;
using System.Web.Script.Serialization; // Add reference: System.Web.Extensions
using System.Xml;
using System.Xml.Serialization;

namespace Helpers
{
    internal static class ParseHelpers
    {
        private static JavaScriptSerializer json;
        private static JavaScriptSerializer JSON { get { return json ?? (json = new JavaScriptSerializer()); } }

        public static Stream ToStream(this string @this)
        {
            var stream = new MemoryStream();
            var writer = new StreamWriter(stream);
            writer.Write(@this);
            writer.Flush();
            stream.Position = 0;
            return stream;
        }


        public static T ParseXML<T>(this string @this) where T : class
        {
            var reader = XmlReader.Create(@this.Trim().ToStream(), new XmlReaderSettings() { ConformanceLevel = ConformanceLevel.Document });
            return new XmlSerializer(typeof(T)).Deserialize(reader) as T;
        }

        public static T ParseJSON<T>(this string @this) where T : class
        {
            return JSON.Deserialize<T>(@this.Trim());
        }
    }
}

Wszystko, co musisz teraz zrobić, to:

    public class JSONRoot
    {
        public catalog catalog { get; set; }
    }
    // ...

    string xml = File.ReadAllText(@"D:\file.xml");
    var catalog1 = xml.ParseXML<catalog>();

    string json = File.ReadAllText(@"D:\file.json");
    var catalog2 = json.ParseJSON<JSONRoot>();

Poniższy fragment powinien zadziałać (i możesz zignorować większość atrybutów serializacji):

public class Car
{
  public string StockNumber { get; set; }
  public string Make { get; set; }
  public string Model { get; set; }
}

[XmlRootAttribute("Cars")]
public class CarCollection
{
  [XmlElement("Car")]
  public Car[] Cars { get; set; }
}

...

using (TextReader reader = new StreamReader(path))
{
  XmlSerializer serializer = new XmlSerializer(typeof(CarCollection));
  return (CarCollection) serializer.Deserialize(reader);
}

Zobacz, czy to pomoże:

[Serializable()]
[System.Xml.Serialization.XmlRootAttribute("Cars", Namespace = "", IsNullable = false)]
public class Cars
{
    [XmlArrayItem(typeof(Car))]
    public Car[] Car { get; set; }
}

.

[Serializable()]
public class Car
{
    [System.Xml.Serialization.XmlElement()]
    public string StockNumber{ get; set; }

    [System.Xml.Serialization.XmlElement()]
    public string Make{ get; set; }

    [System.Xml.Serialization.XmlElement()]
    public string Model{ get; set; }
}

I w przeciwnym razie użyj xsd.program exe, który pochodzi z visual studio, aby utworzyć dokument schematu na podstawie tego pliku xml, a następnie użyć go ponownie, aby utworzyć klasę na podstawie dokumentu schematu.

Nie wydaje mi się, aby.NET był "wybredny w deserializacji tablic". Pierwszy dokument xml nie jest dobrze uformowany. Nie ma elementu głównego, chociaż wygląda na to, że istnieje. Canonical XML document ma root i co najmniej 1 element (jeśli w ogóle). W twoim przykładzie:

<Root> <-- well, the root
  <Cars> <-- an element (not a root), it being an array
    <Car> <-- an element, it being an array item
    ...
    </Car>
  </Cars>
</Root>

Spróbuj tego bloku kodu, jeśli twój .plik xml został wygenerowany gdzieś na dysku i jeśli użyłeś List<T>:

//deserialization

XmlSerializer xmlser = new XmlSerializer(typeof(List<Item>));
StreamReader srdr = new StreamReader(@"C:\serialize.xml");
List<Item> p = (List<Item>)xmlser.Deserialize(srdr);
srdr.Close();`

Uwaga: C:\serialize.xml jest mój .ścieżka pliku xml. Możesz go zmienić dla swoich potrzeb.

Kevin ' S anser jest dobry, pomijając fakt, że w prawdziwym świecie często nie jesteś w stanie zmienić oryginalnego XML do swoich potrzeb.

Jest też proste rozwiązanie dla oryginalnego XML:

[XmlRoot("Cars")]
public class XmlData
{
    [XmlElement("Car")]
    public List<Car> Cars{ get; set; }
}

public class Car
{
    public string StockNumber { get; set; }
    public string Make { get; set; }
    public string Model { get; set; }
}

I wtedy możesz po prostu zadzwonić:

var ser = new XmlSerializer(typeof(XmlData));
XmlData data = (XmlData)ser.Deserialize(XmlReader.Create(PathToCarsXml));

Spróbuj tej klasy generycznej do serializacji i deserializacji Xml.

public class SerializeConfig<T> where T : class
{
    public static void Serialize(string path, T type)
    {
        var serializer = new XmlSerializer(type.GetType());
        using (var writer = new FileStream(path, FileMode.Create))
        {
            serializer.Serialize(writer, type);
        }
    }

    public static T DeSerialize(string path)
    {
        T type;
        var serializer = new XmlSerializer(typeof(T));
        using (var reader = XmlReader.Create(path))
        {
            type = serializer.Deserialize(reader) as T;
        }
        return type;
    }
}

Chodzi o to, aby wszystkie poziomy były obsługiwane dla deserializacji Zobacz przykładowe rozwiązanie, które rozwiązało mój podobny problem

<?xml version="1.0" ?> 
 <TRANSACTION_RESPONSE>
    <TRANSACTION>
        <TRANSACTION_ID>25429</TRANSACTION_ID> 
        <MERCHANT_ACC_NO>02700701354375000964</MERCHANT_ACC_NO> 
        <TXN_STATUS>F</TXN_STATUS> 
        <TXN_SIGNATURE>a16af68d4c3e2280e44bd7c2c23f2af6cb1f0e5a28c266ea741608e72b1a5e4224da5b975909cc43c53b6c0f7f1bbf0820269caa3e350dd1812484edc499b279</TXN_SIGNATURE> 
        <TXN_SIGNATURE2>B1684258EA112C8B5BA51F73CDA9864D1BB98E04F5A78B67A3E539BEF96CCF4D16CFF6B9E04818B50E855E0783BB075309D112CA596BDC49F9738C4BF3AA1FB4</TXN_SIGNATURE2> 
        <TRAN_DATE>29-09-2015 07:36:59</TRAN_DATE> 
        <MERCHANT_TRANID>150929093703RUDZMX4</MERCHANT_TRANID> 
        <RESPONSE_CODE>9967</RESPONSE_CODE> 
        <RESPONSE_DESC>Bank rejected transaction!</RESPONSE_DESC> 
        <CUSTOMER_ID>RUDZMX</CUSTOMER_ID> 
        <AUTH_ID /> 
        <AUTH_DATE /> 
        <CAPTURE_DATE /> 
        <SALES_DATE /> 
        <VOID_REV_DATE /> 
        <REFUND_DATE /> 
        <REFUND_AMOUNT>0.00</REFUND_AMOUNT> 
    </TRANSACTION>
  </TRANSACTION_RESPONSE> 

Powyższy XML jest obsługiwany na dwóch poziomach

  [XmlType("TRANSACTION_RESPONSE")]
public class TransactionResponse
{
    [XmlElement("TRANSACTION")]
    public BankQueryResponse Response { get; set; }

}

Poziom wewnętrzny

public class BankQueryResponse
{
    [XmlElement("TRANSACTION_ID")]
    public string TransactionId { get; set; }

    [XmlElement("MERCHANT_ACC_NO")]
    public string MerchantAccNo { get; set; }

    [XmlElement("TXN_SIGNATURE")]
    public string TxnSignature { get; set; }

    [XmlElement("TRAN_DATE")]
    public DateTime TranDate { get; set; }

    [XmlElement("TXN_STATUS")]
    public string TxnStatus { get; set; }


    [XmlElement("REFUND_DATE")]
    public DateTime RefundDate { get; set; }

    [XmlElement("RESPONSE_CODE")]
    public string ResponseCode { get; set; }


    [XmlElement("RESPONSE_DESC")]
    public string ResponseDesc { get; set; }

    [XmlAttribute("MERCHANT_TRANID")]
    public string MerchantTranId { get; set; }

}

W ten sam sposób potrzebujesz wielu poziomów z car as array sprawdź ten przykład dla wielopoziomowej deserializacji

Jeśli dostajesz błędy przy użyciu xsd.exe aby utworzyć plik xsd, Użyj klasy XmlSchemaInference, jak wspomniano na msdn . Oto test jednostkowy do zademonstrowania:

using System.Xml;
using System.Xml.Schema;

[TestMethod]
public void GenerateXsdFromXmlTest()
{
    string folder = @"C:\mydir\mydata\xmlToCSharp";
    XmlReader reader = XmlReader.Create(folder + "\some_xml.xml");
    XmlSchemaSet schemaSet = new XmlSchemaSet();
    XmlSchemaInference schema = new XmlSchemaInference();

    schemaSet = schema.InferSchema(reader);


    foreach (XmlSchema s in schemaSet.Schemas())
    {
        XmlWriter xsdFile = new XmlTextWriter(folder + "\some_xsd.xsd", System.Text.Encoding.UTF8);
        s.Write(xsdFile);
        xsdFile.Close();
    }
}

// now from the visual studio command line type: xsd some_xsd.xsd /classes

Możesz po prostu zmienić jeden atrybut dla samochodów właściwości samochodu z XmlArrayItem na XmlElment. Czyli od

[System.Xml.Serialization.XmlRootAttribute("Cars", Namespace = "", IsNullable = false)]
public class Cars
{
    [XmlArrayItem(typeof(Car))]
    public Car[] Car { get; set; }
}

Do

[System.Xml.Serialization.XmlRootAttribute("Cars", Namespace = "", IsNullable = false)]
public class Cars
{
    [XmlElement("Car")]
    public Car[] Car { get; set; }
}

Moje rozwiązanie:

1. użyj Edit > Past Special > Paste XML As Classes, Aby uzyskać klasę w kodzie
2. Spróbuj czegoś takiego: Utwórz listę tej klasy (List<class1>), a następnie użyj XmlSerializer, aby serializować tę listę do pliku xml.
3. Teraz wystarczy zastąpić treść tego pliku swoimi danymi i spróbować deserialize go.

Kod:

StreamReader sr = new StreamReader(@"C:\Users\duongngh\Desktop\Newfolder\abc.txt");
XmlSerializer xml = new XmlSerializer(typeof(Class1[]));
var a = xml.Deserialize(sr);
sr.Close();

Uwaga: musisz zwracać uwagę na nazwę główną, Nie zmieniaj jej. Moje to "ArrayOfClass1"

Dla Początkujących

Odpowiedzi tutaj okazały się bardzo pomocne, to znaczy, że nadal starałem się (tylko trochę), aby to zadziałało. Tak więc, jeśli komuś to pomoże, podam rozwiązanie robocze:

XML z oryginalnego pytania. Xml znajduje się w pliku Class1.xml, a path to this file is used in the code to locate this XML file.

Użyłem odpowiedzi @ erymski, aby to zadziałało, więc utworzyłem plik o nazwie Car.cs i dodał:

using System.Xml.Serialization;  // Added

public class Car
{
    public string StockNumber { get; set; }
    public string Make { get; set; }
    public string Model { get; set; }
}

[XmlRootAttribute("Cars")]
public class CarCollection
{
    [XmlElement("Car")]
    public Car[] Cars { get; set; }
}

The inny bit kodu podany przez @erymski ...

using (TextReader reader = new StreamReader(path))
{
  XmlSerializer serializer = new XmlSerializer(typeof(CarCollection));
  return (CarCollection) serializer.Deserialize(reader);
}

... przechodzi do głównego programu (Program.cs), w static CarCollection XCar() tak:

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

namespace ConsoleApp2
{
    class Program
    {

        public static void Main()
        {
            var c = new CarCollection();

            c = XCar();

            foreach (var k in c.Cars)
            {
                Console.WriteLine(k.Make + " " + k.Model + " " + k.StockNumber);
            }
            c = null;
            Console.ReadLine();

        }
        static CarCollection XCar()
        {
            using (TextReader reader = new StreamReader(@"C:\Users\SlowLearner\source\repos\ConsoleApp2\ConsoleApp2\Class1.xml"))
            {
                XmlSerializer serializer = new XmlSerializer(typeof(CarCollection));
                return (CarCollection)serializer.Deserialize(reader);
            }
        }
    }
}

Mam nadzieję, że to pomoże: -)

Jak o klasy generycznej deserializacji dokumentu XML

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Generic class to load any xml into a class
// used like this ...
// YourClassTypeHere InfoList = LoadXMLFileIntoClass<YourClassTypeHere>(xmlFile);

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

public static T LoadXMLFileIntoClass<T>(string xmlFile)
{
    T returnThis;
    XmlSerializer serializer = new XmlSerializer(typeof(T));
    if (!FileAndIO.FileExists(xmlFile))
    {
        Console.WriteLine("FileDoesNotExistError {0}", xmlFile);
    }
    returnThis = (T)serializer.Deserialize(new StreamReader(xmlFile));
    return (T)returnThis;
}

Ta część może, ale nie musi być konieczna. Otwórz dokument XML w Visual Studio, kliknij prawym przyciskiem myszy na XML, wybierz Właściwości. Następnie wybierz plik schematu.

string employeedata = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><tag><name>test</bar></nmae>";//demo xml data
        using (TextReader sr = new StringReader(employeedata))
        {
            XmlSerializer serializer = new XmlSerializer(typeof(Employee));//pass type name in XmlSerializer constructor here
            Employee response = (Employee)serializer.Deserialize(sr);
            Console.WriteLine(response.name);
        }

[System.Xml.Serialization.XmlRoot("tag")]
public class Employee
{
    public string name { get; set; }
}