Implicitně typované místní proměnné (Průvodce programováním v C#)

  • Článek
  • 2 min ke čtení

Místní proměnné lze deklarovat bez explicitního typu. Klíčové slovo instruuje kompilátor, aby odvodit typ proměnné z výrazu na pravé straně var inicializačního příkazu. Odvozený typ může být předdefinovaný typ, anonymní typ, uživatelem definovaný typ nebo typ definovaný v knihovně tříd .NET. Další informace o inicializaci polí pomocí najdete v var tématu Implicitně typovaná pole.

Následující příklady ukazují různé způsoby, jak lze deklarovat místní proměnné pomocí 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>();

Je důležité vědět, že klíčové slovo neznamená "variantu" a neznačí, že proměnná je volně typovaná nebo s pozdní var vazbou. Znamená to jen, že kompilátor určí a přiřadí nejvhodnější typ.

Klíčové var slovo lze použít v následujících kontextech:

  • U místních proměnných (proměnných deklarovaných v oboru metody), jak je znázorněno v předchozím příkladu.

  • V příkazu pro inicializaci.

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

  • V příkazu inicializace foreach.

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

  • V příkazu using.

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

Další informace najdete v tématu Použití implicitně typovanýchmístních proměnných a polí ve výrazu dotazu .

var a anonymní typy

V mnoha případech je použití var volitelné a je pouze syntaktickou výhodou. Pokud je však proměnná inicializována s anonymním typem, musíte proměnnou deklarovat jako , pokud potřebujete přístup k vlastnostem objektu var později. Toto je běžný scénář ve výrazech dotazů LINQ. Další informace najdete v tématu Anonymní typy.

Z pohledu zdrojového kódu nemá anonymní typ žádný název. Proto pokud byla proměnná dotazu inicializována pomocí , pak je jediným způsobem, jak získat přístup k vlastnostem ve vrácené sekvenci objektů, použít jako typ iterační proměnné v var var příkazu foreach .

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

Poznámky

Následující omezení platí pro deklarace implicitně typovaných proměnných:

  • var lze použít pouze v případě, že je místní proměnná deklarována a inicializována ve stejném příkazu. Proměnnou nelze inicializovat na hodnotu null, skupinu metod nebo anonymní funkci.

  • var nelze použít u polí v oboru třídy.

  • Proměnné deklarované pomocí var nelze použít ve výrazu inicializace. Jinými slovy, tento výraz je právní: int i = (i = 20); ale tento výraz vytvoří chybu při kompilaci: var i = (i = 20);

  • Ve stejném příkazu nelze inicializovat více implicitně typovaných proměnných.

  • Pokud je typ s názvem v oboru, klíčové slovo se překládá na tento název typu a nebude považováno za součást var var implicitně typované deklarace místní proměnné.

Implicitní psaní s klíčovým var slovem lze použít pouze u proměnných v oboru místní metody. Implicitní psaní není k dispozici pro pole třídy, protože kompilátor jazyka C# by se při zpracování kódu setkal s logickým znakem: kompilátor musí znát typ pole, ale nemůže určit typ, dokud se výraz přiřazení neanalyzuje a výraz nelze vyhodnotit bez znalosti typu. Vezměme si následující kód:

private var bookTitles;

bookTitles je pole třídy daného typu var . Vzhledem k tomu, že pole nemá žádný výraz k vyhodnocení, kompilátor nemůže odvodit, jaký typ bookTitles by měl být. Přidání výrazu do pole (stejně jako u místní proměnné) navíc nestačí:

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

Když kompilátor při kompilaci kódu narazí na pole, zaznamená typ každého pole před zpracováním libovolných výrazů, které jsou k tomuto poli přidruženy. Kompilátor se při pokusu o parsování setká se stejným způsobem: potřebuje znát typ pole, ale kompilátor obvykle určí typ pomocí analýzy výrazu, což není možné bez znalosti typu bookTitles var předem.

Můžete zjistit, že to může být užitečné také u výrazů dotazů, ve kterých je obtížné určit přesný vytvořený typ proměnné var dotazu. K tomu může dojít u operací seskupování a řazení.

Klíčové slovo může být užitečné také v případě, že je konkrétní typ proměnné zdlouhavý při psaní na klávesnici, je zřejmý nebo nepřidá čitelnost var kódu. Jedním z příkladů, kde je tento způsob užitečný, je u vnořených obecných typů, jako jsou ty, var které se používají s operacemi skupiny. V následujícím dotazu je typ proměnné dotazu IEnumerable<IGrouping<string, Student>> . Pokud vy a ostatní uživatelé, kteří si musí váš kód udržovat, tento kód rozumíte, není problém s používáním implicitního psaní pro usnadnění a stručnost.

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

Použití pomáhá zjednodušit kód, ale jeho použití by mělo být omezeno na případy, kdy je potřeba, nebo když usnadňuje čtení var kódu. Další informace o tom, kdy použít správně, najdete v části Implicitně typované místní proměnné v článku Pokyny var pro kódování v C#.

Viz také