4 - Sprachgrundlagen

Alle Werttypen (die intern als Struktur implementiert sind) sind (indirekt) von der Klasse System.ValueType abgeleitet und besitzen deshalb auch Methoden. So lässt sich von einem Werttyp in Kurzschreibweise der konkrete Typ über die Methode GetType() bestimmen. Das Ergebnis des Methodenaufrufs ist vom Typ Type. Mittels dessen Eigenschaft Fullname können Sie den Namen des Typs ausgeben.

using System;
namespace CSharpBuch.Kap04
{
  public class WerteTypen
  {
    static void Main()
    {
      int zahl = 10;
      char c = 'A';
      double abweichung = 0.123;

      Console.WriteLine(zahl.GetType().FullName);
      Console.WriteLine(c.GetType().FullName);
      Console.WriteLine(abweichung.GetType().FullName);
      Console.ReadLine();
    }
  }
}

Als Ergebnis erhalten Sie die folgende Ausgabe:

Abbildung 4.3: Ausgabe der vollständigen Typnamen

string dateiName = "C:\\Temp\\Daten.txt";
string dateiName = @"C:\Temp\Daten.txt";

Wenn Sie diese Anwendung ausführen (dazu vorher die Zeile b = (byte) 256; auskommentieren), wird zuerst ein fehlerhafter Wert von 255 für die Variable b angezeigt und danach eine Exception ausgelöst.

using System;
public class Variablen
{
  public static void Main()
  {
    byte b = 0;
    unchecked
    {
      b = (byte)511;
      Console.WriteLine(b);
    }
    checked
    {
      b = (byte)256;           // Compilerfehler
      b = (byte)(b * 1000);    // OverflowException
      Console.WriteLine(b);
    }
  }
}

In der dritten Zeile des Beispiels wird das Boxing des int-Wertes nach object durchgeführt. Der int-Wert wird dazu in ein Int32-Objekt verpackt. Der umgekehrte Weg benötigt die Angabe eines Casts (int), um aus dem object- wieder einen int-Typ zu erzeugen. Wenn Sie versuchen, den geboxten int-Typ beispielsweise in einen byte-Typ zu konvertieren, wird eine InvalidCastException ausgelöst.

int i = 10;
object IntObj;
IntObj = i;
i = (int)IntObj;
i = (byte)IntObj;

Die Methode Addition() erwartet zwei Parameter vom Typ object, wandelt diese durch Unboxing in den entsprechenden Werttyp int um und liefert deren Summe zurück. In der Methode Addition() wird über die Methode GetType() der Typ der Parameter ausgegeben. Auf diese Weise können Sie vor dem Unboxing überprüfen, ob der korrekte Typ vorliegt. Das Boxing erfolgt bei der Parameterübergabe an die Methode Addition() automatisch.

using System;
namespace CSharpBuch.Kap04
{
  public class Boxing
  {
    static void Main(string[] args)
    {
      int ergebnis = (int)Addition(10, 11);
      Console.WriteLine("Das Ergebnis ist {0}", ergebnis);
      Console.ReadLine();
    }
    static object Addition(object zahl1, object zahl2)
    {
      int z1 = (int)zahl1;
      int z2 = (int)zahl2;
      Console.WriteLine("Die Parameter sind vom Typ {0}",
                        zahl1.GetType());
      return z1 + z2;
    }
  }
}

int zahl1 = 10 / 3;                // => zahl1 = 3
int zahl2 = 11 % 2;                // => zahl2 = 1
int zahl3 = zahl1++;               // => zahl3 = 3, zahl1 = 4
zahl3 = ++zahl1;                   // => zahl3 = 5, zahl1 = 5
int zahl4 = zahl2 > zahl3 ? 1 : 0; // => zahl4 = 0
zahl1 += zahl2;                    // => zahl1 = 6
bool ergebnis = zahl1 == zahl2;    // => ergebnis = false
zahl1 = zahl2 = zahl3;             // => zahl1 = 5, zahl2 = 5

Einfachste Ausdrücke bestehen aus Literalen oder einfachen Berechnungen.

10
"Ich bin ein Ausdruck"
((12 + 13) * 14)

Mit einer if-else-Anweisung kann z.B. die Division durch 0 verhindert werden. In diesem Fall wird der Variablen zahl2 der Wert 0 zugewiesen und eine Textausgabe durchgeführt.

using System;
namespace CSharpBuch.Kap04
{
  public class IfElseAnweisung
  {
    static void Main(string[] args)
    {
      int zahl1 = 10, zahl2 = 0;
      if(zahl2 > 0)
        zahl1 = zahl1 / zahl2;
      else
      {
        zahl1 = 0;
        Console.WriteLine("Durch 0 kann nicht geteilt werden!");
      }
    }
  }
}

Über diese Anwendung werden Sie aufgefordert, ein Akronym einzugeben, das aus dem .NET-Sprachgebrauch stammt. Die Eingabe wird über eine switch-Anweisung ausgewertet und die Anwendung danach beendet.

using System;
namespace CSharpBuch.Kap04
{
  public class SwitchAnweisung
  {
    static void Main(string[] args)
    {
      string eingabe = "";

      Console.WriteLine("Geben Sie ein .NET-Acronym ein:");
      eingabe = Console.ReadLine();
      switch(eingabe)
      {
        case "CLR": Console.WriteLine("Common Language Runtime");
                    break;
        case "CTS": Console.WriteLine("Common Type System");
                    break;
        case "CLS": Console.WriteLine("Common Language Spec.");
                    break;
        default: Console.WriteLine("Keine bekannte Abkürzung"); 
                 break;
      }
    }
  }
}

Die Zählvariable i wird während der Initialisierung mit dem Wert 1 vorbelegt. Die Anweisungen der for-Schleife werden so lange ausgeführt, wie der Wert 11 durch i nicht erreicht wird. Bei jedem Schleifendurchlauf wird der Wert von i um 1 erhöht. Die Schleife wird also zehnmal durchlaufen.

int i;
for(i = 1; i < 11; i++)
{
  // tue etwas
}

Die Grenzen für das Abbruchkriterium können auch durch Variablen festgelegt werden. So könnte sich z.B. der Wert der Variablen Ende bei jedem Aufruf der for-Schleife ändern. Das Abbruchkriterium besteht aus Ausdrücken, die über den Operator & miteinander verknüpft werden. Die Initialisierung wurde etwas "komplexer" formuliert und ist nicht nur auf die Inkrementierung eines Wertes wie i++ beschränkt.

int ende = 11;
for(int i = 0, j = 0; (i < 11) & (j < ende); i += 2, j = i + 1)
  Console.WriteLine(i * j); 

In diesem Beispiel werden die Produkte der Zahlen 1 bis 10 auf der Konsole ausgegeben.

using System;
namespace CSharpBuch.Kap04
{
  public class ForAnweisung
  {
    static void Main(string[] args)
    {
      for(int i = 1; i <= 10; i++)
        Console.WriteLine(i + " * " + i + " = " + i * i);      
    }
  }
}

In der Methode Main() wird zunächst ein Array (Arrays werden später noch genauer besprochen) aus drei Strings (Hasennamen) erstellt. Dann wird das Array über eine for- und eine foreach-Schleife durchlaufen. Der Vorteil der foreach-Schleife liegt vor allem darin, dass Sie sich nicht um die Laufvariable und die Länge des Arrays kümmern müssen.

using System;
namespace CSharpBuch.Kap04
{
  public class ForEachAnweisung
  {
    static void Main(string[] args)
    {
      string[] hasenListe = {"Nelly", "Daisy", "Mandy"};
      for(int i = 0; i < hasenListe.Length; i++)
        Console.WriteLine(hasenListe[i]);
      foreach(string hase in hasenListe)
        Console.WriteLine(hase);
    }
  }
}

Die folgende Anwendung bestimmt die Anzahl der Zeichen einer vom Benutzer eingegebenen Zeichenkette. Dies wird so lange durchgeführt (aber mindestens einmal - deshalb die do-while- Anweisung), bis der Benutzer die Zeichenkette Ende eingibt.

using System;
namespace CSharpBuch.Kap04
{
  public class WhileAnweisung
  {
    static void Main(string[] args)
    {
      string eingabe = "";
      Console.WriteLine("Anzahl der Zeichen bestimmen...");
      Console.WriteLine("Die Eingabe >Ende< beendet die Anwendung");
      do
      {
        Console.WriteLine("Bitte geben Sie einen Text ein: ");
        eingabe = Console.ReadLine();
        Console.WriteLine("Zeichenzahl: " + eingabe.Length);
      } while(eingabe != "Ende");
    }
  }
}

Es werden alle Zahlen zwischen 1 und 100 ausgegeben, die ohne Rest durch 2 teilbar sind. Mittels break wird geprüft, ob bereits der obere Grenzwert von 100 überschritten wurde. In diesem Fall wird die Anwendung beendet. Über die continue-Anweisung wird zum nächsten Schleifendurchlauf verzweigt, wenn die aktuelle Zahl nicht ohne Rest durch 2 teilbar ist.

using System;
namespace CSharpBuch.Kap04
{
  public class BreakContinueAnweisung
  {
    static void Main(string[] args)
    {
      int zahl = 0;
      do
      {
        if(zahl > 100)
          break;
        zahl++;
        if((zahl % 2) != 0)
          continue;
        Console.WriteLine(zahl);
      }
      while(true);
    }
  }
}

Das Beispiel gibt so lange das Produkt der Zahlen i und j aus, bis es größer als 30 wird. In diesem Fall werden beide for-Schleifen verlassen und die Programmausführung wird mit der Anweisung nach der Marke Ende fortgesetzt.

for(int i = 1; i < 11; i++)
{
  for(int j = 1; j < 11; j++)
  {
    if((i * j) > 30)
      goto Ende;
    else
      Console.WriteLine(i * j); 
  }  
}
Ende: 
Console.WriteLine("Fertig");

Zum Testen einer Anwendung sollen spezielle Ausgaben durchgeführt werden. Außerdem soll eine einfache Möglichkeit geschaffen werden, diese Ausgaben wieder zu deaktivieren. Mittels Direktiven werden sie nicht nur deaktiviert, sondern auch nicht vom Compiler berücksichtigt. Zu Beginn wird das Symbol TEST definiert. Um es zu deaktivieren, z.B. wenn es in einer anderen Datei oder in den Projektoptionen definiert wurde, verwenden Sie die darunter angegebene Direktive #undef. Über die Direktive #if wird auf die Existenz des Symbols TEST geprüft. Ist es definiert, wird die darauf folgende Ausgabe durchgeführt. Durch die Angabe des #else-Zweigs wird eine Ausgabe erzeugt, wenn das Symbol nicht definiert ist.

#define TEST
// #undef TEST
using System;
namespace CSharpBuch.Kap04
{
  public class Direktiven
  {
    static void Main(string[] args)
    {
      #if TEST
      Console.WriteLine("TEST ist definiert.");
      #else
      Console.WriteLine("TEST ist NICHT definiert.");
      #endif
    }
  }
}

#region Hier beginnt ein CodeBlock
...
#endregion

Der folgende Ausschnitt deaktiviert eine Warnung, die daraus resultiert, dass die Variable i nicht weiter verwendet wird: Das Feld "CSharpBuch.Kap04.Direktiven.i" wird nie verwendet. Um diese Warnung zu deaktivieren, wird hinter die Direktive #pragma warning die Angabe disable sowie die Warnnummer angegeben.

#pragma warning disable 169
static int i;
static void Main(string[] args)
{
  ...

In einem unsicheren Block wird ein Zeiger auf die verwaltete Variable quelle1 erzeugt. Da die Variable den Wert 10 enthält, zeigt der Zeiger ebenfalls auf diesen Wert. Wenn der Variablen ziel über *zeiger1 der Inhalt des Zeigers zugewiesen wird, besitzt dann auch die Variable ziel den Wert 10, d.h., es ist eine echte Kopie. Im zweiten Teil wird der gleiche Vorgang noch einmal mit einer Variablen quelle2 durchgeführt. Da es sich um eine lokale Variable handelt, ist keine Angabe von fixed notwendig.

using System;
namespace CSharpBuch.Kap04
{
  public class Unsicher
  {
    static int quelle1 = 10, ziel;
    static void Main(string[] args)
    {
      unsafe
      {
        fixed(int* zeiger1 = &quelle1)
        {
          ziel = *zeiger1;
          Console.WriteLine("Ziel hat den Wert: " + ziel);
        }

        int quelle2 = 20;
        int* zeiger2;
        zeiger2 = &quelle2;
        ziel = *zeiger2;
        Console.WriteLine("Ziel hat jetzt den Wert: " + ziel);
      }
    }
  }
}