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 (siehe struct). Diese können den angegebenen Werte annehmen. Dagegen können Verweistypen wie string und object (und alle Klassen) zusätzlich den "Wert" null annehmen. Will man nun, 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.Boolean |
128 bit
16 byte |
(-7,9x1028 bis 7,9x1028) / 10x10(0 bis 28) |
Suffix M |
| double |
System.Double |
64 bit
8 byte |
-1,79769313486232x10308 bis 1,79769313486232x10308 |
Suffix D |
| float |
System.Single |
32 bit
4 byte |
-3,402823x1038 bis 3,402823x1038 |
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 oder false dargestellt werden.
bool bo1 = false;
bool bo2 = true;
byte (System.Byte)
Dieser Datentyp kann die Werte 0 bis 255 annehmen.
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.
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.
decimal de1 = 1.23; //Compiler-Warnung
decimal de1 = 1.23M;
decimal de2 = decimal.Zero;
double (System.Double)
Dieser Datentyp kann Gleitkommazahl (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.
double do1 = 1.43;
double do2 = 23.33;
float (System.Single)
Dieser Datentyp kann Gleitkommazahl (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.
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.
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.
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.
object ob1 = null;
object ob2 = 39.2;
object ob3 = "test";
sbyte
Dieser Datentyp kann die Werte -128 bis 127 annehmen.
sbyte sb1 = -124;
sbyte sb2 = 9;
short (System.Int16)
Dieser Datentyp stellt Ganzzahlen zwischen -32.768 und +32.767 dar.
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.
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.
uint ui1 = 2314543;
uint ui2 = 1;
ulong (System.UInt64)
Dieser Datentyp stellt Ganzzahlen zwischen 0 und +18.446.744.073.709.551.615 dar.
uint ul1 = 3576875224;
uint ul2 = 35;
ushort (System.UInt32)
Dieser Datentyp stellt Ganzzahlen zwischen 0 und +65.535 dar.
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 |
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 |
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 |
var t1 = 22238984UL;
|
ulong |
| Kommazahl |
ohne |
var t1 = 144.33;
|
double |
| Kommazahl |
F |
var t1 = 24.53F;
|
float |
| Kommazahl |
M |
var t1 = 44.21M;
|
decimal |
| Type |
? |
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. Dennoch sind Großbuchstaben und eine konstistente Reihenfolge aus Gründen der besseren Lesbarkeit Empfehlenswert.