Jak zdezrializować dokument XML

471

Jak usunąć deserializację tego dokumentu XML:

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

Mam to:

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

które nie działają :-(

Alex
źródło
Myślę, że musisz uciec od nawiasów kątowych w swoim przykładowym dokumencie.
harpo
4
Ta odpowiedź jest naprawdę bardzo dobra: stackoverflow.com/a/19613934/196210
Revious

Odpowiedzi:

359

Oto działająca wersja. Zmieniłem XmlElementAttributeetykiety na, XmlElementponieważ w xml wartości StockNumber, Make i Model są elementami, a nie atrybutami. Usunąłem również reader.ReadToEnd();(ta funkcja odczytuje cały strumień i zwraca ciąg znaków, więc Deserialize()funkcja nie mogła już korzystać z czytnika ... pozycja była na końcu strumienia). Wziąłem też kilka swobód z nazywaniem :).

Oto zajęcia:

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

Funkcja deserializacji:

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

I nieco poprawiony plik XML (musiałem dodać nowy element do zawijania <Cars> ... Net jest wybredny w zakresie deserializacji tablic):

<?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>
Kevin Tighe
źródło
67
[Serializable]Jest zbędny w przypadku korzystania XmlSerializer; XmlSerializerpo prostu nigdy tego nie sprawdza. Podobnie większość [Xml...]atrybutów jest zbędna, ponieważ po prostu naśladuje zachowanie domyślne; tzn. domyślnie właściwość o nazwie StockNumberjest przechowywana jako element o nazwie <StockNumber>- nie ma potrzeby do tego atrybutów.
Marc Gravell
3
Zauważ, że XmlElementAttribute = XmlElement (jest to funkcja języka, w której można pominąć przyrostek „Atrybut”). Prawdziwym rozwiązaniem jest usunięcie wywołania ReadToEnd () i dodanie węzła głównego. Ale lepiej użyj kodu erymskiego, który rozwiązuje pytanie (przeanalizuj podany xml)
Flamefire
2
Dzięki Kevin, ale co, jeśli usunę CarsCollection z przykładowego pliku XML. Usunąłem Carscollection z klas i cofnąłem kod, ale nie udało mi się.
Vikrant
441

A może po prostu zapisz plik xml w pliku i użyj xsd do wygenerowania klas C #?

  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 poprzez XmlSerializer:

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

(dołącz wygenerowany plik foo.cs do projektu)

Marc Gravell
źródło
6
Jesteś meżczyzną! Dzięki. dla każdego, kto tego potrzebuje, „ścieżka” może być Strumieniem utworzonym z odpowiedzi sieciowej, takiej jak: var resp = response.Content.ReadAsByteArrayAsync (); var stream = new MemoryStream (rel.Result);
Induster
1
Świetny pomysł, ale nie udało mi się go uruchomić w moim nieco bardziej skomplikowanym modelu z partiami zagnieżdżonych tablic. Wciąż otrzymywałem błędy konwersji typów dla zagnieżdżonych tablic - plus wygenerowany schemat nazewnictwa pozostawiał wiele do życzenia. Dlatego ostatecznie wybrałem niestandardową trasę.
GotDibbs,
9
Jak dostać się do xsd.exe
jwillmer
2
Narzędzie xsd.exe jest dostępne z wiersza polecenia programu Visual Studio, a nie z wiersza polecenia systemu Windows. Sprawdź, czy możesz otworzyć wiersz polecenia w Visual Studio w obszarze Narzędzia. Jeśli nie, spróbuj uzyskać do niego dostęp z folderu Visual Studio. W przypadku VS 2012 znajdował się tutaj: C: \ Program Files (x86) \ Microsoft Visual Studio 12.0 \ Common7 \ Tools \ Shortcuts. W Windows 8 spróbuj wyszukać „Visual Studio Tools”.
goku_da_master
2
Dla wszystkich, którzy szukają XSD. Oto wątek SO: stackoverflow.com/questions/22975031/...
SOReader,
229

Masz dwie możliwości.

Metoda 1. Narzędzie XSD


Załóżmy, że masz plik XML w tej lokalizacji C:\path\to\xml\file.xml

  1. Otwórz wiersz polecenia programisty
    Możesz 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ąć pisać wiersz polecenia programisty na ekranie Start
  2. Zmień lokalizację na katalog plików XML, wpisując cd /D "C:\path\to\xml"
  3. Utwórz plik XSD z pliku xml, wpisującxsd file.xml
  4. Utwórz klasy C # , wpisującxsd /c file.xsd

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

Metoda 2 - Wklej specjalnie


Wymagane Visual Studio 2012+

  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 kliknij menu Edit > Paste special > Paste XML As Classes
    wprowadź opis zdjęcia tutaj

I to wszystko!

Stosowanie


Użycie tej klasy pomocniczej jest bardzo proste:

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>();
Damian Drygiel
źródło
16
+1 dobra odpowiedź. Ale Paste XML As Classespolecenie jest skierowane tylko do .NET 4.5
ravy amiry
1
Jest to świetny sposób na wygenerowanie modelu, jeśli masz zainstalowany program vs2012 +. Później uruchomiłem czyszczenie kodu ReSharper, aby użyć właściwości automatycznych, a potem zrobiłem też inne porządki. Możesz wygenerować za pomocą tej metody, a następnie w razie potrzeby skopiować do starszej wersji.
Scotty.NET,
4
Kierowanie na .net4.5 nie stanowi problemu. Po prostu uruchom tymczasowy projekt za pomocą dotnet4.5, skopiuj go i wklej i skopiuj źródło do swojego projektu.
LosManos
2
gdzie jest obiekt lub klasa „katalog”?
CB4,
3
Aby „Wklej XML jako klasy” pojawił się w tym menu społeczności VS 2017, musisz mieć zainstalowany „ASP.NET i programowanie WWW”. Jeśli go brakuje, uruchom ponownie instalatora VS, aby zmodyfikować instalację.
Slion
89

Poniższy fragment kodu powinien załatwić sprawę (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);
}

źródło
14
To właściwie jedyna odpowiedź. Przyjęta odpowiedź ma kilka wad, które mogą dezorientować początkujących.
Flamefire
24

Sprawdź, 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; }
}

W przeciwnym razie korzysta z programu xsd.exe, który jest dołączony do programu 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.

Joel Coehoorn
źródło
9

Nie sądzę, że .net jest „wybredny w deserializacji tablic”. Pierwszy dokument XML nie jest poprawnie sformułowany. Nie ma elementu głównego, chociaż wygląda na to, że istnieje. Kanoniczny dokument xml ma katalog główny 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>
janbak
źródło
7

wypróbuj ten blok kodu, jeśli 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.xmlto ścieżka do mojego pliku .xml. Możesz to zmienić według własnych potrzeb.

arkuszal nainwal
źródło
6

Anser Kevina jest dobry, poza tym, że w prawdziwym świecie często nie jesteś w stanie zmienić oryginalnego XML, aby dopasować go do swoich potrzeb.

Istnieje również 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; }
}

A potem możesz po prostu zadzwonić:

var ser = new XmlSerializer(typeof(XmlData));
XmlData data = (XmlData)ser.Deserialize(XmlReader.Create(PathToCarsXml));
Kim Homann
źródło
Dzięki! Twoja odpowiedź jest dokładnie tym, czego potrzebowałem, ponieważ nie chciałem zmieniać plików dziennika o wartości gigabajtów.
Colin,
Chociaż warto wspomnieć, że rozwiązanie XmlSerializer jest bardzo eleganckie, ale co prawda również niezbyt szybkie i reaguje wrażliwie na nieoczekiwane dane Xml. Więc jeśli twój problem nie wymaga całkowitej deserializacji, powinieneś rozważyć użycie bardziej pragmatycznej i wydajnej klasy XmlReader i zapętlić elementy <Car>.
Kim Homann
5

Wypróbuj tę klasę ogólną 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;
    }
}
Hasan Javaid
źródło
4

Dla początkujących

Uznałem, że odpowiedzi tutaj są bardzo pomocne, ponieważ powiedziałem, że wciąż walczyłem (tylko trochę), aby to zadziałało. Na wypadek, gdyby to pomogło komuś, przeliteruję działające rozwiązanie:

XML z oryginalnego pytania. Plik xml znajduje się w pliku Class1.xml, apath do tego pliku użyto w kodzie, aby zlokalizować ten plik xml.

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

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

Drugi fragment kodu dostarczony przez @erymski ...

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

... przechodzi do twojego programu głównego (Program.cs), w static CarCollection XCar()następujący sposób:

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

SlowLearner
źródło
1
To zadziałało dla mnie. Jest to doskonale działające rozwiązanie dla danych wejściowych xml (jak w przykładzie OP). [XmlElement („Samochód”)] jest właściwym atrybutem. W innych przykładach używali XmlArray itp., Które nie są potrzebne, dopóki mamy właściwość zdefiniowaną jako public Car [] Cars {get; zestaw; } i poprawnie przekształciłby to z postaci szeregowej. Dzięki.
Diwakar Padmaraja
3

Co powiesz na ogólną klasę do 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 być lub może nie być konieczna. Otwórz dokument XML w Visual Studio, kliknij XML prawym przyciskiem myszy, wybierz właściwości. Następnie wybierz plik schematu.

David C Fuchs
źródło
1
To pozwoliło mi trochę zmniejszyć kod logiki biznesowej i scentralizować funkcjonalność w klasie pomocniczej ze wszystkimi wygenerowanymi przez mnie klasami <T>. Miałem już XML w ciągu, więc mógłbym go skondensować do tego: `public static T LoadXMLFileIntoClass <T> (ciąg xmlData)` {`XmlSerializer serializer = new XmlSerializer (typeof (T)); `return (T) serializer.Deserialize (new StringReader (xmlData)); `} Dzięki!
pwrgreg007
3

Jedna wkładka:

var object = (Cars)new XmlSerializer(typeof(Cars)).Deserialize(new StringReader(xmlString));
Andre M.
źródło
2

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

}

Taki sam sposób, w jaki potrzebujesz wielu poziomów z car as array Sprawdź ten przykład dla deserializacji wielopoziomowej

makdu
źródło
1

Jeśli otrzymujesz błędy przy użyciu xsd.exe do utworzenia pliku xsd, użyj klasy XmlSchemaInference, jak wspomniano w msdn . Oto test jednostkowy w celu wykazania:

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
goku_da_master
źródło
1

Możesz po prostu zmienić jeden atrybut właściwości samochodu Cars z XmlArrayItem na XmlElment. To znaczy, z

[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; }
}
XU Weijiang
źródło
1

Moje rozwiązanie:

  1. Użyj, Edit > Past Special > Paste XML As Classesaby uzyskać klasę w kodzie
  2. Spróbuj czegoś takiego: utwórz listę tej klasy ( List<class1>), a następnie użyj XmlSerializerdo serializacji tej listy do xmlpliku.
  3. Teraz wystarczy zastąpić treść tego pliku swoimi danymi i spróbować deserialize.

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 zwrócić uwagę na nazwę katalogu głównego, nie zmieniaj jej. Mój jest „ArrayOfClass1”

haiduong87
źródło
1
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;
}
Zoidbergseasharp
źródło
1
Proszę zawsze umieszczać odpowiedź w kontekście zamiast wklejać kod. Zobacz tutaj po więcej szczegółów.
gehbiszumeis