C# Language
Ingebouwde typen

Onveranderlijk referentietype - tekenreeks

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

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

Waardetype - kort, int, lang (integers met 16 bits, 32 bits, 64 bits)

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

Het is ook mogelijk om deze typen nulbaar te maken, wat betekent dat naast de gebruikelijke waarden ook null kan worden toegewezen. Als een variabele van een nullable-type niet wordt geïnitialiseerd, is deze nul in plaats van 0. Nullable-typen worden gemarkeerd door een vraagteken (?) Toe te voegen na het type.

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

Waardetype - ushort, uint, ulong (niet-ondertekend 16 bit, 32 bit, 64 bit gehele getallen)

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

Het is ook mogelijk om deze typen nulbaar te maken, wat betekent dat naast de gebruikelijke waarden ook null kan worden toegewezen. Als een variabele van een nullable-type niet wordt geïnitialiseerd, is deze nul in plaats van 0. Nullable-typen worden gemarkeerd door een vraagteken (?) Toe te voegen na het type.

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

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

Het sleutelwoord bool is een alias van System.Boolean. Het wordt gebruikt om variabelen te declareren om de Booleaanse waarden true en false te slaan.

Vergelijkingen met boxtypetypen

Als waardetypes worden toegewezen aan variabelen van het type object ze in een vakje geplaatst - de waarde wordt opgeslagen in een instantie van een System.Object . Dit kan onbedoelde gevolgen hebben bij het vergelijken van waarden met == , bijvoorbeeld:

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

var comparison1 = left == right;      // false

Dit kan worden voorkomen door de overbelaste methode Equals gebruiken, die het verwachte resultaat zal geven.

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

Als alternatief kan hetzelfde worden gedaan door de left en right vinken zodat de int waarden worden vergeleken:

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

Conversie van typen boxed waarden

Boxed- waardetypen kunnen alleen in hun oorspronkelijke Type worden uitgepakt, zelfs als een conversie van de twee Type s geldig is, bijvoorbeeld:

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

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

Dit kan worden voorkomen door eerst in het oorspronkelijke Type pakken, bijvoorbeeld:

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