Condividi tramite

Panoramica di LINQ to XML

LINQ to XML fornisce un'interfaccia di programmazione XML in memoria che sfrutta il framework LINQ (.NET Language-Integrated Query). LINQ to XML usa funzionalità .NET ed è paragonabile a un'interfaccia di programmazione XML DOM (Document Object Model) aggiornata e riprogettata.

XML è stato ampiamente adottato come modo per formattare i dati in molti contesti. Ad esempio, è possibile trovare xml sul Web, nei file di configurazione, nei file di Microsoft Office Word e nei database.

LINQ to XML è un approccio up-to-date riprogettato alla 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. Anche se queste espressioni di query sono sintatticamente diverse da XPath, forniscono funzionalità simili.

Sviluppatori di 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 l'xml offrendo un'esperienza di query simile a SQL. Con un po' di studio, i programmatori possono imparare a scrivere query concise e potenti nel linguaggio di programmazione preferito.

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. Possono usare espressioni di query da più domini 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 DOM (Document Object Model) in quanto porta il documento XML in memoria. È possibile eseguire query e modificare il documento e, dopo averlo modificato, è possibile salvarlo in un file o serializzarlo e inviarlo tramite Internet. Tuttavia, LINQ to XML è diverso da DOM:

  • Fornisce un nuovo modello di oggetti, più leggero e 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). Questa integrazione consente di scrivere query nel documento XML in memoria per recuperare raccolte di elementi e 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 più avanzate, 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 alberi XML da una forma a un'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 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"));

Come un altro esempio, si potrebbe volere un elenco, ordinato in base al numero di parte, degli elementi con un valore maggiore di $100. 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 offre un'interfaccia di programmazione XML migliorata. Usando LINQ to XML, è possibile:

  • Carica XML da file o flussi.
  • Serializzare XML su file o flussi.
  • Creare codice XML da zero usando la costruzione funzionale.
  • Interrogare XML utilizzando assi in stile XPath.
  • Modificare l'albero XML in memoria usando metodi come Add, RemoveReplaceWith, e SetValue.
  • Convalidare alberi XML usando XSD.
  • Utilizzare una combinazione di queste funzionalità per trasformare alberi XML da una forma a 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 codice come segue:

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>

Annotazioni

La versione di 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.

Vedere anche