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 “Wertnull annehmen. Will man unbedingt, dass auch ein Werttyp null annehmen kann, so kann man auf die Nullable-Typen zugreifen.

Keyword.NET-DatentypSpeicherWertebereichBemerkung
boolSystem.Boolean8 bit
1 byte
true oder false
(0xFF oder 0x00)
byteSystem.Byte8 bit
1 byte
0x0 bis 0xFF
0 bis 255
charSystem.Char16 bit
2 byte
0x0 bis 0xFFFF (ein Unicode-Zeichen)
0 bis 65.535
einzelnes Unicode-Zeichen innerhalb einfachen Anführungsstrichen (')
decimalSystem.Decimal128 bit
16 byte
(-7,9x1028 bis 7,9x1028)
/ 10x10(0 bis 28)
Suffix M
doubleSystem.Double64 bit
8 byte
-1,79769313486232x10308 bis 1,79769313486232x10308Suffix D
floatSystem.Single32 bit
4 byte
-3,402823x1038 bis 3,402823x1038Suffix F
intSystem.Int3232 bit
4 byte
0x8000 0000 bis 0x7FFFFFFF
-2.147.483.648 bis 2.147.483.647
longSystem.Int6464 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
objectSystem.Object
sbyteSystem.SByte8 bit
1 byte
0x80 bis 0x7F
-128 bis 127
shortSystem.Int1616 bit
2 byte
0x8000 bis 0x7FFF
-32.768 bis 32.767
stringSystem.StringKein oder mehrere Unicode-Zeichen innerhalb doppelten Anführungsstrichen (") - oder null.
uintSystem.UInt3232 bit
4 byte
0x0 bis 0xFFFF FFFF
0 bis 4.294.967.295
ulongSystem.UInt6464 bit
8 byte
0x0 bis 0xFFFF FFFF FFFF FFFF
0 bis 18.446.744.073.709.551.615
Suffix UL (U, L)
ushortSystem.UInt1616 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 nicht 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.

1
2
3
4
5
6
7
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
uint ul1 = 3576875224;
uint 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:

WasSuffixBeispielDatentyp
Ganzzahlohne
1
2
3
4
var t1 = 253; //int
var t2 = -3231991134; //long
var t3 = 3231991134; //uint
var t4 = 9255388339999993837; //ulong
Kleinster Datentyp aus int, uint, long und ulong
GanzzahlU
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
GanzzahlL
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
GanzzahlUL
1
var t1 = 22238984UL;
ulong
Kommazahlohne
1
var t1 = 144.33;
double
KommazahlF
1
var t1 = 24.53F;
float
KommazahlM
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.