C# Language
Inbyggda typer

Oändlig referenstypsträng

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

Värdetyp - 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';

Värdetyp - kort, int, långt (signerad 16 bit, 32 bit, 64 bitars heltal)

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

Det är också möjligt att göra dessa typer nollbara, vilket innebär att tillägg till de vanliga värdena också kan tilldelas null. Om en variabel av en nullable typ inte initialiseras kommer den att vara noll i stället för 0. Nullable typer markeras genom att lägga till ett frågetecken (?) Efter typen.

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

Värdetyp - ushort, uint, ulong (osignerad 16 bitar, 32 bitar, 64 bitars heltal)

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

Det är också möjligt att göra dessa typer nollbara, vilket innebär att tillägg till de vanliga värdena också kan tilldelas null. Om en variabel av en nullable typ inte initialiseras kommer den att vara noll i stället för 0. Nullable typer markeras genom att lägga till ett frågetecken (?) Efter typen.

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

Värdetyp - 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");
}

Bool-nyckelordet är ett alias för System.Boolean. Det används för att förklara variabler för att lagra de booleska värdena, true och false .

Jämförelser med boxade värdetyper

Om värdetyper tilldelas variabler av object de i rutan - värdet lagras i ett exempel på ett System.Object . Detta kan leda till oavsiktliga konsekvenser när man jämför värden med == , t.ex.

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

var comparison1 = left == right;      // false

Detta kan undvikas genom att använda metoden överbelastad Equals , vilket ger det förväntade resultatet.

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

Alternativt kan samma göras genom att ta bort rutan för left och right variabler så att int värdena jämförs:

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

Konvertering av boxade värdetyper

Boxade värdetyper kan endast avmarkeras i sin ursprungliga Type , även om en konvertering av de två Type är giltig, t.ex.

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

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

Detta kan undvikas genom att först ta bort rutan i den ursprungliga Type , t.ex.

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