Implizit typisierte lokale Variablen (C#-Programmierhandbuch)Implicitly Typed Local Variables (C# Programming Guide)

Lokale Variablen können deklariert werden, ohne einen expliziten Typ anzugeben.Local variables can be declared without giving an explicit type. Das var-Schlüsselwort weist den Compiler an, den Typ der Variablen vom Ausdruck auf der rechten Seite der Initialisierungsanweisung abzuleiten.The var keyword instructs the compiler to infer the type of the variable from the expression on the right side of the initialization statement. Der hergeleitete Typ ist möglicherweise ein integrierter Typ, ein anonymer Typ, ein benutzerdefinierter Typ oder ein Typ, der in der .NET Framework-Klassenbibliothek definiert wurde.The inferred type may be a built-in type, an anonymous type, a user-defined type, or a type defined in the .NET Framework class library. Weitere Informationen zur Initialisierung von Arrays mithilfe von var finden Sie unter Implizit typisierte Arrays.For more information about how to initialize arrays with var, see Implicitly Typed Arrays.

Die folgenden Beispiele veranschaulichen verschiedene Arten, wie Sie lokale Variablen mit var deklarieren können:The following examples show various ways in which local variables can be declared with var:

// 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>();

Es ist von großer Bedeutung zu verstehen, dass das var-Schlüsselwort nicht „variant“ bedeutet, und das es nicht darauf hinweist, dass die Variable schwach typisiert oder spät gebunden ist.It is important to understand that the var keyword does not mean "variant" and does not indicate that the variable is loosely typed, or late-bound. Es bedeutet nur, dass der Compiler den angemessensten Typen bestimmt und zuweist.It just means that the compiler determines and assigns the most appropriate type.

Das var-Schlüsselwort kann in folgendem Kontext verwendet werden:The var keyword may be used in the following contexts:

  • Für lokale Variablen (Variablen, die im Geltungsbereich der Methode deklariert wurden), wie in vorherigem Beispiel gezeigt.On local variables (variables declared at method scope) as shown in the previous example.

  • In einer for-Initialisierungsanweisung.In a for initialization statement.

    for(var x = 1; x < 10; x++)  
    
  • In einer foreach-Initialisierungsanweisung.In a foreach initialization statement.

    foreach(var item in list){...}  
    
  • In einer using-Anweisung.In a using statement.

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

Weitere Informationen finden Sie unter Vorgehensweise: Verwenden von implizit typisierten lokalen Variablen und Arrays in einem Abfrageausdruck.For more information, see How to: Use Implicitly Typed Local Variables and Arrays in a Query Expression.

var und anonyme Typenvar and Anonymous Types

In vielen Fällen ist der Einsatz von var optional und nur eine praktische Syntax.In many cases the use of var is optional and is just a syntactic convenience. Wenn eine Variable allerdings mit einem anonymen Typ initialisiert wird, müssen Sie die Variable als var deklarieren, wenn Sie zu einem späteren Zeitpunkt auf die Eigenschaften des Objekts zugreifen möchten.However, when a variable is initialized with an anonymous type you must declare the variable as var if you need to access the properties of the object at a later point. Das ist ein häufiges Szenario in LINQLINQ-Abfrageausdrücken.This is a common scenario in LINQLINQ query expressions. Weitere Informationen finden Sie unter Anonyme Typen.For more information, see Anonymous Types.

Aus der Perspektive Ihres Quellcodes hat ein anonymer Typ keinen Namen.From the perspective of your source code, an anonymous type has no name. Wenn eine Abfragevariable mit var initialisiert wurde, ist es deshalb nur möglich, auf die Eigenschaften in der zurückgegebenen Objektsequenz zuzugreifen, wenn Sie var in der foreach-Anweisung als Typen der Iterationvariablen verwenden.Therefore, if a query variable has been initialized with var, then the only way to access the properties in the returned sequence of objects is to use var as the type of the iteration variable in the foreach statement.

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        
 */

HinweiseRemarks

Die folgenden Einschränkungen gelten für implizit typisierte Variablendeklarationen:The following restrictions apply to implicitly-typed variable declarations:

  • var kann nur verwendet werden, wenn eine lokale Variable deklariert und in derselben Anweisung initialisiert wird; die Variable kann weder mit NULL noch mit einer Methodengruppe oder einer anonymen Funktion initialisiert werden.var can only be used when a local variable is declared and initialized in the same statement; the variable cannot be initialized to null, or to a method group or an anonymous function.

  • var kann nicht für Felder im Klassenbereich verwendet werden.var cannot be used on fields at class scope.

  • Variablen, die mit var deklariert wurden, können nicht im Initialisierungsausdruck verwendet werden.Variables declared by using var cannot be used in the initialization expression. Sprich, dieser Ausdruck ist gültig: int i = (i = 20);, aber dieser Ausdruck führt zu einem Kompilierzeitfehler: var i = (i = 20);In other words, this expression is legal: int i = (i = 20); but this expression produces a compile-time error: var i = (i = 20);

  • Es können nicht mehrere implizit typisierte Variablen in derselben Anweisung initialisiert werden.Multiple implicitly-typed variables cannot be initialized in the same statement.

  • Wenn sich ein Typ mit dem Namen var im Geltungsbereich befindet, löst sich das var-Schlüsselwort zu diesem Typnamen auf und wird nicht als Teil der Deklaration einer implizit typisierten lokalen Variablen behandelt.If a type named var is in scope, then the var keyword will resolve to that type name and will not be treated as part of an implicitly typed local variable declaration.

var erweist sich auch bei Abfrageausdrücken als nützlich, deren genauer konstruierter Typ der Abfragevariable schwer ermittelbar ist.You may find that var can also be useful with query expressions in which the exact constructed type of the query variable is difficult to determine. Dies kann bei Gruppierungs- und Sortierungsvorgängen auftreten.This can occur with grouping and ordering operations.

Das var-Schlüsselwort erweist sich auch als nützlich, wenn es umständlich ist, den Variablentypen mit der Tastatur einzugeben – oder wenn der Typ offensichtlich ist, oder nicht zur Lesbarkeit des Codes beiträgt.The var keyword can also be useful when the specific type of the variable is tedious to type on the keyboard, or is obvious, or does not add to the readability of the code. var ist z.B. bei geschachtelten generischen Typen wie die, die in Gruppenvorgängen verwendet werden, auf diese Weise nützlich.One example where var is helpful in this manner is with nested generic types such as those used with group operations. In der folgenden Abfrage ist der Typ der Abfragevariablen IEnumerable<IGrouping<string, Student>>.In the following query, the type of the query variable is IEnumerable<IGrouping<string, Student>>. Solange dies Ihnen und denen, die Ihren Code verwalten müssen, klar ist, spricht nichts dagegen, implizite Typisierung aus Gründen der Zweckmäßigkeit und der Kürze zu verwenden.As long as you and others who must maintain your code understand this, there is no problem with using implicit typing for convenience and brevity.

// 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;

Durch den Gebrauch von var besteht aber zumindest die Möglichkeit, dass Ihr Code für andere Entwickler schwerer zu verstehen ist.However, the use of var does have at least the potential to make your code more difficult to understand for other developers. Aus diesem Grund wird var in der C#-Dokumentation nur dann verwendet, wenn es tatsächlich erforderlich ist.For that reason, the C# documentation generally uses var only when it is required.

Siehe auchSee Also

C#-ReferenzC# Reference
Implizit typisierte ArraysImplicitly Typed Arrays
Gewusst wie: Verwenden von implizit typisierten lokalen Variablen und Arrays in einem AbfrageausdruckHow to: Use Implicitly Typed Local Variables and Arrays in a Query Expression
Anonyme TypenAnonymous Types
Objekt- und AuflistungsinitialisiererObject and Collection Initializers
varvar
LINQ-AbfrageausdrückeLINQ Query Expressions
LINQ (Language Integrated Query)LINQ (Language-Integrated Query)
forfor
foreach, inforeach, in
Using-Anweisungusing Statement