C# Language
Eingebaute Typen

Unveränderlicher Referenztyp - Zeichenfolge

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

Werttyp - Zeichen

// 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';

Werttyp - short, int, long (vorzeichenbehaftete 16-Bit-, 32-Bit-, 64-Bit-Ganzzahlen)

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

Es ist auch möglich, diese Typen auf Null zu setzen, was bedeutet, dass zusätzlich zu den üblichen Werten auch Null zugewiesen werden kann. Wenn eine Variable mit einem nullwertfähigen Typ nicht initialisiert wird, ist sie null statt 0. Nullwertfähige Typen werden markiert, indem ein Fragezeichen (?) Nach dem Typ hinzugefügt wird.

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

Werttyp - ushort, uint, ulong (vorzeichenlose 16-Bit-, 32-Bit-, 64-Bit-Ganzzahlen)

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

Es ist auch möglich, diese Typen auf Null zu setzen, was bedeutet, dass zusätzlich zu den üblichen Werten auch Null zugewiesen werden kann. Wenn eine Variable mit einem nullwertfähigen Typ nicht initialisiert wird, ist sie null statt 0. Nullwertfähige Typen werden markiert, indem ein Fragezeichen (?) Nach dem Typ hinzugefügt wird.

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

Werttyp - 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");
}

Das Schlüsselwort bool ist ein Alias ​​von System.Boolean. Es wird verwendet, um Variablen zu deklarieren, um die booleschen Werte true und false zu speichern.

Vergleiche mit geschachtelten Werttypen

Wenn Werttypen Variablen des Typs object zugewiesen werden, werden sie in Kästchen gesetzt - der Wert wird in einer Instanz eines System.Object gespeichert. Dies kann zu unbeabsichtigten Folgen beim Vergleich von Werten mit == , zB:

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

var comparison1 = left == right;      // false

Dies kann durch die Verwendung der überladenen Equals Methode vermieden werden, die das erwartete Ergebnis liefert.

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

Alternativ können Sie auch die left und right Variable entpacken, um die int Werte zu vergleichen:

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

Konvertierung von geschachtelten Werttypen

Boxed- Value-Typen können nur in ihrem ursprünglichen Type entpackt werden, selbst wenn eine Konvertierung der beiden Type Werte gültig ist, z.

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

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

Dies kann vermieden werden, indem Sie zunächst den ursprünglichen Type entpacken, z. B .:

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