Share via

Impliciet getypte lokale variabelen (C#-programmeerhandleiding)

  • Artikel

Lokale variabelen kunnen worden gedeclareerd zonder een expliciet type te geven. Het var trefwoord geeft de compiler de instructie om het type variabele af te stellen van de expressie aan de rechterkant van de initialisatie-instructie. Het afgeleid type kan een ingebouwd type zijn, een anoniem type, een door de gebruiker gedefinieerd type of een type dat is gedefinieerd in de .NET-klassebibliotheek. Zie Impliciet getypte matrices varvoor meer informatie over het initialiseren van matrices.

In de volgende voorbeelden ziet u verschillende manieren waarop lokale variabelen kunnen worden gedeclareerd met 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>();

Het is belangrijk om te begrijpen dat het var trefwoord niet 'variant' betekent en niet aangeeft dat de variabele losjes is getypt of laat gebonden is. Dit betekent alleen dat de compiler het meest geschikte type bepaalt en toewijst.

Het var trefwoord kan worden gebruikt in de volgende contexten:

  • Op lokale variabelen (variabelen die zijn gedeclareerd op methodebereik), zoals wordt weergegeven in het vorige voorbeeld.

  • In een voor initialisatie-instructie.

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

  • In een foreach-initialisatie-instructie .

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

  • In een using-instructie .

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

Zie Hoe u impliciet getypte lokale variabelen en matrices gebruikt in een query-expressie voor meer informatie.

var en anonieme typen

In veel gevallen is het gebruik var van optioneel en is slechts een syntactisch gemak. Wanneer een variabele echter wordt geïnitialiseerd met een anoniem type, moet u de variabele declareren alsof var u op een later moment toegang nodig hebt tot de eigenschappen van het object. Dit is een veelvoorkomend scenario in LINQ-queryexpressies. Zie Anonieme typen voor meer informatie.

Vanuit het perspectief van uw broncode heeft een anoniem type geen naam. Als een queryvariabele daarom is geïnitialiseerd, varis de enige manier om toegang te krijgen tot de eigenschappen in de geretourneerde reeks objecten als var het type iteratievariabele in de foreach instructie.

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

Opmerkingen

De volgende beperkingen gelden voor impliciet getypte variabeledeclaraties:

  • var kan alleen worden gebruikt wanneer een lokale variabele wordt gedeclareerd en geïnitialiseerd in dezelfde instructie; de variabele kan niet worden geïnitialiseerd naar null of naar een methodegroep of een anonieme functie.

  • var kan niet worden gebruikt voor velden in het klassebereik.

  • Variabelen die zijn gedeclareerd met behulp var van, kunnen niet worden gebruikt in de initialisatie-expressie. Met andere woorden, deze expressie is legaal: int i = (i = 20); maar deze expressie produceert een compilatiefout: var i = (i = 20);

  • Meerdere impliciet getypte variabelen kunnen niet in dezelfde instructie worden geïnitialiseerd.

  • Als een type met de naam var binnen het bereik valt, wordt het var trefwoord omgezet in die typenaam en wordt het niet behandeld als onderdeel van een impliciet getypte lokale variabeledeclaratie.

Impliciet typen met het var trefwoord kan alleen worden toegepast op variabelen binnen het bereik van de lokale methode. Impliciet typen is niet beschikbaar voor klassevelden omdat de C#-compiler een logische paradox tegenkomt terwijl de code is verwerkt: de compiler moet het type van het veld kennen, maar kan het type pas bepalen als de toewijzingsexpressie is geanalyseerd en de expressie kan niet worden geëvalueerd zonder het type te kennen. Kijk eens naar de volgende code:

private var bookTitles;

bookTitles is een klasseveld op basis van het type var. Omdat het veld geen expressie heeft die moet worden geëvalueerd, kan de compiler niet afleiden welk type bookTitles moet zijn. Bovendien is het toevoegen van een expressie aan het veld (net als voor een lokale variabele) ook onvoldoende:

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

Wanneer de compiler velden tegenkomt tijdens het compileren van code, wordt het type van elk veld vastgelegd voordat er expressies worden verwerkt die eraan zijn gekoppeld. De compiler ondervindt dezelfde paradox die probeert te parseren bookTitles: het moet het type van het veld weten, maar de compiler zou normaal gesproken het type bepalen vardoor de expressie te analyseren, wat niet mogelijk is zonder het type vooraf te kennen.

var Het kan ook handig zijn voor query-expressies waarin het exacte samengestelde type van de queryvariabele moeilijk te bepalen is. Dit kan gebeuren met groeperings- en bestelbewerkingen.

Het var trefwoord kan ook handig zijn wanneer het specifieke type variabele te veel te typen is op het toetsenbord, of duidelijk is of niet toevoegt aan de leesbaarheid van de code. Een voorbeeld waarbij var dit handig is, is met geneste algemene typen, zoals typen die worden gebruikt met groepsbewerkingen. In de volgende query is IEnumerable<IGrouping<string, Student>>het type van de queryvariabele. Zolang u en anderen die uw code moeten onderhouden dit begrijpen, is er geen probleem met het gebruik van impliciete typen voor gemak en beknoptheid.

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

Het gebruik van var helpt uw code te vereenvoudigen, maar het gebruik ervan moet worden beperkt tot gevallen waarin deze nodig is, of wanneer uw code gemakkelijker te lezen is. Zie de sectie Impliciet getypte lokale variabelen in het artikel C#-coderingsrichtlijnen voor meer informatie over wanneer u correct moet gebruikenvar.

Zie ook