Atomized XName- en XNamespace-objecten (LINQ naar XML)

XName en XNamespace objecten worden ge atomiseerd. Als ze dezelfde gekwalificeerde naam bevatten, verwijzen ze naar hetzelfde object. Dit levert prestatievoordelen op voor query's: wanneer u twee atomiseerde namen vergelijkt voor gelijkheid, hoeft de onderliggende tussenliggende taal alleen te bepalen of de twee verwijzingen naar hetzelfde object verwijzen. De onderliggende code hoeft geen tekenreeksvergelijkingen uit te voeren, wat langer duurt.

Semantiek van atomen

Atomisatie betekent dat als twee XName objecten dezelfde lokale naam hebben en zich in dezelfde naamruimte bevinden, ze hetzelfde exemplaar delen. Op dezelfde manier, als twee XNamespace objecten dezelfde naamruimte-URI hebben, delen ze hetzelfde exemplaar.

Om een klasse geatomiseerde objecten in te laten schakelen, moet de constructor voor de klasse privé zijn, niet publiek. Dit komt doordat als de constructor openbaar was, u een niet-atomiseerd object kunt maken. De XName en XNamespace klassen implementeren een impliciete conversieoperator om een tekenreeks te converteren naar een XName of XNamespace. Dit is hoe u een exemplaar van deze objecten krijgt. U kunt geen instantie krijgen met behulp van een constructor, omdat de constructor niet toegankelijk is.

XName en XNamespace implementeer ook de gelijkheids- en ongelijkheidsoperators, die bepalen of de twee objecten die worden vergeleken verwijzingen naar hetzelfde exemplaar zijn.

Voorbeeld: Objecten maken en weergeven dat identieke namen een exemplaar delen

Met de volgende code worden enkele XElement objecten gemaakt en wordt gedemonstreert dat identieke namen hetzelfde exemplaar delen.

var r1 = new XElement("Root", "data1");
XElement r2 = XElement.Parse("<Root>data2</Root>");

if ((object)r1.Name == (object)r2.Name)
    Console.WriteLine("r1 and r2 have names that refer to the same instance.");
else
    Console.WriteLine("Different");

XName n = "Root";

if ((object)n == (object)r1.Name)
    Console.WriteLine("The name of r1 and the name in 'n' refer to the same instance.");
else
    Console.WriteLine("Different");

Dim r1 As New XElement("Root", "data1")
Dim r2 As XElement = XElement.Parse("<Root>data2</Root>")

If DirectCast(r1.Name, Object) = DirectCast(r2.Name, Object) Then
    Console.WriteLine("r1 and r2 have names that refer to the same instance.")
Else
    Console.WriteLine("Different")
End If

Dim n As XName = "Root"

If DirectCast(n, Object) = DirectCast(r1.Name, Object) Then
    Console.WriteLine("The name of r1 and the name in 'n' refer to the same instance.")
Else
    Console.WriteLine("Different")
End If

In dit voorbeeld wordt de volgende uitvoer gegenereerd:

r1 and r2 have names that refer to the same instance.
The name of r1 and the name in 'n' refer to the same instance.

Zoals eerder vermeld, is het voordeel van atomiseerde objecten dat wanneer u een van de asmethoden gebruikt die een XName parameter gebruiken, de asmethode alleen moet bepalen dat twee namen verwijzen naar hetzelfde exemplaar om de gewenste elementen te selecteren.

In het volgende voorbeeld wordt een XName doorgegeven aan de Descendants methodeaanroep, wat leidt tot betere prestaties vanwege het atomisatiepatroon.

var root = new XElement("Root",
    new XElement("C1", 1),
    new XElement("Z1",
        new XElement("C1", 2),
        new XElement("C1", 1)
    )
);

var query = from e in root.Descendants("C1")
            where (int)e == 1
            select e;

foreach (var z in query)
    Console.WriteLine(z);

Dim root As New XElement("Root", New XElement("C1", 1), New XElement("Z1", New XElement("C1", 2), New XElement("C1", 1)))

Dim query = From e In root.Descendants("C1") Where CInt(e) = 1

For Each z In query
    Console.WriteLine(z)
Next

In dit voorbeeld wordt de volgende uitvoer gegenereerd:

<C1>1</C1>
<C1>1</C1>