Panoramica di LINQ to XML

LINQ to XML offre un'interfaccia di programmazione XML in memoria che usa .NET Language-Integrated Query (LINQ) Framework. LINQ to XML usa le funzionalità .NET e può essere paragonato a un'interfaccia di programmazione XML DOM aggiornata e riprogettata.

XML è stato ampiamente adottato per la formattazione dei dati in una vasta gamma di contesti. Viene ad esempio usato in applicazioni Web, file di configurazione, file di Microsoft Office Word e in database.

LINQ to XML è un approccio aggiornato e riprogettato per la programmazione con XML. Fornisce le funzionalità di modifica dei documenti in memoria del Document Object Model (DOM) e supporta le espressioni di query LINQ. Sebbene sintatticamente diverse da XPath, queste espressioni di query offrono funzionalità simili.

Sviluppatori LINQ to XML

LINQ to XML è destinato a un'ampia gamma di sviluppatori. Per uno sviluppatore medio che desidera solo ottenere un risultato, LINQ to XML rende il codice XML più semplice fornendo un'esperienza di query simile a SQL. Sono poi sufficienti competenze minime per consentire a un programmatore di imparare a scrivere query potenti e meno estese nel linguaggio di programmazione desiderato.

Gli sviluppatori professionisti possono utilizzare LINQ to XML per aumentare significativamente la loro produttività. Con LINQ to XML, possono scrivere meno codice più espressivo, compatto e più potente. È inoltre possibile usare espressioni di query da più domini di dati contemporaneamente.

LINQ to XML è un'interfaccia di programmazione XML

LINQ to XML è un'interfaccia di programmazione XML in memoria, abilitata per LINQ, che consente di utilizzare XML dall'interno dei linguaggi di programmazione .NET.

LINQ to XML è simile al Document Object Model (DOM) in quanto riporta il documento XML in memoria. È quindi possibile eseguire query e modificare il documento e dopo averlo modificato salvarlo in un file o serializzarlo e inviarlo tramite Internet. Tuttavia, LINQ to XML differisce da DOM:

  • Fornisce un nuovo modello a oggetti più leggero e più semplice da usare.
  • Sfrutta i vantaggi delle funzionalità del linguaggio in C# e Visual Basic.

Il vantaggio più importante della LINQ to XML è l'integrazione con LINQ (Language-Integrated Query). Grazie a tale integrazione è possibile scrivere query sul documento XML in memoria per recuperare raccolte di elementi e di attributi. La funzionalità di query di LINQ to XML è paragonabile nelle funzionalità (sebbene non nella sintassi) a XPath e XQuery. L'integrazione di LINQ in C# e Visual Basic offre una tipizzazione più forte, il controllo in fase di compilazione e il supporto migliorato del debugger.

Un altro vantaggio di LINQ to XML è la possibilità di usare i risultati delle query come parametri dei XElement XAttribute costruttori di oggetti e consente un approccio efficace alla creazione di alberi XML. Questo approccio, chiamato costruzione funzionale consente agli sviluppatori di trasformare facilmente gli alberi XML da una forma all'altra.

Ad esempio, è possibile che si disponga di un tipico ordine di acquisto XML, come descritto in file XML di esempio: tipico ordine di acquisto. Utilizzando LINQ to XML, è possibile eseguire la query seguente per ottenere il valore dell'attributo del numero di parte per ogni elemento Item nell'ordine di acquisto:

// Load the XML file from our project directory containing the purchase orders
var filename = "PurchaseOrder.xml";
var currentDirectory = Directory.GetCurrentDirectory();
var purchaseOrderFilepath = Path.Combine(currentDirectory, filename);

XElement purchaseOrder = XElement.Load(purchaseOrderFilepath);

IEnumerable<string> partNos =  from item in purchaseOrder.Descendants("Item")
                               select (string) item.Attribute("PartNumber");
' Load the XML file from our project directory containing the purchase orders
Dim filename = "PurchaseOrder.xml"
Dim currentDirectory = Directory.GetCurrentDirectory()
Dim purchaseOrderFilepath = Path.Combine(currentDirectory, filename)

Dim purchaseOrder As XElement = XElement.Load(purchaseOrderFilepath)

Dim partNos = _
    From item In purchaseOrder...<Item> _
    Select item.@PartNumber

In C# questo può essere riscritto nel formato di sintassi del metodo:

IEnumerable<string> partNos = purchaseOrder.Descendants("Item").Select(x => (string) x.Attribute("PartNumber"));

Si supponga ancora, ad esempio, di voler creare un elenco, ordinato in base al numero di parte, degli articoli il cui valore è maggiore di 100 dollari. Per ottenere queste informazioni, è possibile eseguire la query seguente:

// Load the XML file from our project directory containing the purchase orders
var filename = "PurchaseOrder.xml";
var currentDirectory = Directory.GetCurrentDirectory();
var purchaseOrderFilepath = Path.Combine(currentDirectory, filename);

XElement purchaseOrder = XElement.Load(purchaseOrderFilepath);

IEnumerable<XElement> pricesByPartNos =  from item in purchaseOrder.Descendants("Item")
                                 where (int) item.Element("Quantity") * (decimal) item.Element("USPrice") > 100
                                 orderby (string)item.Element("PartNumber")
                                 select item;
' Load the XML file from our project directory containing the purchase orders
Dim filename = "PurchaseOrder.xml"
Dim currentDirectory = Directory.GetCurrentDirectory()
Dim purchaseOrderFilepath = Path.Combine(currentDirectory, filename)

Dim purchaseOrder As XElement = XElement.Load(purchaseOrderFilepath)

Dim partNos = _
From item In purchaseOrder...<Item> _
Where (item.<Quantity>.Value * _
       item.<USPrice>.Value) > 100 _
Order By item.<PartNumber>.Value _
Select item

Anche in questo caso, in C# questo può essere riscritto nel formato di sintassi del metodo:

IEnumerable<XElement> pricesByPartNos = purchaseOrder.Descendants("Item")
                                        .Where(item => (int)item.Element("Quantity") * (decimal)item.Element("USPrice") > 100)
                                        .OrderBy(order => order.Element("PartNumber"));

Oltre a queste funzionalità LINQ, LINQ to XML fornisce un'interfaccia di programmazione XML migliorata. Con LINQ to XML è possibile:

  • Caricare XML da file o flussi.
  • Serializzare codice XML in file o flussi.
  • Creare codice XML nuovo usando la costruzione funzionale.
  • Eseguire una query su codice XML usando assi simili a XPath.
  • Modificare l'albero XML in memoria usando metodi quali esempio Add, Remove, ReplaceWithe SetValue.
  • Convalidare alberi XML usando lo schema XSD.
  • Usare una combinazione di queste funzionalità per trasformare strutture ad albero XML da una forma in un altra.

Creazione di strutture ad albero XML

Uno dei vantaggi più significativi della programmazione con LINQ to XML è che è facile creare alberi XML. Ad esempio, per creare un piccolo albero XML, è possibile scrivere il codice seguente:

XElement contacts =
new XElement("Contacts",
    new XElement("Contact",
        new XElement("Name", "Patrick Hines"),
        new XElement("Phone", "206-555-0144",
            new XAttribute("Type", "Home")),
        new XElement("phone", "425-555-0145",
            new XAttribute("Type", "Work")),
        new XElement("Address",
            new XElement("Street1", "123 Main St"),
            new XElement("City", "Mercer Island"),
            new XElement("State", "WA"),
            new XElement("Postal", "68042")
        )
    )
);
Dim contacts As XElement = _
    <Contacts>
        <Contact>
            <Name>Patrick Hines</Name>
            <Phone>206-555-0144</Phone>
            <Address>
                <Street1>123 Main St</Street1>
                <City>Mercer Island</City>
                <State>WA</State>
                <Postal>68042</Postal>
            </Address>
        </Contact>
    </Contacts>

Nota

La versione Visual Basic dell'esempio usa i valori letterali XML. È anche possibile usare XElement in Visual Basic, come nella versione C#.

Per altre informazioni, vedere strutture ad albero XML.

Vedere anche