C# Datentypen

Insgesamt 15 Datentypen können direkt mit C#-Keywords beschrieben werden. Diese Schlüsselwörter sind dabei “nur” Aliasnamen für entsprechende .NET-Framework-Datentypen.

Übersicht

Die meisten Datentypen sind Werttypen (struct). Diese können die angegebenen Werte annehmen. Dagegen können Verweistypen wie string und object (und alle Klassen) zusätzlich den “Wert“ null annehmen. Will man unbedingt, dass auch ein Werttyp null annehmen kann, so kann man auf die Nullable-Typen zugreifen.

Keyword	.NET-Datentyp	Speicher	Wertebereich	Bemerkung
bool	System.Boolean	8 bit 1 byte	`true` oder `false` (0xFF oder 0x00)
byte	System.Byte	8 bit 1 byte	0x0 bis 0xFF 0 bis 255
char	System.Char	16 bit 2 byte	0x0 bis 0xFFFF (ein Unicode-Zeichen) 0 bis 65.535	einzelnes Unicode-Zeichen innerhalb einfachen Anführungsstrichen (`'`)
decimal	System.Decimal	128 bit 16 byte	(-7,9x10²⁸ bis 7,9x10²⁸) / 10x10^{(0 bis 28)}	Suffix M
double	System.Double	64 bit 8 byte	-1,79769313486232x10³⁰⁸ bis 1,79769313486232x10³⁰⁸	Suffix D
float	System.Single	32 bit 4 byte	-3,402823x10³⁸ bis 3,402823x10³⁸	Suffix F
int	System.Int32	32 bit 4 byte	0x8000 0000 bis 0x7FFFFFFF -2.147.483.648 bis 2.147.483.647
long	System.Int64	64 bit 8 byte	0x8000 0000 0000 0000 bis 0x7FFF FFFF FFFF FFFF -9.223.372.036.854.775.808 bis 9.223.372.036.854.775.807	Suffix L
object	System.Object
sbyte	System.SByte	8 bit 1 byte	0x80 bis 0x7F -128 bis 127
short	System.Int16	16 bit 2 byte	0x8000 bis 0x7FFF -32.768 bis 32.767
string	System.String			Kein oder mehrere Unicode-Zeichen innerhalb doppelten Anführungsstrichen (`"`) - oder `null`.
uint	System.UInt32	32 bit 4 byte	0x0 bis 0xFFFF FFFF 0 bis 4.294.967.295
ulong	System.UInt64	64 bit 8 byte	0x0 bis 0xFFFF FFFF FFFF FFFF 0 bis 18.446.744.073.709.551.615	Suffix UL (U, L)
ushort	System.UInt16	16 bit 2 byte	0x0 bis 0xFFFF 0 bis 65.535

bool - System.Boolean

Mit diesem Datentyp können die Werte true und false dargestellt werden.

1 2	bool bo1 = false; bool bo2 = true;

byte - System.Byte

Dieser Datentyp kann die Werte 0 bis 255 annehmen.

1 2	byte by1 = 124; byte by2 = 9;

char - System.Char

Dieser Datentyp nimmt ein einzelnes Unicode-Zeichen an. Um ein Zeichen als Literal angeben zu können, muss dieses innerhalb einfachen Anführungsstrichen (') geschrieben werden.

1
2
3

char c1 = ' '; //Leerzeichen
char c2 = '\u1249'; //Unicode-Zeichen U+1249
char c3 = '\x0043'; //Hexadezimale schreibweise

decimal - System.Decimal

Eine Datentyp, mit dem Kommazahlen dargestellt werden können, bei denen im Gegensatz zu double und float aber keine (bzw. weniger) “Rundungsfehler” auftreten. Das Suffix “M” kann zur Unterscheidung zu einer double-Zahl verwendet werden und hilft, Compiler-Warnungen zu vermeiden oder um var verwenden zu können.

1
2
3

decimal de1 = 1.23; //Compiler-Warnung
decimal de1 = 1.23M;
decimal de2 = decimal.Zero;

double - System.Double

Dieser Datentyp kann Gleitkommazahlen (IEEE 754) mit doppelter Genauigkeit aufnehmen. Double kann neben den “normalen” Werten auch die Werte double.PositiveInfinite (+∞), double.NegativeInfinite (-∞) und double.NaN (Not a Number) annehmen.

1 2	double do1 = 1.43; double do2 = 23.33;

float - System.Single

Dieser Datentyp kann Gleitkommazahlen (IEEE 754) mit einfacher Genauigkeit (single) aufnehmen. Das Suffix F wird verwendet, um zwischen double und float unterscheiden zu können. Float kann neben den “normalen” Werten auch die Werte float.PositiveInfinite (+∞), float.NegativeInfinite (-∞) und float.NaN (Not a Number) annehmen.

1 2	float fl1 = 23.44299F; float fl2 = -664.34F;

int - System.Int32

Dieser Datentyp stellt Ganzzahlen zwischen -2.147.483.648 und 2.147.483.648 dar. int ist “der” Ganzzahlendatentyp überhaupt.

1 2	int in1 = 0; int in2 = 232544;

long - System.Int64

Dieser Datentyp stellt Ganzzahlen zwischen -9.223.372.036.854.775.808 und 9.223.372.036.854.775.808 dar.

1 2	long lo1 = 234; long lo2 = -4234587;

object - System.Object

Dies ist der Basis-Datentyp des .NET-Frameworks. D.h. alle anderen Klassen leiten sich von diesem Typ ab.

1
2
3

object ob1 = null;
object ob2 = 39.2;
object ob3 = "test";

sbyte - System.SByte

Dieser Datentyp kann die Werte -128 bis 127 annehmen.

1 2	sbyte sb1 = -124; sbyte sb2 = 9;

short - System.Int16

Dieser Datentyp stellt Ganzzahlen zwischen -32.768 und +32.767 dar.

1 2	short sh1 = 123; short sh2 = -33;

string - System.String

Die string-Klasse stellt kein oder mehrere Unicode-Zeichen dar. Da es sich um einen Verweistyp handelt, kann zusätzlich der Wert null angenommen werden. Damit ist eine Unterscheidung zwischen null (nicht angegeben) und “” (leere Zeichenfolge) möglich und nötig.

string st1 = "Das ist ein Test";
string st2 = null;
string st3 = "";
string st4 = "C:\\Programs\\Microsoft Visual Studio 9.0\\";
string st5 = @"C:\Programs\Microsoft Visual Studio 9.0\";
string st6 = "Mein \"Hase\" ist Name";
string st7 = @"Mein ""Hase"" ist Name";

uint - System.UInt32

Dieser Datentyp stellt Ganzzahlen zwischen 0 und +4.294.967.295 dar.

1 2	uint ui1 = 2314543; uint ui2 = 1;

ulong - System.UInt64

Dieser Datentyp stellt Ganzzahlen zwischen 0 und +18.446.744.073.709.551.615 dar.

1 2	ulong ul1 = 3576875224; ulong ul2 = 35;

ushort - System.UInt32

Dieser Datentyp stellt Ganzzahlen zwischen 0 und +65.535 dar.

1 2	ushort us1 = 24566; ushort us2 = 66;

Nullable-Types

Das Suffix {Typ}? ist eine Kurzschreibweise für Nullable<Typ>. Damit ist es möglich, einem Werttyp so zu erweitern, dass auch null gespeichert werden kann.

Suffixe

Die Suffixe geben an, welchen Datentyp man wirklich meint. Dabei gilt folgende Tabelle:

Was Suffix Beispiel Datentyp

Ganzzahl

ohne

var t1 = 253; //int
var t2 = -3231991134; //long
var t3 = 3231991134; //uint
var t4 = 9255388339999993837; //ulong

Kleinster Datentyp aus int, uint, long und ulong

Ganzzahl

U

1
2
3

var t1 = 253U; //uint
var t2 = 7231991134U; //ulong
var t3 = -3231991134U; //long

Kleinster Datentyp aus uint und ulong
Bei negativen Zahlen keine Auswirkung

Ganzzahl

L

1
2
3

var t1 = 253L; //long
var t2 = 7231991134L; //ulong
var t3 = -3231991134L; //long

Kleinster Datentyp aus long und ulong
Compilerwarnung, wenn L klein geschrieben wird

Ganzzahl

UL

1	var t1 = 22238984UL;

ulong

Kommazahl

ohne

1	var t1 = 144.33;

double

Kommazahl

F

1	var t1 = 24.53F;

float

Kommazahl

M

1	var t1 = 44.21M;

decimal

Werttyp

?

1 2	char? c1 = 'x'; int? i1 = null;

Ein Werttyp, der auch den “Wert” null annehmen kann

Die Groß-/Kleinschreibung ist bei den Suffixen nicht relevant. Genausowenig die Reihenfolge der Buchstaben bei UL. Eine konstistente Reihenfolge und konsequente Einhaltung der Groß- oder Kleinschreibung ist aus Gründen der besseren Lesbarkeit aber mehr als empfehlenswert.