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 nei confronti della programmazione con XML. Offre 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.

Sviluppatori LINQ to XML

LINQ to XML è destinato a un'ampia gamma di sviluppatori. Per uno sviluppatore medio che vuole semplicemente eseguire un'operazione, LINQ to XML semplifica XML offrendo un'esperienza di query simile a quella di 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 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 dall'interno dei linguaggi di programmazione .NET.

LINQ to XML è simile al modello 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 è diverso 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 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 a livello di funzionalità, anche se non nella sintassi, a quella di XPath e XQuery. L'integrazione di LINQ in C# e Visual Basic offre funzionalità di digitazione più avanzate, controllo in fase di compilazione e supporto migliorato del debugger.

Un altro vantaggio di LINQ to XML è che la possibilità di usare i risultati delle query come parametri per i costruttori di oggetti XElement 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: Tipico ordine di acquisto. Usando LINQ to XML, è possibile eseguire la query seguente per ottenere il valore dell'attributo del numero di parte per ogni elemento 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 modulo 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

Di nuovo, in C# questo può essere riscritto nel modulo 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 offre 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>

Per altre informazioni, vedere Alberi XML.

Vedi anche

• Riferimento
• LINQ to XML e DOM
• LINQ to XML rispetto ad altre tecnologie XML
• System.Xml.Linq