Inbyggda typer och literaler

C# innehåller en uppsättning inbyggda typer som du kan använda i valfritt program utan ytterligare referenser. Dessa typer omfattar de vanligaste data som du arbetar med: tal, sanna/falska värden, enskilda tecken och text. En fullständig referenstabell som mappar C#-nyckelord till . NET-typer finns i Inbyggda typer (C#-referens).

Numeriska typer

C# har inbyggda typer för heltal, flyttalsnummer och decimaltal. De vanligaste typerna är int, doubleoch decimal:

int population = 67_000_000;
long distance = 384_400_000L;
short temperature = -40;
byte red = 255;

double pi = 3.141592653589793;
float gravity = 9.81f;
decimal price = 19.99m;

Varje numerisk typ har en fast storlek och ett fast intervall. int lagrar 32-bitars heltal (ungefär ±2,1 miljarder), long lagrar 64-bitars heltal och short lagrar byte mindre värden. En fullständig lista över storlekar och intervall finns i Heltalstyper och Flyttalstyper.

Används double för allmän flyttalsmatematik, float när minnet är begränsat och decimal när du behöver exakt decimalprecision (till exempel ekonomiska beräkningar). Lägg till suffixet f för float literaler och m för decimal literaler. Utan ett suffix behandlar kompilatorn ett tal med en decimalpunkt som double.

Osignerade typer

Varje signerad heltalstyp har en osignerad motsvarighet som endast lagrar icke-negativa värden med dubbelt så stort positivt intervall:

uint fileSize = 4_294_967_295;
ulong totalBytes = 18_446_744_073_709_551_615;
ushort port = 443;

Du kan använda osignerade typer när negativa värden inte är giltiga för data, till exempel filstorlekar eller nätverksportar. I praktiken använder många program int eller long även för enbart positiva värden eftersom signed typer är standard i .NET-API:erna.

Inhemska heltalstorlekar

Typerna nint och nuint representerar heltal vars storlek matchar plattformens ursprungliga pekarstorlek: 32 bitar på en 32-bitars plattform, 64 bitar på en 64-bitars plattform:

nint bufferSize = 1024;
nuint elementCount = 256;

Det är osannolikt att du behöver nint eller nuint i vanlig kod. De finns för interop-scenarier och minnesåtgärder på låg nivå där det är viktigt att matcha plattformens pekarstorlek. Håll dig till int eller long om du inte har en specifik anledning att använda typer med native-storlek. Mer information finns i nint och nuint.

bool, char och string

Utöver tal tillhandahåller C# tre andra inbyggda typer som används ofta:

bool isValid = true;
char grade = 'A';
string greeting = "Hello, world!";

• bool — Lagrar true eller false. Använd den i villkor, loopar och logiska uttryck.
• char – Lagrar ett enda Unicode-tecken (UTF-16-kodenhet), omgivet av enkla citattecken.
• string – Lagrar en sekvens med tecken, omgiven av dubbla citattecken. Strängar är oföränderliga. När du har skapat en sträng kan du inte ändra dess innehåll. Åtgärder som verkar ändra en sträng skapar faktiskt en ny.

Strängar är en av de mest använda typerna i C#. Detaljerad information om strängåtgärder, inklusive interpolering, råa strängliteraler, sökning, delning och jämförelse finns i avsnittet Strängar .

Literal syntax

En literal är ett värde som du skriver direkt i koden. Kompilatorn tilldelar varje literal en typ baserat på dess format och eventuella suffix som du anger. C# stöder följande typer av literaler:

• Heltalsliteraler – Decimala (42), hexadecimala (0x2A) och binära (0b_0010_1010).
• Flyttalsliteraler – double som standard (3.14), float med suffixet f (3.14f) och decimal med m (3.14m).
• Teckenliteraler – ett enda tecken inom enkla citattecken ('A'), inklusive escape-sekvenser ('\n').
• Strängliteraler – Vanlig ("hello"), ordagrann (@"C:\path"), rå (""" ... """) och interpolerad ($"value: {x}").
• Booleska literaler – true och false.
• Literalen null – representerar avsaknaden av ett värde för referenstyper och nullbara värdetyper.
• Literalen default – Genererar standardvärdet för alla typer (som beskrivs i default uttryck).

Följande avsnitt täcker de vanligaste litterala formerna i detalj.

Heltalsliteraler

int dec = 42;
int hex = 0x2A;
int bin = 0b_0010_1010;
long big = 1_000_000_000L;

Använd prefixet 0x för hexadecimalt och 0b binärt. L Lägg till för long, U för uinteller UL för ulong.

Placera sifferavgränsaren _ var som helst inom ett tal för att göra det lättare att läsa. Vanliga mönster är tusentalsavgränsare i decimala litteraler (1_000_000_000), byte- eller ordgränser i hexadecimala tal (0xFF_FF) och nibblegränser i binära tal (0b_0010_1010).

Flyttalsliteraler

double d = 3.14;
float f = 3.14f;
decimal m = 3.14m;
double scientific = 1.5e6; // 1,500,000

Utan ett suffix är doubleen numerisk literal med en decimalpunkt . Lägg till f för float och m för decimal. Vetenskaplig notation (1.5e6) stöds också.

Tecken- och strängliteraler

char newline = '\n';
char unicode = '\u0041'; // 'A'

string message = $"Found {dec} items";            // interpolated string
string path = @"C:\Users\docs\file.txt";        // verbatim string
string json = """
    { "name": "Alice", "age": 30 }
    """;                                           // raw string literal
string raw = $"""
    Found {dec} items in "{greeting}"
    """;                                           // raw + interpolated

Teckenkonstanter använder enkelcitat och stöder escape-sekvenser (\n, \t, \u). Strängliteraler använder dubbla citattecken.

Prefixsträngar med $ för interpolering. När en sträng innehåller citattecken, omvänt snedstreck eller inbäddad JSON eller XML, använd en rå sträng (avgränsad av """) istället för att exkludera varje tecken. Råsträngliteraler kombineras också med interpolering ($""").

Äldre kod använder @ (ordagranna strängar) för att undvika escape-hantering. Råsträngliteraler är lättare att läsa och skriva, så föredra dem för ny kod.

default Uttryck

Uttrycket default genererar standardvärdet för en typ: 0 för numeriska typer, false för bool, och null för referenstyper:

int defaultInt = default;          // 0
bool defaultBool = default;        // false
string? defaultString = default;   // null

// Use default in a conditional:
var limit = (args.Length > 0) ? int.Parse(args[0]) : default(int);

Uttrycket default är mest användbart i allmän kod, där du inte känner till den konkreta typen och inte kan hårdkoda ett specifikt värde som 0 eller null. Skriv default (utan ett typargument) när kompilatorn kan härleda typen från kontexten eller default(T) när typen inte är uppenbar. En fullständig lista över standardvärden efter typ finns i Standardvärden för C#-typer.

Implicit inskrivna variabler med var

Nyckelordet var instruerar kompilatorn att härleda en lokal variabels typ från dess initialiserare:

var count = 10;              // compiler infers int
var name = "C#";             // compiler infers string
var items = new List<int>(); // compiler infers List<int>

// var requires an initializer — the compiler needs a value to infer the type.
// The following line wouldn't compile:
// var unknown;

Variabeln är fortfarande starkt skriven. var gör den inte dynamisk. Kompilatorn avgör typen vid kompileringstid och framtvingar typsäkerhet som vanligt. Använd var när typen är uppenbar från höger sida för att minska det visuella bruset. Stava ut typen när koden blir tydligare. Mer information finns i Implicit inskrivna lokala variabler.

Måltypade new uttryck

När du redan känner till måltypen från kontexten, till exempel en variabeldeklaration eller en metodparameter, kan du utelämna typnamnet från new uttrycket:

List<string> names = new() { "Alice", "Bob", "Charlie" };
Dictionary<string, int> scores = new()
{
    ["Alice"] = 95,
    ["Bob"] = 87
};

Måltyp minskar new upprepningen när typnamnet är långt eller visas till vänster i tilldelningen. Det fungerar var som helst där kompilatorn kan fastställa måltypen, inklusive metodargument och returinstruktioner. För mer information, se new operatorn — måltypad new.

Typ dynamic

Typen dynamic kringgår kompileringstidstypkontroll. Kompilatorn löser operationer för en dynamic-variabel vid körning istället.

dynamic value = 42;
Console.WriteLine(value.GetType()); // System.Int32

value = "Now I'm a string";
Console.WriteLine(value.GetType()); // System.String

// The compiler doesn't check operations on dynamic at compile time.
// Errors surface at run time instead.

Använd dynamic när du interagerar med COM-API:er, dynamiska språk eller reflektionsintensiva scenarier där typer inte är kända vid kompileringstillfället. Undvik dynamic i de flesta programkod eftersom du förlorar kompileringstidens säkerhet. Fel som kompilatorn normalt fångar upp blir i stället körningsexceptioner. Mer information finns i Den dynamiska typen.

Se även

• Översikt över typsystem
• Inbyggda typer (C#-referens)
• numeriska typer av integraler
• flyttalsnumeriska typer
• Värdetyper