Megosztás a következőn keresztül:

Implicit módon beírt helyi változók (C# programozási útmutató)

  • Cikk

A helyi változók explicit típus megadása nélkül deklarálhatók. A var kulcsszó arra utasítja a fordítót, hogy az inicializálási utasítás jobb oldalán lévő kifejezésből következtetsen a változó típusára. A kikövetkeztetett típus lehet beépített típus, névtelen típus, felhasználó által definiált típus vagy a .NET-osztálytárban definiált típus. A tömbök varinicializálásáról további információt az implicit módon beírt tömbök című témakörben talál.

Az alábbi példák a helyi változók deklarálásának varkülönböző módjait mutatják be:

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

Fontos tisztában lenni azzal, hogy a var kulcsszó nem "variánst" jelent, és nem jelzi, hogy a változó lazán van begépelve vagy késve. Ez csak azt jelenti, hogy a fordító határozza meg és rendeli hozzá a legmegfelelőbb típust.

A var kulcsszó a következő kontextusokban használható:

  • Helyi változókon (a metódus hatókörében deklarált változókon) az előző példában látható módon.

  • Inicializálási utasításban.

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

  • Foreach inicializálási utasításban.

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

  • Egy felhasználói utasításban.

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

További információ: Implicit módon beírt helyi változók és tömbök használata lekérdezési kifejezésben.

var és névtelen típusok

Sok esetben a használat var nem kötelező, és csak egy szintaktikai kényelem. Ha azonban egy változót névtelen típussal inicializál, úgy kell deklarálnia a változót, mintha var egy későbbi időpontban hozzá kell férnie az objektum tulajdonságaihoz. Ez a LINQ-lekérdezési kifejezések gyakori forgatókönyve. További információ: Névtelen típusok.

A forráskód szempontjából egy névtelen típusnak nincs neve. Ezért ha egy lekérdezési változó inicializálása varmegtörtént, akkor az objektumok var visszaadott sorozatában lévő tulajdonságok eléréséhez csak az utasítás iterációs változójának foreach típusa használható.

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

Megjegyzések

Az implicit típusú változódeklarációkra a következő korlátozások vonatkoznak:

  • var csak akkor használható, ha egy helyi változót deklarálnak és inicializálnak ugyanabban az utasításban; a változó nem inicializálható null értékre vagy metóduscsoportba vagy névtelen függvénybe.

  • var az osztály hatókörében lévő mezőkön nem használható.

  • A használatával var deklarált változók nem használhatók az inicializálási kifejezésben. Más szóval ez a kifejezés legális: int i = (i = 20); de ez a kifejezés fordítási időt eredményez: var i = (i = 20);

  • Több implicit típusú változó nem inicializálható ugyanabban az utasításban.

  • Ha egy névvel ellátott var típus hatókörben van, akkor a kulcsszó erre a var típusnévre lesz feloldva, és nem fog implicit módon beírt helyi változódeklaráció részeként kezelni.

A kulcsszó implicit beírása var csak a helyi metódus hatókörében lévő változókra alkalmazható. Az implicit beírás nem érhető el az osztálymezőkhöz, mivel a C#-fordító logikai paradoxonnal találkozik a kód feldolgozása során: a fordítónak ismernie kell a mező típusát, de a hozzárendelési kifejezés elemzéséig nem tudja meghatározni a típust, és a kifejezés nem értékelhető ki a típus ismerete nélkül. Tekintse meg az alábbi kódot:

private var bookTitles;

bookTitles egy osztálymező, amely a típust varadja meg. Mivel a mezőnek nincs kiértékelhető kifejezése, a fordító nem tudja kikövetkeztetni, hogy milyen típusúnak bookTitles kell lennie. Emellett nem elegendő kifejezést hozzáadni a mezőhöz (mint egy helyi változó esetében):

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

Amikor a fordító a kód összeállítása során mezőkkel találkozik, rögzíti az egyes mezők típusát a hozzá társított kifejezések feldolgozása előtt. A fordító ugyanazzal a paradoxonnal találkozik, amelyet elemezni bookTitlespróbál: ismernie kell a mező típusát, de a fordító általában a kifejezés elemzésével határozná meg vara típust, ami a típus előzetes ismerete nélkül nem lehetséges.

var Ez olyan lekérdezési kifejezéseknél is hasznos lehet, amelyekben a lekérdezési változó pontos felépítése nehezen határozható meg. Ez csoportosítási és rendezési műveletek esetén fordulhat elő.

A var kulcsszó akkor is hasznos lehet, ha a változó adott típusa unalmas a billentyűzeten, vagy nyilvánvaló, vagy nem növeli a kód olvashatóságát. Ilyen esetben az egyik példa var a beágyazott általános típusokra, például a csoportműveletekhez használt típusokra. Az alábbi lekérdezésben a lekérdezési változó típusa a következő IEnumerable<IGrouping<string, Student>>. Mindaddig, amíg Ön és mások, akiknek meg kell tartaniuk a kódot, megértik ezt, nincs probléma az implicit gépeléssel a kényelem és a rövidség érdekében.

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

A kód használata leegyszerűsíti var a kódot, de a használatát olyan esetekre kell korlátozni, ahol szükség van rá, vagy ha a kód könnyebben olvasható. A megfelelő használatról var további információt a C# kódolási útmutatójának implicit módon beírt helyi változók szakaszában talál.

Lásd még