Niejawnie wpisane zmienne lokalneC# (Przewodnik programowania)Implicitly typed local variables (C# Programming Guide)

Zmienne lokalne można deklarować bez udzielania jawnego typu.Local variables can be declared without giving an explicit type. Słowo kluczowe var instruuje kompilator do wywnioskowania typu zmiennej z wyrażenia po prawej stronie instrukcji inicjującej.The var keyword instructs the compiler to infer the type of the variable from the expression on the right side of the initialization statement. Typ wnioskowany może być typem wbudowanym, typem anonimowym, typem zdefiniowanym przez użytkownika lub typem zdefiniowanym w bibliotece klas .NET Framework.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. Aby uzyskać więcej informacji na temat inicjowania tablic z var, zobacz niejawnie wpisane tablice.For more information about how to initialize arrays with var, see Implicitly Typed Arrays.

W poniższych przykładach pokazano różne sposoby deklarowania zmiennych lokalnych przy użyciu var: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>();

Ważne jest, aby zrozumieć, że słowo kluczowe var nie ma znaczenia "Variant" i nie wskazuje, że zmienna jest luźno wpisana lub późna.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. Oznacza to, że kompilator określa i przypisuje najbardziej odpowiedni typ.It just means that the compiler determines and assigns the most appropriate type.

Słowo kluczowe var może być używane w następujących kontekstach:The var keyword may be used in the following contexts:

  • W przypadku zmiennych lokalnych (zmienne zadeklarowane w zakresie metody), jak pokazano w poprzednim przykładzie.On local variables (variables declared at method scope) as shown in the previous example.

  • W instrukcji for inicjującej.In a for initialization statement.

    for (var x = 1; x < 10; x++)
    
  • W instrukcji inicjującej foreach .In a foreach initialization statement.

    foreach (var item in list) {...}
    
  • W instrukcji using .In a using statement.

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

Aby uzyskać więcej informacji, zobacz jak używać niejawnie wpisanych zmiennych lokalnych i tablic w wyrażeniu zapytania.For more information, see How to use implicitly typed local variables and arrays in a query expression.

typy var i Anonymousvar and anonymous types

W wielu przypadkach użycie var jest opcjonalne i jest tylko wygodą składni.In many cases the use of var is optional and is just a syntactic convenience. Jeśli jednak zmienna jest inicjowana z typem anonimowym, należy zadeklarować zmienną jako var, jeśli chcesz uzyskać dostęp do właściwości obiektu w późniejszym momencie.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. Jest to typowy scenariusz w wyrażeniach zapytań LINQ.This is a common scenario in LINQ query expressions. Aby uzyskać więcej informacji, zobacz Typy anonimowe.For more information, see Anonymous Types.

Z perspektywy kodu źródłowego typ anonimowy nie ma nazwy.From the perspective of your source code, an anonymous type has no name. W związku z tym, jeśli zmienna zapytania została zainicjowana przy użyciu var, jedynym sposobem uzyskania dostępu do właściwości w zwracanej sekwencji obiektów jest użycie var jako typu zmiennej iteracji w instrukcji foreach.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        
 */

UwagiRemarks

Następujące ograniczenia dotyczą deklaracji zmiennej o typie określonym niejawnie:The following restrictions apply to implicitly-typed variable declarations:

  • var można używać tylko wtedy, gdy zmienna lokalna jest zadeklarowana i zainicjowana w tej samej instrukcji; nie można zainicjować zmiennej do wartości null lub do grupy metod lub funkcji anonimowej.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.

  • nie można używać var dla pól w zakresie klasy.var cannot be used on fields at class scope.

  • Zmienne zadeklarowane za pomocą var nie mogą być używane w wyrażeniu inicjalizacji.Variables declared by using var cannot be used in the initialization expression. Innymi słowy, to wyrażenie jest dozwolone: int i = (i = 20); ale to wyrażenie powoduje błąd czasu kompilacji: 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);

  • W tej samej instrukcji nie można zainicjować wielu niejawnie wpisanych zmiennych.Multiple implicitly-typed variables cannot be initialized in the same statement.

  • Jeśli typ o nazwie var znajduje się w zakresie, wówczas słowo kluczowe var zostanie rozpoznane jako nazwa tego typu i nie będzie traktowane jako część niejawnie wpisanej deklaracji zmiennej lokalnej.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.

Niejawne wpisywanie za pomocą słowa kluczowego var może być stosowane tylko do zmiennych w zakresie metody lokalnej.Implicit typing with the var keyword can only be applied to variables at local method scope. Niejawne wpisywanie nie jest dostępne w przypadku C# pól klas, ponieważ kompilator napotyka logiczną Paradox w miarę przetwarzania kodu: kompilator musi znać typ pola, ale nie może ustalić typu do czasu przeanalizowania wyrażenia przypisania, a wyrażenia nie można ocenić bez znajomości typu.Implicit typing is not available for class fields as the C# compiler would encounter a logical paradox as it processed the code: the compiler needs to know the type of the field, but it cannot determine the type until the assignment expression is analyzed, and the expression cannot be evaluated without knowing the type. Spójrzmy na poniższy kod:Consider the following code:

private var bookTitles;

bookTitles to pole klasy, którego typ to var.bookTitles is a class field given the type var. Ponieważ pole nie ma wyrażenia do obliczenia, nie jest możliwe, aby kompilator mógł wnioskować, jakiego typu bookTitles ma być.As the field has no expression to evaluate, it is impossible for the compiler to infer what type bookTitles is supposed to be. Ponadto dodanie wyrażenia do pola (na przykład dla zmiennej lokalnej) jest również niewystarczające:In addition, adding an expression to the field (like you would for a local variable) is also insufficient:

private var bookTitles = new List<string>();

Gdy kompilator napotyka pola podczas kompilacji kodu, rejestruje każdy typ pola przed przetworzeniem skojarzonych z nim wyrażeń.When the compiler encounters fields during code compilation, it records each field's type before processing any expressions associated with it. Kompilator napotyka ten sam program Paradox, próbując przeanalizować bookTitles: musi znać typ pola, ale kompilator zwykle określa typ var, analizując wyrażenie, które nie jest możliwe bez uprzedniego poznania typu.The compiler encounters the same paradox trying to parse bookTitles: it needs to know the type of the field, but the compiler would normally determine var's type by analyzing the expression, which isn't possible without knowing the type beforehand.

Może się okazać, że var może być również przydatne w przypadku wyrażeń zapytania, w których dokładny, skonstruowany typ zmiennej zapytania jest trudny do określenia.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. Może się to zdarzyć w przypadku operacji grupowania i porządkowania.This can occur with grouping and ordering operations.

Słowo kluczowe var może być również przydatne, gdy określony typ zmiennej jest żmudnym do wpisywania na klawiaturze lub jest oczywiste lub nie dodaje do czytelności kodu.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. Przykład, w którym var jest pomocne w ten sposób, to z zagnieżdżonych typów ogólnych, takich jak te używane w przypadku operacji grupowych.One example where var is helpful in this manner is with nested generic types such as those used with group operations. W poniższym zapytaniu typ zmiennej zapytania jest IEnumerable<IGrouping<string, Student>>.In the following query, the type of the query variable is IEnumerable<IGrouping<string, Student>>. Tak długo, jak ty i inne osoby, które muszą zachować ten kod, nie występują problemy z użyciem niejawnego wpisywania dla wygody i zwięzłości.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;

Jednak użycie var ma co najmniej potencjał, aby kod był trudniejszy do zrozumienia dla innych deweloperów.However, the use of var does have at least the potential to make your code more difficult to understand for other developers. Z tego powodu dokumentacja zazwyczaj C# używa var tylko wtedy, gdy jest to wymagane.For that reason, the C# documentation generally uses var only when it is required.

Zobacz takżeSee also