Ingebouwde typen en letterlijke gegevens

C# biedt een set ingebouwde typen die u in elk programma kunt gebruiken zonder extra verwijzingen. Deze typen hebben betrekking op de meest voorkomende gegevens waarmee u werkt: getallen, waar/onwaar,afzonderlijke tekens en tekst. Zie Ingebouwde typen (C#-verwijzing) voor een volledige verwijzingstabel die C#-trefwoorden aan .NET-typen toewijzen.

Numerieke typen

C# heeft ingebouwde typen voor gehele getallen, drijvendekommagetallen en decimale getallen. De meest gebruikte typen zijn int, doubleen 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;

Elk numeriek type heeft een vaste grootte en een vast bereik. int slaat 32-bits gehele getallen op (ongeveer ±2,1 miljard), long slaat 64-bits gehele getallen op en shortbyte slaat kleinere waarden op. Zie Integraal numerieke typen en Drijvende-komma numerieke typen voor de volledige lijst met grootten en bereiken.

Gebruik double voor algemene drijvende-kommawiskunde, float wanneer geheugen beperkt is en decimal voor exacte decimale precisie (zoals financiële berekeningen). Voeg het achtervoegsel f toe aan float letterlijke waarden en m aan decimal letterlijke waarden. Zonder achtervoegsel behandelt de compiler een getal met een decimaalteken als double.

Niet-ondertekende typen

Elk ondertekend geheel getaltype heeft een niet-ondertekende tegenhanger die alleen niet-negatieve waarden opslaat met twee keer het positieve bereik:

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

U kunt niet-ondertekende typen gebruiken wanneer negatieve waarden niet geldig zijn voor de gegevens, zoals bestandsgrootten of netwerkpoorten. In de praktijk wordt in veel toepassingen int of long gebruikt, zelfs voor waarden die alleen-positief zijn, omdat signed types de standaard zijn in de .NET-API's.

Gehele getallen van systeemeigen grootte

De nint en nuint typen vertegenwoordigen gehele getallen waarvan de grootte overeenkomt met de systeemeigen aanwijzergrootte van het platform: 32 bits op een 32-bits platform, 64 bits op een 64-bits platform:

nint bufferSize = 1024;
nuint elementCount = 256;

Het is onwaarschijnlijk dat u nint of nuint nodig hebt in gewone, dagelijkse code. Ze bestaan voor interop-scenario's en geheugenbewerkingen op laag niveau waarbij het aanpassen van de aanwijzergrootte van het platform belangrijk is. Blijf bij int of long tenzij u een specifieke reden heeft om typen in native grootte te gebruiken. Zie voor meer informatie nint en nuint.

bool, char en string

Naast getallen biedt C# drie andere veelgebruikte ingebouwde typen:

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

• bool — Opslaan true of false. Gebruik deze in voorwaarden, lussen en logische expressies.
• char — Slaat één Unicode-teken (UTF-16-code-eenheid) op tussen enkele aanhalingstekens.
• string — Slaat een reeks tekens op, tussen dubbele aanhalingstekens. Tekenreeksen zijn onveranderbaar. Zodra u een tekenreeks hebt gemaakt, kunt u de inhoud ervan niet meer wijzigen. Bewerkingen die een tekenreeks lijken te wijzigen, creëren daadwerkelijk een nieuwe tekenreeks.

Tekenreeksen zijn één van de typen die het meest gebruikt worden in C#. Zie de sectie Tekenreeksen voor uitgebreide dekking van tekenreeksbewerkingen, waaronder interpolatie, letterlijke tekenreeksen, zoeken, splitsen en vergelijken.

Letterlijke syntaxis

Een letterlijke waarde is een waarde die u rechtstreeks in uw code schrijft. De compiler wijst elk letterlijk type toe op basis van de indeling en elk achtervoegsel dat u opgeeft. C# ondersteunt de volgende soorten literalen:

• Letterlijke waarden voor gehele getallen: decimaal (42), hexadecimaal (0x2A) en binair (0b_0010_1010).
• Letterlijke drijvende komma - double standaard (3.14), float met het f achtervoegsel (3.14f) en decimal met m (3.14m).
• Letterlijke tekens : één teken tussen enkele aanhalingstekens ('A'), inclusief escapereeksen ('\n').
• Letterlijke tekenreeksen : regular ("hello"), verbatim (@"C:\path"), raw (""" ... """) en geïnterpoleerd ($"value: {x}").
• Booleaanse letterlijke waarden , true en false.
• De null letterlijke waarde : vertegenwoordigt het ontbreken van een waarde voor verwijzingstypen en null-waardetypen.
• De default letterlijke waarde : produceert de standaardwaarde voor elk type (behandeld in default expressies).

In de volgende secties worden de meest voorkomende letterlijke formulieren gedetailleerd beschreven.

Letterlijke waarden voor gehele getallen

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

Gebruik het 0x voorvoegsel voor hexadecimaal en 0b voor binair. Toevoegen L voor long, U voor uintof UL voor ulong.

Plaats het _ scheidingsteken voor cijfers op een willekeurige plaats binnen een getal, zodat het gemakkelijker te lezen is. Veelvoorkomende patronen zijn scheidingstekens voor duizendtallen in letterlijke decimalen (1_000_000_000), byte- of woordgrenzen in hexadecimale (0xFF_FF) en knabbelgrenzen in binair (0b_0010_1010).

Drijvende-komma-literalen

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

Zonder achtervoegsel is doubleeen numerieke letterlijke waarde met een decimaalteken. Toevoegen f voor float en m voor decimal. Wetenschappelijke notatie (1.5e6) wordt ook ondersteund.

Letterlijke tekens en tekenreeksen

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

Letterlijke karakters gebruiken enkele aanhalingstekens en ondersteunen escapereeksen (\n, \t, \u). Letterlijke tekenreeksen gebruiken dubbele aanhalingstekens.

Voorvoegseltekenreeksen met $ voor interpolatie. Wanneer een tekenreeks aanhalingstekens, backslashes of ingesloten JSON of XML bevat, gebruikt u een ruwe tekenreeks (afgebakend door """) in plaats van elk teken afzonderlijk te ontsnappen. Onbewerkte tekenreeksen combineren ook met interpolatie ($""").

Oudere code maakt gebruik @ van (verbatimtekenreeksen) om escape-verwerking te voorkomen. Geef de voorkeur aan ruwe stringliteralen omdat ze makkelijker te lezen en te schrijven zijn, en gebruik ze bij nieuwe code.

default Expressies

De default expressie produceert de standaardwaarde voor een type: 0 voor numerieke typen, false voor boolen null voor verwijzingstypen:

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

De default expressie is het handigst in algemene code, waarbij u het concrete type niet kent en een specifieke waarde niet kunt codeeren, zoals 0 of null. Schrijven default (zonder een typeargument) wanneer de compiler het type kan afleiden uit context of default(T) wanneer het type niet duidelijk is. Zie Standaardwaarden van C#-typen voor de volledige lijst met standaardwaarden per type.

Impliciet getypte variabelen met var

Het var trefwoord vertelt de compiler dat het type van een lokale variabele moet worden afgeleid van de initialisatiefunctie:

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;

De variabele is nog steeds sterk getypt; var maakt het niet dynamisch. De compiler bepaalt het type tijdens het compileren en dwingt de veiligheid van het type af zoals gebruikelijk. Gebruik var dit wanneer het type duidelijk is aan de rechterkant om visuele ruis te verminderen. Het type uitspelen wanneer de code duidelijker wordt. Zie Impliciet getypte lokale variabelen voor meer informatie.

Doelgetypte expressies new

Wanneer u het doeltype al kent vanuit context, zoals een variabeledeclaratie of een methodeparameter, kunt u de naam van het type weglaten uit de new expressie:

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

Target-typed new vermindert herhaling wanneer de typenaam lang is of aan de linkerkant van de toewijzing verschijnt. Het werkt overal waar de compiler het doeltype kan bepalen, inclusief methodeargumenten en retourinstructies. Zie new-operator voor meer informatie — doel-typ ingeschakeld new.

Het dynamic type

Het dynamic-type omzeilt typecontrole tijdens de compilatie. De compiler lost in plaats daarvan bewerkingen op een dynamic variabele tijdens runtime op:

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.

Gebruik dynamic deze functie bij interactie met COM-API's, dynamische talen of scenario's met veel reflectie, waarbij typen tijdens het compileren niet bekend zijn. Vermijd dynamic in de meeste toepassingscode omdat je compile-tijd veiligheid verliest. Fouten die normaal gesproken door de compiler worden opgevangen, worden in plaats daarvan runtime-uitzonderingen. Zie Het dynamische type voor meer informatie.

Zie ook

• Typesysteemoverzicht
• Ingebouwde typen (C#-verwijzing)
• Integrale numerieke typen
• zwevendekommagetaltypen
• waardetypen