Aus Wikibooks

Inhaltsverzeichnis 1 Datentypen 1.1 Einfache Datentypen 1.2 Wertetypen 1.3 Verweistypen 1.4 Wozu diese Unterschiede zwischen Verweis- und Wertetyp? 2 Siehe auch

[Bearbeiten] Datentypen

Im Gegensatz zu vielen anderen Programmiersprachen ist C# eine sogenannte stark typbasierte Sprache. Das bedeutet, dass alle Variablen und Objekte einen speziellen Typ haben müssen. Im Gegensatz dazu ist beispielsweise JavaScript eine schwach typbasierte Sprache:

// JavaScript (schwach typisiert)
var x;

// Wir weisen x eine Zahl zu.
x = 1;

// Wir weisen x einen String zu.
x = "Das ist ein String.";

// C# (stark typisiert)
int x;

// Wir weisen x eine Zahl zu.
x = 1;

// Wir weisen x einen String zu.
x = "Das geht nicht, denn x wurde als int-Datentyp deklariert.";

Während JavaScript ohne zu murren schluckt, was wir geschrieben haben, würde der C#-Compiler hier schlicht die Arbeit verweigern. In C# muss man zwingend einen Datentyp angeben und sich auch daran halten. Um also das Gleiche wie in JavaScript zu erreichen, müssten wir folgendes schreiben:

// C# (stark typisiert)
int x;
string s;

// Wir weisen x eine Zahl zu.
x = 1;

// Wir weisen s einen String zu.
s = "Das ist ein String.";

Natürlich fragen wir uns nun nach dem Sinn. Wäre es nicht einfacher, wir könnten Variablen einfach zuweisen, ohne uns Gedanken machen zu müssen, welcher Datentyp gerade dargestellt wird? … Und die Antwort lautet ganz klar: „Nein! Im Gegenteil!“. Dann wäre der Compiler bei seiner Unterstützung für uns nämlich sehr stark eingeschränkt. Welche Aussage treffen wir denn mit dem folgenden Programmcode?

 c = a + b;

Werden hier Zahlen addiert? Texte und Zahlen? Oder nur Texte? Oder stecken gar Objekte von Klassen dahinter? Wird es zur Laufzeit des Programms Fehler geben, wenn eine Variable statt einer Zahl ein Objekt einer Klasse enthält? … Fragen über Fragen, die keiner beantworten kann und die zu allem Übel auch noch immer schwieriger zu beantworten sind, je umfangreicher unser Programm wird.

Also ist man in C#, den Entwicklern des .NET-Framework sei Dank, ganz ähnlich wie in Java den Weg der starken Typisierung gegangen.

Allerdings bedeutet das für uns, dass wir uns nun zwei neue Begriffe und deren Bedeutung näher anschauen und merken müssen: Werttypen und Verweistypen.
Doch vorher schauen wir uns noch schnell die einfachen Datentypen an.

[Bearbeiten] Einfache Datentypen

Einfache Datentypen sind, wie das Wort schon sagt, eben einfach. Wir kennen sie alle, oder haben sie zumindest schon mal irgendwo gesehen:

// Datentypen (Beispiele) 
bool istDatentypBool = true;
short s = 1;
int i = 2;
long l = 3l;         // l = long (kleines L)
float f = 4.1f;      // f = float
double dbl = 5.9d;     // d = double
decimal dec = 7.3m;    // m = decimal

(Der Buchstabe hinter den Zahlen sagt .NET, wie der jeweilige Datentyp initialisiert werden soll. Diese Buchstaben werden uns immer wieder begegnen, wenn wir mit Zahlen arbeiten. Zur Zeit ist das aber eher unwichtig; und man kann sie auch problemlos weglassen.)

Praktisch gibt es für jeden „normalen“ Fall einen Basisdatentyp. Dabei unterscheiden sich die „Zahlen-Datentypen“ lediglich in der Größe der Zahl, die sie aufnehmen können.

 // Ganzzahl-Datentypen

  Datentyp                    Minimal                       Maximal        Speicherplatz in Byte
------------------------------------------------------------------------------------------------
  sbyte                          -128                           127                            1
  byte                              0                           255                            1
  char                         U+0000                        U+FFFF                            2
    
  short                       -32.768                        32.767                            2
  ushort                            0                        65.535                            2

  int                  -2.147.483.648                 2.147.483.647                            4
  uint                              0                 4.294.967.295                            4

  long     -9.233.372.036.854.775.808     9.223.372.036.854.775.807                            8
  ulong                             0    18.446.744.073.709.551.615                            8

  // Gleitkomma-Datentypen

  Datentyp           Minimal          Maximal    Genauigkeit in Stellen     Speicherplatz in Byte
-------------------------------------------------------------------------------------------------
  float         ca. 1,5e -45      ca. 3,4e 38                         7                         4
  double        ca. 5,0e-324      ca. 1,7e308                     15-16                         8

  // Festkomma-Datentypen

  Datentyp           Minimal          Maximal    Genauigkeit in Stellen     Speicherplatz in Byte
-------------------------------------------------------------------------------------------------
  decimal       ca. 1,0e -28      ca. 7,9e 28                     28-29                        16

Das sind eine ganze Menge. Da aber nur wenige wirklich häufig benutzt werden, brauchen wir uns jetzt auch nur merken, dass…

	Merke int-Datentypen können "irgendwas um die +/- 2 Milliarden" aufnehmen. Für Zahlen mit Komma gibt es den Datentyp float. Für Zahlen mit Komma und hoher Genauigkeit gibt es den Datentyp decimal (z.B.: für Finanz- und Währungskalkulationen). Alle Zahlen sind Wertetypen.

Bleibt noch ein wichtiger Datentyp, der allerdings kein Wertetyp, wie die Zahlen, sondern ein Verweistyp ist:

  // Text-Datentyp

  Datentyp                    Minimal                       Maximal   
---------------------------------------------------------------------
  string                         NULL                       ca. 2GB

Und auch hier müssen wir uns jetzt nur merken:

	Merke "Alles klar, Strings reichen locker aus, wenn wir Texte haben wollen." Strings sind Verweistypen.

[Bearbeiten] Wertetypen

Für Wertetypen gibt es einen ganz einfachen Merksatz:

	Merke Wertetypen sind Typen, die Werte direkt speichern.

Wenn wir also einen Wert aus einer int-Variablen abrufen, dann schauen wir direkt auf den Speicherplatz, wo diese Variable liegt.

[Bearbeiten] Verweistypen

Auch Verweistypen kann man sich ganz leicht merken:

	Merke Verweistypen sind Typen, die nur speichern, wo sich die gespeicherten Informationen befinden, also darauf verweisen.

Wenn wir einen Verweistyp, beispielsweise einen String, abrufen, dann erhalten wir im ersten Schritt nur einen Hinweis – oder eben Verweis –, der uns sagt, wo wir die Daten im Speicher finden.

Und warum reden wir so gestelzt von Verweisen, wenn wir doch einfach Zeiger sagen könnten? Ganz einfach: Weil Zeiger etwas anderes sind. In C# unterscheiden wir zwischen den Zeigern und Verweisen aus dem ganz einfachen Grund, weil auch ein paar C++-Programmierer zu unserer Gemeinde wechseln möchten, und die verstehen unter Zeigern etwas anderes: Verweise sind bei uns .NET-sichere Zeiger. Zeiger, wie sie die C++-Programmierer kennen, können nur im unsicheren Code verwendet werden. Und weil wir in der nächsten Zeit keinen unsicheren Code schreiben wollen, lassen wir auch die Zeiger-Typen hier erst einmal weg.

[Bearbeiten] Wozu diese Unterschiede zwischen Verweis- und Wertetyp?

Denken wir mal kurz nach:

Stellen wir uns vor, wir wären Bauleiter auf einer Baustelle. Und heute früh ist eine große Ladung Steine gekommen. Mittags trudeln die Maurer ein und fragen, wo die Steine sind. Jetzt haben wir die Wahl:

• Wir bringen die Steine zu den Maurern.
• Wir zeigen den Maurern wo die Steine sind.

Was wird wohl für uns schneller und einfacher sein? Genauso ist es mit der Programmierung:

Wir haben eine riesige Datentabelle im Speicher. Jetzt wollen wir in einer anderen Methode diese Tabelle bearbeiten, indem wir eine Zeile dieser Tabelle löschen. Wäre die Datentabelle ein Werttyp, müsste .NET die gesamte Tabelle in die andere Methode rüberschaufeln. Wenn wir aber nur einen Verweis auf die Stelle übergeben, an der sich die Tabelle im Speicher befindet, können wir sie auch bearbeiten… und unser Programm wird erheblich schneller, weil wir eben nicht mehr riesige Datenberge umschaufeln müssen.

[Bearbeiten] Siehe auch

MSDN C# Referenz: Typen
MSDN C# Referenz: Datentypen
MSDN C# Referenz: Werttypen
MSDN C# Referenz: Verweistypen

MSDN C# Referenz: Verweistyp string
MSDN C# Referenz: Datentyp void
MSDN C# Referenz: Typentabellen