C# Datentypen

by Administrator April 30, 2009 19:30

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.Decimal 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.

Tags:

C#

Kommentare

30.04.2009 19:35:11 #

trackback

C# Datentypen

Sie wurden gekickt (eine gute Sache) - Trackback von  dotnet-kicks.de

dotnet-kicks.de |

17.06.2009 12:04:07 #

Chris

Sehr nützlich! Vielen Dank!

-------------------------------------------------
http://www.christianwirth.de

Chris Deutschland |

31.03.2012 16:48:01 #

Rodrigo Groener

In der Tabelle steht:
decimal | System.Boolean

sicher ist System.Decimal gemeint oder?

Rodrigo Groener Deutschland |

19.05.2012 13:04:10 #

Wolfgang

Natürlich, vielen Dank..

Wolfgang Deutschland |

18.07.2012 14:39:50 #

Hans

Ja ich blick überhaupt nichts!

Hans Deutschland |

Kommentare sind geschlossen

Powered by BlogEngine.NET 1.6.1.6
Theme by Mads Kristensen | Modified by Mooglegiant and me ;)