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 alla programmazione con XML. Fornisce le funzionalità di modifica dei documenti in memoria del modello DOM (Document Object Model) e supporta le espressioni di query LINQ. Sebbene sintatticamente diverse da XPath, queste espressioni di query offrono funzionalità simili.

LINQ to XML sviluppatori

LINQ to XML è destinato a un'ampia gamma di sviluppatori. Per uno sviluppatore medio che vuole eseguire un'operazione, LINQ to XML semplifica l'xml offrendo 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.

Professional gli sviluppatori possono usare LINQ to XML per aumentare notevolmente la produttività. Con LINQ to XML, possono scrivere meno codice più espressivo, più 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 usare XML all'interno dei linguaggi di programmazione .NET.

LINQ to XML è simile al DOM (Document Object Model) in quanto porta 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ù facile da usare.
  • Sfrutta le funzionalità del linguaggio in C# e Visual Basic.

Il vantaggio più importante di LINQ to XML è l'integrazione con Language-Integrated Query (LINQ). 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 alle funzionalità (anche se non nella sintassi) a XPath e XQuery. L'integrazione di LINQ in C# e Visual Basic offre funzionalità di digitazione, controllo in fase di compilazione e supporto migliorato del debugger.

Un altro vantaggio di LINQ to XML è la possibilità di usare i risultati delle query come parametri per XElement i costruttori di oggetti e XAttribute 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, potrebbe essere presente un tipico ordine di acquisto XML, come descritto in File XML di esempio: ordine di acquisto tipico. Usando LINQ to XML, è possibile eseguire la query seguente per ottenere il valore dell'attributo del numero di parte per ogni elemento dell'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 della 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 C# questo può essere riscritto nel formato della 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. Usando 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.

Creare alberi 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 valori letterali XML. È anche possibile usare XElement in Visual Basic, come nella versione C#.

Per altre informazioni, vedere Alberi XML.

Vedi anche