Condividi tramite

Tipi e valori letterali predefiniti

Suggerimento

Novità dello sviluppo di software? Iniziare prima con le esercitazioni introduttive . Introducono tipi mentre si scrivono i primi programmi.

Esperienza in un'altra lingua? I tipi predefiniti C# sono strettamente mappati ai tipi in Java, C++ e altri linguaggi. Esaminare velocemente la sintassi letterale e le sezioni di inferenza dei tipi per i dettagli specifici di C#.

C# offre un set di tipi predefiniti che è possibile usare in qualsiasi programma senza riferimenti aggiuntivi. Questi tipi coprono i dati più comuni usati con: numeri, valori true/false, singoli caratteri e testo. Per un mapping completo delle parole chiave C# ai tipi .NET, vedere Tipi predefiniti (riferimenti per C#).

Tipi numerici

C# include tipi predefiniti per numeri interi, numeri a virgola mobile e numeri decimali. I tipi usati più comunemente sono int, doublee 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;

Ogni tipo numerico ha una dimensione fissa e un intervallo. int archivia interi a 32 bit (approssimativamente ±2,1 miliardi), long archivia interi a 64 bit e shortbyte archivia valori più piccoli. Per l'elenco completo di dimensioni e intervalli, vedere Tipi numerici integrali e tipi numerici a virgola mobile.

Usare double per la matematica generale a virgola mobile, float quando la memoria è vincolata e decimal quando è necessaria una precisione decimale esatta ,ad esempio calcoli finanziari. Aggiungere il f suffisso per float i valori letterali e m per decimal i valori letterali. Senza un suffisso, il compilatore considera un numero con un separatore decimale come double.

Tipi senza segno

Ogni tipo integer con segno ha una controparte senza segno che archivia solo valori non negativi con due volte l'intervallo positivo:

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

È possibile usare tipi non firmati quando i valori negativi non sono validi per i dati, ad esempio le dimensioni dei file o le porte di rete. In pratica, molte applicazioni usano int o long anche per i valori positivi perché i tipi firmati sono l'impostazione predefinita in tutte le API .NET.

Numeri interi di dimensioni native

I nint tipi e nuint rappresentano numeri interi le cui dimensioni corrispondono alle dimensioni del puntatore nativo della piattaforma: 32 bit in una piattaforma a 32 bit, 64 bit in una piattaforma a 64 bit:

nint bufferSize = 1024;
nuint elementCount = 256;

È improbabile che sia necessario nint o nuint nel codice quotidiano. Esistono per scenari di interoperabilità e operazioni di memoria di basso livello in cui la corrispondenza delle dimensioni del puntatore della piattaforma è importante. Attenersi a int o long a meno che non si abbia un motivo specifico per usare tipi di dimensioni native. Per altre informazioni, vedere nint e nuint.

bool, char e string

Oltre ai numeri, C# offre tre altri tipi predefiniti usati di frequente:

bool isValid = true;
char grade = 'A';
string greeting = "Hello, world!";
  • bool — Archivia true o false. Usarlo in condizioni, cicli ed espressioni logiche.
  • char — Archivia un singolo carattere Unicode (unità di codice UTF-16), racchiuso tra virgolette singole.
  • string — Archivia una sequenza di caratteri, racchiusa tra virgolette doppie. Le stringhe non sono modificabili. Dopo aver creato una stringa, non è possibile modificarne il contenuto. Le operazioni che sembrano modificare una stringa creano effettivamente una nuova stringa.

Le stringhe sono uno dei tipi più usati in C#. Per una copertura approfondita delle operazioni sulle stringhe, tra cui interpolazione, valori letterali stringa non elaborati, ricerca, suddivisione e confronto, vedere la sezione Stringhe .

Sintassi letterale

Un valore letterale è un valore scritto direttamente nel codice. Il compilatore assegna ogni valore letterale a un tipo in base al relativo formato e a qualsiasi suffisso specificato. C# supporta i tipi di valori letterali seguenti:

  • Valori letterali interi — Decimal (42), esadecimale (0x2A) e binario (0b_0010_1010).
  • Valori letterali a virgola mobile : double per impostazione predefinita (3.14), float con il f suffisso (3.14f) e decimal con m (3.14m).
  • Valori letterali carattere : un singolo carattere tra virgolette singole ('A'), incluse le sequenze di escape ('\n').
  • Letterali di stringa - Regular ("hello"), verbatim (@"C:\path"), raw (""" ... """) e interpolati ($"value: {x}").
  • Valori letterali booleani : true e false.
  • La costante null: rappresenta l'assenza di un valore per i tipi di riferimento e i tipi di valore nullable.
  • Valore default letterale : produce il valore predefinito per qualsiasi tipo (coperto nelle default espressioni).

Le sezioni seguenti illustrano in dettaglio i moduli letterali più comuni.

Valori letterali interi

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

Usare il prefisso 0x per l'esadecimale e 0b per il binario. Accodamento L per long, U per uint, o UL per ulong.

Posizionare il _ separatore di cifre in un punto qualsiasi all'interno di un numero per semplificare la lettura. I modelli comuni includono separatori di migliaia in valori letterali decimali (1_000_000_000), limiti di byte o parola in esadecimale (0xFF_FF) e limiti di nibbles in binario (0b_0010_1010).

Numeri letterali a virgola mobile

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

Senza un suffisso, un valore letterale numerico con un separatore decimale è double. Aggiungere f per float e m per decimal. È supportata anche la notazione scientifica (1.5e6).

Valori letterali di carattere e stringhe

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

I letterali di carattere usano virgolette singole e supportano sequenze di escape (\n, \t, \u). I valori letterali stringa usano virgolette doppie.

Stringhe di prefisso con $ per l'interpolazione. Quando una stringa contiene virgolette, barre rovesciate o JSON o XML incorporati, usare una stringa letterale grezza (delimitata da """) anziché eseguire l'escape di ogni carattere. I valori letterali stringa non elaborati si combinano anche con l'interpolazione ($""").

Il codice meno recente usa @ (stringhe verbatim) per evitare l'elaborazione di escape. Preferisci le stringhe letterali grezze, in quanto sono più facili da leggere e scrivere, per il nuovo codice.

default Espressioni

L'espressione default produce il valore predefinito per un tipo: 0 per i tipi numerici, false per boole null per i tipi di riferimento:

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

L'espressione default è più utile nel codice generico, in cui non si conosce il tipo concreto e non è possibile impostare come hardcoded un valore specifico come 0 o null. Scrivere default (senza un argomento di tipo) quando il compilatore può dedurre il tipo dal contesto o default(T) quando il tipo non è ovvio. Per l'elenco completo dei valori predefiniti per tipo, vedere Valori predefiniti dei tipi C#.

Variabili tipizzate in modo implicito con var

La var parola chiave indica al compilatore di dedurre il tipo di una variabile locale dal relativo inizializzatore:

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;

La variabile è ancora fortemente tipizzata; var non lo rende dinamico. Il compilatore determina il tipo in fase di compilazione e applica la sicurezza dei tipi come di consueto. Usare var quando il tipo è ovvio dal lato destro per ridurre il rumore visivo. Specificare il tipo quando rende più chiaro il codice. Per altre informazioni, vedere Variabili locali tipizzate in modo implicito.

Espressioni tipate secondo il contesto di new

Quando si conosce già il tipo di destinazione dal contesto, ad esempio una dichiarazione di variabile o un parametro di metodo, è possibile omettere il nome del tipo dall'espressione new :

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

Il tipo di new destinazione riduce la ripetizione quando il nome del tipo è lungo o viene visualizzato sul lato sinistro dell'assegnazione. Funziona ovunque il compilatore possa determinare il tipo di obiettivo, inclusi gli argomenti del metodo e le istruzioni di ritorno. Per altre informazioni, vedere new operator — target-typed new.

Il tipo dynamic

Il dynamic tipo ignora il controllo dei tipi in fase di compilazione. Il compilatore risolve invece le operazioni su una dynamic variabile in fase di esecuzione:

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.

Usare dynamic quando si interagisce con LE API COM, i linguaggi dinamici o gli scenari con elevato utilizzo di reflection, in cui i tipi non sono noti in fase di compilazione. Evitare dynamic nella maggior parte del codice dell'applicazione perché si perde la sicurezza in fase di compilazione. Gli errori rilevati normalmente dal compilatore diventano eccezioni in fase di esecuzione. Per altre informazioni, vedere Il tipo dinamico.

Vedere anche

  • Last updated on