Làm cách nào để tôi giải nén tài liệu XML này:

<?xml version="1.0" encoding="utf-8"?>
<Cars>
  <Car>
    <StockNumber>1020</StockNumber>
    <Make>Nissan</Make>
    <Model>Sentra</Model>
  </Car>
  <Car>
    <StockNumber>1010</StockNumber>
    <Make>Toyota</Make>
    <Model>Corolla</Model>
  </Car>
  <Car>
    <StockNumber>1111</StockNumber>
    <Make>Honda</Make>
    <Model>Accord</Model>
  </Car>
</Cars>

Tôi có cái này:

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

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

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

.

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

}

.

public class CarSerializer
{
    public Cars Deserialize()
    {
        Cars[] cars = null;
        string path = HttpContext.Current.ApplicationInstance.Server.MapPath("~/App_Data/") + "cars.xml";

        XmlSerializer serializer = new XmlSerializer(typeof(Cars[]));

        StreamReader reader = new StreamReader(path);
        reader.ReadToEnd();
        cars = (Cars[])serializer.Deserialize(reader);
        reader.Close();

        return cars;
    }
}

điều đó dường như không hoạt động :-(

Đây là một phiên bản làm việc. Tôi đã thay đổi XmlElementAttributenhãn thành XmlElementvì trong xml, các giá trị StockNumber, Make và Model là các phần tử, không phải thuộc tính. Ngoài ra, tôi đã xóa reader.ReadToEnd();( hàm đó đọc toàn bộ luồng và trả về một chuỗi, vì vậy Deserialize()hàm không thể sử dụng trình đọc nữa ... vị trí nằm ở cuối luồng). Tôi cũng mất một vài tự do với việc đặt tên :).

Dưới đây là các lớp:

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

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

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


[Serializable()]
[System.Xml.Serialization.XmlRoot("CarCollection")]
public class CarCollection
{
    [XmlArray("Cars")]
    [XmlArrayItem("Car", typeof(Car))]
    public Car[] Car { get; set; }
}

Hàm Deserialize:

CarCollection cars = null;
string path = "cars.xml";

XmlSerializer serializer = new XmlSerializer(typeof(CarCollection));

StreamReader reader = new StreamReader(path);
cars = (CarCollection)serializer.Deserialize(reader);
reader.Close();

Và xml được điều chỉnh một chút (tôi cần thêm một yếu tố mới để bọc <Ô tô> ... Net rất kén chọn mảng khử lưu huỳnh):

<?xml version="1.0" encoding="utf-8"?>
<CarCollection>
<Cars>
  <Car>
    <StockNumber>1020</StockNumber>
    <Make>Nissan</Make>
    <Model>Sentra</Model>
  </Car>
  <Car>
    <StockNumber>1010</StockNumber>
    <Make>Toyota</Make>
    <Model>Corolla</Model>
  </Car>
  <Car>
    <StockNumber>1111</StockNumber>
    <Make>Honda</Make>
    <Model>Accord</Model>
  </Car>
</Cars>
</CarCollection>

Còn về việc bạn chỉ cần lưu xml vào một tệp và sử dụng xsd để tạo các lớp C # thì sao?

1. Ghi tệp vào đĩa (Tôi đặt tên là foo.xml)
2. Tạo xsd: xsd foo.xml
3. Tạo C #: xsd foo.xsd /classes

Et voila - và tệp mã C # có thể đọc dữ liệu qua XmlSerializer:

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

(bao gồm các foo.cs được tạo trong dự án)

Bạn có hai khả năng.

Phương pháp 1. Công cụ XSD

1. Mở dấu nhắc lệnh nhà phát triển
   Bạn có thể tìm thấy nó trong Start Menu > Programs > Microsoft Visual Studio 2012 > Visual Studio Tools Hoặc nếu bạn có Windows 8, bạn chỉ cần bắt đầu nhập Dấu nhắc lệnh của nhà phát triển trong màn hình Bắt đầu
2. Thay đổi vị trí vào thư mục tệp XML của bạn bằng cách nhập cd /D "C:\path\to\xml"
3. Tạo tệp XSD từ tệp xml của bạn bằng cách nhậpxsd file.xml
4. Tạo các lớp C # bằng cách gõxsd /c file.xsd

Và đó là nó! Bạn đã tạo các lớp C # từ tệp xml trongC:\path\to\xml\file.cs

Phương pháp 2 - Dán đặc biệt

1. Sao chép nội dung tệp XML của bạn vào khay nhớ tạm
2. Thêm vào giải pháp của bạn tập tin lớp mới, trống ( Shift+ Alt+ C)
3. Mở tập tin đó và trong menu bấm vào Edit > Paste special > Paste XML As Classes
   

Và đó là nó!

Sử dụng

Cách sử dụng rất đơn giản với lớp người trợ giúp này:

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

Tất cả bạn phải làm bây giờ, là:

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

Đoạn mã sau nên thực hiện thủ thuật (và bạn có thể bỏ qua hầu hết các thuộc tính tuần tự hóa):

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

Xem nếu điều này giúp:

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

Và không sử dụng chương trình xsd.exe đi kèm với visual studio để tạo tài liệu lược đồ dựa trên tệp xml đó, sau đó sử dụng lại để tạo một lớp dựa trên tài liệu lược đồ.

Tôi không nghĩ .net là 'kén chọn về việc giải nén các mảng'. Tài liệu xml đầu tiên không được hình thành tốt. Không có yếu tố gốc, mặc dù có vẻ như có. Tài liệu xml chính tắc có gốc và ít nhất 1 phần tử (nếu có). Trong ví dụ của bạn:

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

hãy thử khối mã này nếu tệp .xml của bạn đã được tạo ở đâu đó trong đĩa và nếu bạn đã sử dụng 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();`

Lưu ý: C:\serialize.xmllà đường dẫn tệp .xml của tôi. Bạn có thể thay đổi nó cho nhu cầu của bạn.

Anser của Kevin là tốt, ngoài thực tế, rằng trong thế giới thực, bạn thường không thể thay đổi XML gốc cho phù hợp với nhu cầu của bạn.

Cũng có một giải pháp đơn giản cho XML gốc:

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

Và sau đó bạn có thể chỉ cần gọi:

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

Hãy thử Lớp chung này để xê-ri hóa và giải tuần tự 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;
    }
}

Cho những người mới bắt đầu

Tôi thấy các câu trả lời ở đây rất hữu ích, điều đó nói rằng tôi vẫn cố gắng (chỉ một chút) để làm việc này. Vì vậy, trong trường hợp nó giúp được ai đó tôi sẽ đánh vần giải pháp làm việc:

XML từ Câu hỏi gốc. Xml nằm trong tệp Class1.xml, a pathđến tệp này được sử dụng trong mã để định vị tệp xml này.

Tôi đã sử dụng câu trả lời của @erymski để làm việc này, vì vậy đã tạo một tệp có tên Car.cs và thêm vào như sau:

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

Một đoạn mã khác được cung cấp bởi @erymski ...

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

... đi vào chương trình chính của bạn (Program.cs), static CarCollection XCar()như thế này:

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

Hy vọng nó giúp :-)

Làm thế nào về một lớp chung để giải tuần tự hóa một tài liệu 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;
}

Phần này có thể, hoặc có thể không cần thiết. Mở tài liệu XML trong Visual Studio, nhấp chuột phải vào XML, chọn thuộc tính. Sau đó chọn tệp lược đồ của bạn.

Lót:

var object = (Cars)new XmlSerializer(typeof(Cars)).Deserialize(new StringReader(xmlString));

Ý tưởng là để tất cả các cấp được xử lý để khử lưu huỳnh Vui lòng xem một giải pháp mẫu giải quyết vấn đề tương tự của tôi

<?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> 

XML ở trên được xử lý ở hai cấp độ

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

}

Cấp độ bên trong

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

}

Cùng một cách bạn cần nhiều cấp độ với car as array Kiểm tra ví dụ này để khử lưu lượng đa cấp

Nếu bạn gặp lỗi khi sử dụng xsd.exe để tạo tệp xsd của mình, thì hãy sử dụng lớp XmlSchemaInference như đã đề cập trên msdn . Đây là một bài kiểm tra đơn vị để chứng minh:

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

Bạn chỉ có thể thay đổi một thuộc tính cho bạn Thuộc tính xe ô tô từ XmlArrayItem sang XmlElment. Đó là, từ

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

đến

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

Giải pháp của tôi:

1. Sử dụng Edit > Past Special > Paste XML As Classes để có được lớp trong mã của bạn
2. Hãy thử một cái gì đó như thế này: tạo một danh sách của lớp đó ( List<class1>), sau đó sử dụng XmlSerializerđể tuần tự hóa danh sách đó thành một xmltệp.
3. Bây giờ bạn chỉ cần thay thế phần thân của tệp đó bằng dữ liệu của bạn và thử deserializenó.

Mã số:

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

LƯU Ý: bạn phải chú ý đến tên gốc, đừng thay đổi nó. Của tôi là "ArrayOfClass1"

async public static Task<JObject> XMLtoNETAsync(XmlDocument ToConvert)
{
    //Van XML naar JSON
    string jsonText = await Task.Run(() => JsonConvert.SerializeXmlNode(ToConvert));

    //Van JSON naar .net object
    var o = await Task.Run(() => JObject.Parse(jsonText));

    return o;
}