Implizit typisierte lokale Variablen (C#-Programmierhandbuch)

Aktualisiert: Juli 2008

Lokale Variablen können einen abgeleiteten "Typ" von var statt eines expliziten Typs erhalten. Das var-Schlüsselwort weist den Compiler an, den Typ der Variable aus dem Ausdruck an der rechten Seite der Initialisierungsanweisung abzuleiten. Beim abgeleiteten Typ kann es sich um einen integrierten Typ, einen anonymen Typ, einen benutzerdefinierten Typ oder einen in der .NET Framework-Klassenbibliothek definierten Typ handeln. Weitere Informationen zum Initialisieren von Arrays mit var finden Sie unter Implizit typisierte Arrays (C#-Programmierhandbuch).

In den folgenden Beispielen werden verschiedene Methoden veranschaulicht, mit denen lokale Variablen mit var deklariert werden können:

// i is compiled as an int
var i = 5;

// s is compiled as a string
var s = "Hello";

// a is compiled as int[]
var a = new[] { 0, 1, 2 };

// expr is compiled as IEnumerable<Customer>
// or perhaps IQueryable<Customer>
var expr =
    from c in customers
    where c.City == "London"
    select c;

// anon is compiled as an anonymous type
var anon = new { Name = "Terry", Age = 34 };

// list is compiled as List<int>                             
var list = new List<int>();

Beachten Sie, dass das var-Schlüsselwort nicht für "variant" steht und damit nicht festgelegt wird, dass die Variable lose typisiert oder spät gebunden ist. Es bedeutet nur, dass der Compiler den am besten geeigneten Typ bestimmt und zuweist.

Das var-Schlüsselwort kann in den folgenden Kontexten verwendet werden:

• Für lokale Variablen (bei Methodenbereich deklarierte Variablen), wie im vorherigen Beispiel gezeigt.

• In einer for-Initialisierungsanweisung.

  for(var x = 1; x < 10; x++)
  

• In einer foreach-Initialisierungsanweisung.

  foreach(var item in list){...}
  

• In einer using-Anweisung.

  using (var file = new StreamReader("C:\\myfile.txt")) {...}
  

Weitere Informationen finden Sie unter Gewusst wie: Verwenden von implizit typisierten lokalen Variablen und Arrays in einem Abfrageausdruck (C#-Programmierhandbuch).

var und anonyme Typen

In vielen Fällen ist die Verwendung von var optional und nur ein syntaktisches Hilfsmittel. Bei der Initialisierung einer Variablen mit einem anonymen Typ muss diese Variable jedoch als var deklariert werden, wenn auf die Eigenschaften des Objekts später zugegriffen werden muss. Dies ist ein allgemeines Szenario in LINQ-Abfrageausdrücken. Weitere Informationen finden Sie unter Anonyme Typen (C#-Programmierhandbuch).

Vom Quellcode aus betrachtet hat ein anonymer Typ keinen Namen. Wenn eine Abfragevariable daher mit var initialisiert wurde, kann auf die Eigenschaften in der zurückgegebenen Folge von Objekten nur unter Verwendung von var als Typ der Iterationsvariable in der foreach-Anweisung zugegriffen werden.

class ImplicitlyTypedLocals2
{
    static void Main()
    {            
        string[] words = { "aPPLE", "BlUeBeRrY", "cHeRry" };

        // If a query produces a sequence of anonymous types, 
        // then use var in the foreach statement to access the properties.
        var upperLowerWords =
             from w in words
             select new { Upper = w.ToUpper(), Lower = w.ToLower() };

        // Execute the query
        foreach (var ul in upperLowerWords)
        {
            Console.WriteLine("Uppercase: {0}, Lowercase: {1}", ul.Upper, ul.Lower);
        }
    }        
}
/* Outputs:
    Uppercase: APPLE, Lowercase: apple
    Uppercase: BLUEBERRY, Lowercase: blueberry
    Uppercase: CHERRY, Lowercase: cherry        
 */

Hinweise

Die folgenden Beschränkungen gelten für implizit typisierte Variablendeklarationen:

• var kann nur verwendet werden, wenn eine lokale Variable in der gleichen Anweisung deklariert und initialisiert wird. Die Variable kann nicht mit NULL oder einer Methodengruppe bzw. einer anonymen Funktion initialisiert werden.

• var kann nicht für Felder im Klassengültigkeitsbereich verwendet werden.

• Variablen, die mit var deklariert werden, können nicht im Initialisierungsausdruck verwendet werden. Anders ausgedrückt, ist der Ausdruck int i = (i = 20); gültig, während der Ausdruck var i = (i = 20); einen Kompilierungsfehler verursacht.

• Mehrere implizit typisierte Variablen können nicht in der gleichen Anweisung initialisiert werden.

• Wenn sich ein Typ mit der Bezeichnung var im Bereich befindet, wird das var-Schlüsselwort zu diesem Typnamen aufgelöst und nicht als Teil einer implizit typisierten lokalen Variablendeklaration aufgefasst.

Möglicherweise stellen Sie fest, dass var auch bei Abfrageausdrücken nützlich sein kann, in denen der exakte konstruierte Typ der Abfragevariable nur schwer bestimmt werden kann. Dies kann beim Gruppieren und Sortieren von Operationen auftreten.

Das var-Schlüsselwort kann auch nützlich sein, wenn der spezifische Typ der Variable nur mühsam mit der Tastatur eingegeben werden kann, oder wenn er offensichtlich ist bzw. nicht zur Lesbarkeit des Codes beiträgt. Ein Beispiel, in dem var auf diese Weise nützlich ist, sind geschachtelte Typen, z. B. solche, die mit Gruppenoperationen verwendet werden. In der folgenden Abfrage ist der Typ dieser Variable IEnumerable<IGrouping<string, Student>>. Solange Sie und andere, die Ihren Code verwalten müssen, sich dessen bewusst sind, steht dem Verwenden der impliziten Typisierung aus Gründen der Einfachheit und der Kürze nichts im Weg.

// Same as previous example except we use the entire last name as a key.
// Query variable is an IEnumerable<IGrouping<string, Student>>
 var studentQuery3 =
     from student in students
     group student by student.Last;

Der Einsatz von var kompliziert jedoch potenziell Ihren Code, sodass andere Entwickler ihn nur schwer nachvollziehen können. Aus diesem Grund wird in der C#-Dokumentation var im Allgemeinen nur verwendet, wenn es erforderlich ist.

Siehe auch

Aufgaben

Gewusst wie: Verwenden von implizit typisierten lokalen Variablen und Arrays in einem Abfrageausdruck (C#-Programmierhandbuch)

Konzepte

LINQ-Abfrageausdrücke (C#-Programmierhandbuch)

Referenz

Implizit typisierte Arrays (C#-Programmierhandbuch)

Anonyme Typen (C#-Programmierhandbuch)

Objekt- und Auflistungsinitialisierer (C#-Programmierhandbuch)

var (C#-Referenz)

for (C#-Referenz)

foreach, in (C#-Referenz)

using-Anweisung (C#-Referenz)

Weitere Ressourcen

C#-Referenz

Sprachintegrierte Abfrage (Language-Integrated Query, LINQ)

Änderungsprotokoll