Udostępnij za pośrednictwem

Wbudowane typy i literały

Wskazówka

Dopiero zaczynasz programować oprogramowanie? Najpierw zacznij od samouczków Wprowadzenie . Wprowadzają one typy podczas pisania pierwszych programów.

Czy masz doświadczenie w pracy w innym języku? Wbudowane typy języka C# ściśle odpowiadają typom w językach Java, C++ i innych. Przejrzyj sekcje składni literału i wnioskowania typów w celu uzyskania szczegółów specyficznych dla języka C#.

Język C# udostępnia zestaw wbudowanych typów, których można używać w dowolnym programie bez dodatkowych odwołań. Te typy obejmują najbardziej typowe dane, z których pracujesz: liczby, wartości true/false, poszczególne znaki i tekst. Aby uzyskać pełne mapowanie słów kluczowych języka C# na typy platformy .NET, zobacz Wbudowane typy (odwołanie do C#).

Typy liczbowe

Język C# ma wbudowane typy liczb całkowitych, liczb zmiennoprzecinkowych i liczb dziesiętnych. Najczęściej używane typy to int, doublei 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;

Każdy typ liczbowy ma stały rozmiar i zakres. int przechowuje 32-bitowe liczby całkowite (w przybliżeniu ±2,1 miliarda), long przechowuje 64-bitowe liczby całkowite i shortbyte przechowuje mniejsze wartości. Aby uzyskać pełną listę rozmiarów i zakresów, zobacz Typy liczb całkowitych i Typy liczb zmiennoprzecinkowych.

Służy double do ogólnych obliczeń zmiennoprzecinkowych, float gdy pamięć jest ograniczona i decimal gdy potrzebujesz dokładnej dokładności dziesiętnej (np. obliczeń finansowych). f Dodaj sufiks do literałów float i m do literałów decimal. Bez sufiksu kompilator traktuje liczbę z separatorem dziesiętnym jako double.

Typy niepodpisane

Każdy podpisany typ liczby całkowitej ma niepodpisany odpowiednik, który przechowuje tylko wartości inne niż ujemne z dwukrotnie dodatnim zakresem:

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

Można użyć typów niepodpisanych, gdy wartości ujemne nie są prawidłowe dla danych, takich jak rozmiary plików lub porty sieciowe. W praktyce wiele aplikacji używa int lub long, nawet dla wartości tylko dodatnich, ponieważ typy ze znakiem są domyślne w interfejsach API platformy .NET.

Liczby całkowite o rozmiarze natywnym

Typy nint i nuint reprezentują liczby całkowite, których rozmiar jest zgodny z natywnym rozmiarem wskaźnika platformy: 32 bity na 32-bitowej platformie, 64 bity na platformie 64-bitowej:

nint bufferSize = 1024;
nuint elementCount = 256;

Jest mało prawdopodobne, aby nint lub nuint były potrzebne w codziennym kodzie. Istnieją one w scenariuszach interoperacyjnych i operacjach pamięci niskiego poziomu, gdzie dopasowanie rozmiaru wskaźnika do platformy jest istotne. Trzymaj się int lub long, chyba że masz konkretny powód, aby używać typów o rozmiarze natywnym. Aby uzyskać więcej informacji, zobacz tematy nint oraz nuint.

bool, char i string

Poza liczbami język C# udostępnia trzy inne często używane wbudowane typy:

bool isValid = true;
char grade = 'A';
string greeting = "Hello, world!";
  • bool — Przechowuje true lub false. Użyj go w warunkach, pętlach i wyrażeniach logicznych.
  • char — przechowuje pojedynczy znak Unicode (jednostka kodu UTF-16) ujęta w pojedyncze cudzysłowy.
  • string — przechowuje sekwencję znaków ujętą w cudzysłów. Ciągi są niezmienne. Po utworzeniu ciągu nie można zmienić jego zawartości. Operacje, które wydają się modyfikować ciąg, faktycznie tworzą nowy.

Ciągi są jednym z najczęściej używanych typów w języku C#. Szczegółowe pokrycie operacji ciągów, w tym interpolacji, nieprzetworzonych literałów ciągów, wyszukiwania, dzielenia i porównywania, można znaleźć w sekcji Ciągi .

Składnia literału

Literał to wartość, którą wpisujesz bezpośrednio w swoim kodzie. Kompilator przypisuje każdemu literałowi typ na podstawie jego formatu i podanego sufiksu. Język C# obsługuje następujące typy literałów:

  • Literały liczb całkowitych — dziesiętne (42), szesnastkowe (0x2A) i binarne (0b_0010_1010).
  • Literały zmiennoprzecinkowe — double domyślnie (3.14), float z sufiksem f (3.14f) i decimal (m3.14m).
  • Literały znaków — pojedynczy znak w pojedynczych cudzysłowach ('A'), w tym sekwencje ucieczki ('\n').
  • Literały ciągu — zwykłe (), dosłowne ("hello"@"C:\path"), nieprzetworzone (""" ... """) i interpolowane ($"value: {x}").
  • Literały logiczne — true i false.
  • Literał null — Oznacza brak wartości dla typów referencyjnych i typów wartości, które mogą przyjmować wartość null.
  • Literał default — tworzy wartość domyślną dla dowolnego typu (zawarte w wyrażeniachdefault).

W poniższych sekcjach szczegółowo omówiono najbardziej typowe formularze literału.

Literały liczb całkowitych

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

Użyj prefiksu 0x dla szesnastkowego i 0b dla binarnego. Załącz L dla long, U dla uint, lub UL dla ulong.

Umieść separator cyfry _ w dowolnym miejscu w obrębie liczby, aby ułatwić odczytywanie. Typowe wzorce obejmują separatory tysięcy w literałach dziesiętnych (1_000_000_000), granice bajtów lub słów w postaci szesnastkowej (0xFF_FF) i granice półbajtów w postaci binarnej (0b_0010_1010).

Literały zmiennoprzecinkowe

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

Bez sufiksu literał liczbowy z przecinkiem dziesiętnym to double. Dołącz f dla float i m dla decimal. Notacja naukowa (1.5e6) jest również obsługiwana.

Literały znakowe i ciągowe

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

Literały znaków używają pojedynczych cudzysłowów i obsługują sekwencje ucieczki (\n, \t, \u). Literały ciągu używają podwójnych cudzysłowów.

Dodaj ciągi z prefiksem $ do interpolacji. Gdy ciąg zawiera cudzysłowy, ukośniki odwrotne lub osadzony kod JSON lub XML, użyj nieprzetworzonego literału ciągu (ograniczanego znakiem """) zamiast znakowania każdego znaku. Nieprzetworzone literały ciągów łączą się również z interpolacją ($""").

Starszy kod używa @ (ciągów dosłownych), aby uniknąć przetwarzania znaków specjalnych. Literały nieprzetworzonych ciągów są łatwiejsze do odczytania i zapisu, więc preferują je dla nowego kodu.

default Wyrażenia

Wyrażenie default generuje wartość domyślną dla typu: 0 dla typów liczbowych, false dla bool, i null dla typów referencyjnych:

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

Wyrażenie default jest najbardziej przydatne w kodzie ogólnym, gdzie nie znasz konkretnego typu i nie można zakodować określonej wartości, takiej jak 0 lub null. Zapis default (bez argumentu typu), gdy kompilator może wywnioskować typ z kontekstu lub default(T) gdy typ nie jest oczywisty. Aby uzyskać pełną listę wartości domyślnych według typu, zobacz Domyślne wartości typów języka C#.

Niejawnie typowane zmienne z użyciem var

Słowo var kluczowe nakazuje kompilatorowi wywnioskowanie typu zmiennej lokalnej z inicjatora:

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;

Zmienna jest nadal silnie typizowana; var nie sprawia, że jest dynamiczna. Kompilator określa typ w czasie kompilacji i wymusza bezpieczeństwo typu w zwykły sposób. Użyj var, gdy typ jest oczywisty po prawej stronie, aby zmniejszyć szum wizualny. Podaj pełną nazwę typu, gdy to ułatwia zrozumienie kodu. Aby uzyskać więcej informacji, zobacz Niejawnie wpisane zmienne lokalne.

Wyrażenia typizowane obiektem docelowym new

Jeśli już znasz typ docelowy z kontekstu, na przykład deklarację zmiennej lub parametr metody, możesz pominąć nazwę typu z new wyrażenia:

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

Typ docelowy new zmniejsza powtarzanie, gdy nazwa typu jest długa lub pojawia się po lewej stronie przypisania. Działa w dowolnym miejscu, w których kompilator może określić typ docelowy, w tym argumenty metody i instrukcje zwracane. Aby uzyskać więcej informacji, zobacz new operator — typ docelowy new.

Typ dynamic

Typ dynamic pomija sprawdzanie poprawności typów w czasie kompilacji. Kompilator rozstrzyga operacje na zmiennej dynamic w czasie wykonywania:

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.

Należy używać dynamic podczas interakcji z interfejsami API MODELU COM, językami dynamicznymi lub scenariuszami wymagającymi odbicia, w których typy nie są znane w czasie kompilacji. Unikaj dynamic w większości kodu aplikacji, ponieważ tracisz bezpieczeństwo w czasie kompilacji. Błędy, które zwykle wykrywa kompilator, stają się wyjątkami czasu wykonywania. Aby uzyskać więcej informacji, zobacz Typ dynamiczny.

Zobacz także

  • Last updated on