C# Language
Tipi incorporati

Tipo di riferimento immutabile - stringa

// assign string from a string literal
string s = "hello";

// assign string from an array of characters
char[] chars = new char[] { 'h', 'e', 'l', 'l', 'o' };
string s = new string(chars, 0, chars.Length);

// assign string from a char pointer, derived from a string
string s;
unsafe
{
    fixed (char* charPointer = "hello")
    {
        s = new string(charPointer);
    }
}

Tipo di valore - char

// single character s
char c = 's';

// character s: casted from integer value
char c = (char)115;

// unicode character: single character s
char c = '\u0073';

// unicode character: smiley face
char c = '\u263a';

Tipo di valore: breve, int, lungo (con segno 16 bit, 32 bit, numeri interi a 64 bit)

// assigning a signed short to its minimum value
short s = -32768;

// assigning a signed short to its maximum value
short s = 32767;

// assigning a signed int to its minimum value
int i = -2147483648;

// assigning a signed int to its maximum value
int i = 2147483647;

// assigning a signed long to its minimum value (note the long postfix)
long l = -9223372036854775808L;

// assigning a signed long to its maximum value (note the long postfix)
long l = 9223372036854775807L;

È anche possibile rendere nullable di questi tipi, il che significa che in aggiunta ai normali valori può essere assegnato anche null. Se una variabile di un tipo nullable non è inizializzata, sarà null invece di 0. I tipi di nullità sono contrassegnati aggiungendo un punto interrogativo (?) Dopo il tipo.

int a; //This is now 0.
int? b; //This is now null.

Tipo di valore: ushort, uint, ulong (interi senza segno a 16 bit, 32 bit, 64 bit)

// assigning an unsigned short to its minimum value
ushort s = 0;

// assigning an unsigned short to its maximum value
ushort s = 65535;

// assigning an unsigned int to its minimum value
uint i = 0;

// assigning an unsigned int to its maximum value
uint i = 4294967295;

// assigning an unsigned long to its minimum value (note the unsigned long postfix)
ulong l = 0UL;

// assigning an unsigned long to its maximum value (note the unsigned long postfix)
ulong l = 18446744073709551615UL;

È anche possibile rendere nullable di questi tipi, il che significa che in aggiunta ai normali valori può essere assegnato anche null. Se una variabile di un tipo nullable non è inizializzata, sarà null invece di 0. I tipi di nullità sono contrassegnati aggiungendo un punto interrogativo (?) Dopo il tipo.

uint a; //This is now 0.
uint? b; //This is now null.

Tipo di valore - bool

// default value of boolean is false
bool b;
//default value of nullable boolean is null
bool? z;
b = true;
if(b) {
    Console.WriteLine("Boolean has true value");
}

La parola chiave bool è un alias di System.Boolean. È usato per dichiarare le variabili per memorizzare i valori booleani, true e false .

Confronti con i tipi di valore in scatola

Se i tipi di valore sono assegnati a variabili di tipo object , vengono inseriti in una scatola : il valore viene archiviato in un'istanza di System.Object . Questo può portare a conseguenze indesiderate quando si confrontano i valori con == , ad esempio:

object left = (int)1;  // int in an object box
object right = (int)1; // int in an object box

var comparison1 = left == right;      // false

Questo può essere evitato usando il metodo Equals sovraccarico, che darà il risultato atteso.

var comparison2 = left.Equals(right); // true

In alternativa, lo stesso potrebbe essere fatto unboxing delle variabili left e right modo che i valori int vengano confrontati:

var comparison3 = (int)left == (int)right; // true

Conversione di tipi di valore in box

I tipi di valore in box possono essere disgiunti solo nel loro Type originale, anche se una conversione dei due Type è valida, ad esempio:

object boxedInt = (int)1; // int boxed in an object

long unboxedInt1 = (long)boxedInt; // invalid cast

Questo può essere evitato con il primo unboxing nel Type originale, ad esempio:

long unboxedInt2 = (long)(int)boxedInt; // valid