C# Academy · Lektion

När var bör undvikas

Håll koden lättläst genom att ange typen uttryckligen när det behövs.

Lektion 2 av 413 steg

När var bör undvikas är en gratis lektion i C# Academy på CoddyKit. Detta är lektion 2 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för C# Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i C# Academy innehåller totalt 4 lektioner.

var kan dölja typen

var är praktiskt, men kan göra det otydligt vad en variabel faktiskt är, vilket försämrar läsbarheten för nästa läsare.

using System;

class Program {
    static void Main() {
        var x = Compute();
        Console.WriteLine(x);
    }
    static int Compute() { return 42; }
}

Otydliga metodreturer

När ett metodnamn inte avslöjar returtypen bör ni föredra en explicit typ, så att läsarna vet vad de har.

using System;

class Program {
    static double Process() { return 3.14; }
    static void Main() {
        double value = Process();
        Console.WriteLine(value);
    }
}

Överraskningar med taltyper

var sum = 0 är en int. Om ni förväntar er en double kan det orsaka buggar med heltalsdivision.

using System;

class Program {
    static void Main() {
        double sum = 0;
        sum += 7 / 2.0;
        Console.WriteLine(sum);
    }
}

Var explicita för gränssnitt

Om ni vill programmera mot ett gränssnitt bör ni deklarera det explicit; var skulle i stället välja den konkreta typen.

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        IList<int> items = new List<int> { 1, 2 };
        Console.WriteLine(items.Count);
    }
}

Avlägsna initierare

När initieraren är ett långt eller nästlat uttryck beskriver en explicit typ avsikten bättre än var.

using System;

class Program {
    static void Main() {
        int finalScore = (10 + 5) * 2 - 3;
        Console.WriteLine(finalScore);
    }
}

Undvik var för tydliga primitiva typer

Många team skriver ut den explicita typen för enkla primitiva typer, så att den avsedda taltypen blir entydig.

using System;

class Program {
    static void Main() {
        long bigCount = 5000000000;
        Console.WriteLine(bigCount);
    }
}

var kan inte vara ett fält

var kan endast användas för lokala variabler. Fält, parametrar och returtyper måste alltid anges explicit.

using System;

class Program {
    static int field = 100;
    static void Main() {
        Console.WriteLine(field);
    }
}

Blandad numerisk typinferens

Var försiktiga: var avg = total / count med två heltal förblir en heltalsberäkning. Gör avsikten explicit när ni behöver decimaler.

using System;

class Program {
    static void Main() {
        int total = 7, count = 2;
        double avg = (double)total / count;
        Console.WriteLine(avg);
    }
}

När stilguider skiljer sig åt

Vissa stilguider säger "använd var endast när typen är uppenbar på högersidan". En konsekvent regel hjälper hela teamet.

using System;

class Program {
    static void Main() {
        var customer = new string("Ann"[0], 3);
        Console.WriteLine(customer);
    }
}

Balansera bekvämlighet och tydlighet

Målet är lättläst kod. Använd var där det hjälper och explicita typer där de förtydligar.

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var lookup = new Dictionary<int, string>();
        int key = 1;
        lookup[key] = "one";
        Console.WriteLine(lookup[1]);
    }
}

En praktisk tumregel

Om ni inte kan avgöra typen genom att läsa raden ensam bör ni skriva ut den. Annars går var bra.

using System;

class Program {
    static void Main() {
        var greeting = "Hello";
        decimal price = 19.99m;
        Console.WriteLine(greeting + " " + price);
    }
}

Snabbtest

Testa ert omdöme om när var bör undvikas.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Undvik var när det döljer en viktig typ, när taltypen spelar roll (int jämfört med double), när ni vill rikta er mot ett gränssnitt eller när ett metodnamn inte avslöjar returtypen.

var fungerar endast för lokala variabler. En bra tumregel är: om raden ensam inte avslöjar typen bör ni skriva ut den explicit.

Gratis att börja

Lär dig C# med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 93
Lektioner: 346

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”När var bör undvikas” gratis?

Ja – hela texten till ”När var bör undvikas” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i C# Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i C# Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”När var bör undvikas”?

Håll koden lättläst genom att ange typen uttryckligen när det behövs. Ni övar på C# Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig C# Academy?

Du behöver inga förkunskaper. Utbildningen i C# Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”När var bör undvikas”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här C# Academy-lektionen?

Ja. Varje C# Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Härledning av lokala variabeltyper med var
När var bör undvikas
Typen dynamic
Målinfererade new-uttryck

← Tillbaka till C# Academy