Atomiserade XName- och XNamespace-objekt (LINQ till XML)

XName och XNamespace objekt är atomiserade. Om de innehåller samma kvalificerade namn refererar de till samma objekt. Detta ger prestandafördelar för frågor: när du jämför två atomiserade namn för likhet behöver det underliggande mellanliggande språket bara avgöra om de två referenserna pekar på samma objekt. Den underliggande koden behöver inte göra strängjämförelser, vilket skulle ta längre tid.

Atomiseringssemantik

Atomisering innebär att om två XName objekt har samma lokala namn och de är i samma namnområde delar de samma instans. På samma sätt, om två XNamespace objekt har samma namnområdes-URI, delar de samma instans.

För att en klass ska kunna aktivera atomiserade objekt måste konstruktorn för klassen vara privat, inte offentlig. Det beror på att om konstruktorn var offentlig kan du skapa ett icke-atomiserat objekt. Klasserna XName och XNamespace implementerar en implicit konverteringsoperator för att konvertera en sträng till en XName eller XNamespace. Så här får du en instans av dessa objekt. Du kan inte hämta en instans med hjälp av en konstruktor eftersom konstruktorn inte är tillgänglig.

XName och XNamespace även implementera likhets- och ojämlikhetsoperatorerna, som avgör om de två objekt som jämförs är referenser till samma instans.

Exempel: Skapa objekt och visa att identiska namn delar en instans

Följande kod skapar vissa XElement objekt och visar att identiska namn delar samma instans.

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

Det här exemplet genererar följande utdata:

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.

Som tidigare nämnts är fördelen med atomiserade objekt att när du använder en av axelmetoderna som tar en XName som en parameter, behöver axelmetoden bara fastställa att två namn refererar till samma instans för att välja önskade element.

I följande exempel skickas ett XName till metodanropet Descendants , som sedan har bättre prestanda på grund av atomiseringsmönstret.

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

Det här exemplet genererar följande utdata:

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