Sdílet prostřednictvím

Předdefinované typy a literály

Návod

Začínáte s vývojem softwaru? Začněte nejprve kurzy Začínáme . Při psaní vašich prvních programů zavádějí typy.

Máte zkušenosti v jiném jazyce? Předdefinované typy jazyka C# se úzce mapují na typy v Javě, C++ a dalších jazycích. Přeskočte části syntaxe literálu a odvození typu pro podrobnosti specifické pro jazyk C#.

Jazyk C# poskytuje sadu předdefinovaných typů, které můžete použít v libovolném programu bez dalších odkazů. Tyto typy pokrývají nejběžnější data, se kterými pracujete: čísla, hodnoty true/false, jednotlivé znaky a text. Kompletní referenční tabulky mapující klíčová slova jazyka C# na typy .NET najdete v tématu Předdefinované typy (referenční dokumentace jazyka C#).

Číselné typy

Jazyk C# obsahuje předdefinované typy pro celá čísla, čísla s plovoucí desetinnou čárkou a desetinná čísla. Nejčastěji používané typy jsou int, doublea 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ždý číselný typ má pevnou velikost a rozsah. int ukládá 32bitové celá čísla (zhruba ±2,1 miliardy), long ukládá 64bitové celá čísla a shortbyte ukládají menší hodnoty. Úplný seznam velikostí a rozsahů najdete v tématu Celé číselné typy a Plovoucí číselné typy.

Používá se double pro obecnou matematiku s plovoucí desetinnou čárkou, float při omezení paměti a decimal v případě, že potřebujete přesnou desetinnou přesnost (například finanční výpočty). Připojte příponu f pro float literály a m pro decimal literály. Pokud není uvedena přípona, kompilátor považuje číslo s desetinnou čárkou za double.

Nepodepsané typy

Každý typ celého čísla se znaménkem má nepodepsaný protějšek, který ukládá pouze nezáporné hodnoty s dvojnásobným kladným rozsahem:

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

Typy bez znaménka můžete použít v případě, že záporné hodnoty nejsou platné pro data, například velikosti souborů nebo síťové porty. V praxi mnoho aplikací používá int nebo long dokonce pro kladné hodnoty, protože podepsané typy jsou výchozími hodnotami v rozhraních .NET API.

Celá čísla v nativní velikosti

nint Typy nuint představují celá čísla, jejichž velikost odpovídá nativní velikosti ukazatele platformy: 32 bitů na 32bitové platformě, 64 bitů na 64bitové platformě:

nint bufferSize = 1024;
nuint elementCount = 256;

Není pravděpodobné, že byste v každodenním kódu potřebovali nint nebo nuint. Existují pro scénáře spolupráce a operace s pamětí nízké úrovně, kde je důležitá shoda s velikostí ukazatele platformy. Držte se int nebo long pokud nemáte konkrétní důvod používat typy nativní velikosti. Další informace najdete v tématech nint a nuint.

bool, char a string

Kromě čísel poskytuje jazyk C# tři další často používané předdefinované typy:

bool isValid = true;
char grade = 'A';
string greeting = "Hello, world!";
  • bool — Obchody true nebo false. Používejte ho v podmínkách, smyčkách a logických výrazech.
  • char — Ukládá jeden znak Unicode (jednotku kódu UTF-16) uzavřenou do jednoduchých uvozovek.
  • string — Ukládá posloupnost znaků uzavřených do dvojitých uvozovek. Řetězce jsou neměnné. Po vytvoření řetězce nemůžete změnit jeho obsah. Operace, které se jeví jako úprava řetězce, ve skutečnosti vytvoří nový.

Řetězce jsou jedním z nejčastěji používaných typů v jazyce C#. Podrobné pokrytí řetězcových operací, včetně interpolace, nezpracovaných řetězcových literálů, vyhledávání, rozdělení a porovnání, najdete v části Řetězce .

Syntaxe literálu

Literál je hodnota, kterou napíšete přímo v kódu. Kompilátor přiřadí každému literálu typ na základě jeho formátu a přípony, kterou zadáte. Jazyk C# podporuje následující typy literálů:

  • Celočíselné literály – Desetinné číslo (42), šestnáctkové (0x2A) a binární (0b_0010_1010).
  • Literály čísla s plovoucí desetinnou čárkou — double ve výchozím nastavení (3.14), float s příponou f (3.14f) a decimal s m (3.14m).
  • Literály znaků – jeden znak v jednoduchých uvozovkách ('A'), včetně escape sekvencí ('\n').
  • Řetězcové literály – Normální ("hello"), doslovné (@"C:\path"), nezpracované (""" ... """) a interpolované ($"value: {x}").
  • Logické literály — true a false.
  • Literál null – Představuje absenci hodnoty pro odkazové typy a nulovatelné hodnotové typy.
  • Literál default – Vytvoří výchozí hodnotu pro libovolný typ (uvedený ve default výrazech).

Následující části detailně pokrývají nejběžnější literální formy.

Celočíselné literály

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

Použijte předponu 0x pro šestnáctkové a 0b binární hodnoty. Připojit L pro long, U pro uint, nebo UL pro ulong.

_ Umístěte oddělovač číslic kamkoli do čísla, aby se snadněji četl. Mezi běžné vzory patří oddělovače tisíců v desítkových literálech (1_000_000_000), hranice bajtu nebo slova v šestnáctkových formátech (0xFF_FF) a ohraničení půlbytu v binární soustavě (0b_0010_1010).

Literály s plovoucí desetinnou čárkou

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

Bez přípony je doublečíselný literál s desetinnou čárkou . Připojte f pro float a m pro decimal. Podporuje se také vědecký zápis (1.5e6).

Znakové a řetězcové literály

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

Literály znaků používají jednoduché uvozovky a podporují escape sekvence (\n, \t, \u). Řetězcové literály používají dvojité uvozovky.

Předponujte řetězce pomocí $ pro interpolaci. Pokud řetězec obsahuje uvozovky, zpětné lomítka nebo vložený JSON nebo XML, použijte namísto odvozování jednotlivých znaků nezpracovaný řetězcový literál (oddělený znakem """). Surové řetězcové literály se také pojí s interpolací ($""").

Starší kód používá @ (doslovné řetězce), aby se zabránilo řídicímu zpracování. Nezpracované řetězcové literály se snadněji čtou a zapisují, proto je preferujte pro nový kód.

default Výrazy

Výraz default vytvoří výchozí hodnotu pro typ: 0 pro číselné typy, false pro boola null pro odkazové typy:

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

Výraz default je nejužitečnější v obecném kódu, kde neznáte konkrétní typ a nemůžete pevně zakódovat konkrétní hodnotu, například 0 nebo null. Zapište default (bez argumentu typu), když kompilátor dokáže odvodit typ z kontextu nebo default(T) když typ není zřejmý. Úplný seznam výchozích hodnot podle typu najdete v tématu Výchozí hodnoty typů jazyka C#.

Implicitně zadané proměnné pomocí var

Klíčové var slovo říká kompilátoru, aby odvodil typ místní proměnné z inicializátoru:

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;

Proměnná je stále silně typovaná; var nečiní ji dynamickou. Kompilátor určuje typ v době kompilace a vynucuje bezpečnost typů obvyklým způsobem. Použijte var tehdy, když je typ zřejmý z pravé strany, abyste snížili vizuální šum. Vypište typ, když kód bude jasnější. Další informace naleznete v tématu Implicitně zadané místní proměnné.

Výrazy typu new cíle

Pokud už znáte cílový typ z kontextu, jako je deklarace proměnné nebo parametr metody, můžete název typu z výrazu new vynechat:

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

Typ cíle new snižuje opakování, pokud je název typu dlouhý nebo se zobrazí na levé straně přiřazení. Funguje kdekoli, kde kompilátor může určit cílový typ, včetně argumentů metody a návratových příkazů. Další informace naleznete v operátorunew — cílový typ new.

Typ dynamic

Typ dynamic obchází kontrolu typů kompilace. Kompilátor vyřeší operace s proměnnou dynamic za běhu místo toho:

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.

Používá se dynamic při interakci s rozhraními COM API, dynamickými jazyky nebo scénáři náročnými na reflexi, ve kterých nejsou typy v době kompilace známé. Vyhněte se dynamic většině kódu aplikace, protože ztratíte bezpečnost kompilace. Chyby, které kompilátor obvykle zachytí, se místo toho stanou výjimkami za běhu. Další informace naleznete v tématu Dynamický typ.

Viz také

  • Last updated on