C# ist ein Akronym für den, in der Musik durch ein Kreuz um einen Halbton erhöhten Ton c, das cis - im Englisch "C sharp" ("scharfes C"). Teilweise wird C# auch mit "see sharp" übersetzt oder im deutschen Sprachgebrauch von wenigen Entwicklern "cis" genannt.

Table of contents

1 Konzept 2 Sprachelemente 2.1 Notationsregeln 2.2 Quellcode 2.2.1 Zeichensatz 2.2.2 Unicode 2.3 Schlüsselworte 2.3.3 if, elseif, else (Bedingte Ausführung) 2.3.4 for, while, do (Schleifen) 2.3.5 continue, break, goto 2.3.6 return, throw (Sprünge) 2.3.7 switch, case (Aufzählung) 2.4 Objekte und Klassen 2.4.8 Die Klasse object 2.4.9 Konstruktor 2.4.10 Destruktor 2.4.11 Das Schlüsselwort static 2.4.12 Das Schlüsselwort new 2.4.13 Das Schlüsselwort this 2.5 Schnittstellen (interface) 2.6 Strukturen (Struct) 2.6.14 Flags 2.7 Aufzählungstypen (Enumerationen) 2.8 Zugriffsmodifikatoren 2.9 Datentypen, Eigenschaften und Konstanten 2.9.15 Datentypen und Speicherbedarf 2.9.16 Konstanten (Schlüsselwort const) 2.9.17 Eigenschaften (Schlüsselworte get, set und value) 2.9.18 Die Klasse string 2.9.19 Escape-Sequenzen 2.10 Methoden 2.10.20 Parameter 2.10.21 Die Schlüsselworte in, out, ref 2.10.22 Parameterlisten 2.10.23 Rückgabewert 2.11 Indexer und Arrays (Felder) 2.12 Ereignisse und Delegate 2.13 Operatoren 2.14 Sichtbarkeit 2.14.24 Namensräume (Namespaces) 2.14.25 Schlüsselwort using 2.15 Vererbung 2.15.26 Abstrakte Klassen 2.15.27 Interfaces 2.15.28 Das Schlüsselwort override 2.15.29 Das Schlüsselwort base 2.15.30 Das Schlüsselwort sealed 2.15.31 Casting (Konvertierung) 2.15.32 Überladen vs Überschreiben 2.15.33 Mehrfachvererbung 2.16 Exception-Handling (Ausnahmen) 2.17 Assemblies 2.18 Attribute (Metadaten) 2.19 Shared Libraries (DLLs) 2.20 Kommentare und Dokumentation 3 Verfügbare Klassenbibliotheken 4 Verfügbarkeit (IDEs) 5 Weblinks

Konzept

Neben Konzepten der Programmiersprache Java, greift C# auch Konzepte aus C++ sowie der Microsoft-eigenen propietären Sprache VisualBasic auf. Beide Programmiersprachen sind ebenfalls, neben weiteren, als eigenständige Portierungen im .NET Framework verfügbar und nutzbar.

Als eine (favorisierte) Sprache der .NET Plattform, wird C# mittels einer virtuellen Laufzeitumgebung (runtime environment) in Form einer virtuellen Maschine (VM) ausgeführt. Durch die Verwendung einer virtuellen Maschine ist es möglich, ein Programm unabhängig von der Plattform (Betriebssystem, Prozessorarchitektur) auszuführen. Ein Programm, das beispielsweise unter dem Betriebssystem Windows auf einer Intel-Architektur entwickelt wurde, kann somit auch auf einem MacOS X-System auf einer PowerPC (PPC)-Architektur ausgeführt werden. Diese Plattformunabhängigkeit ist bei C# bisher aber kaum gegeben, da der Hersteller Microsoft die .NET Plattform nur für seine eigene Produktlinie Windows anbietet. Eine Laufzeitumgebung für das Betriebssystem Linux (und Derivate) steht aber in Form des Mono-Projekts in Aussicht, das vom Hersteller Ximian begonnen wurde. Nur lizenzrechtliche Probleme könnten zum Scheitern dieser Portierung führen.

Was C# von Java und C++ abhebt, ist die Tatsache, dass sowohl Klassen als auch Datentypen, wie in Smalltalk, durch Objekte repräsentiert werden. Ein weiterer Unterschied ist, dass in C# mit Attributen gearbeitet werden kann. Attribute erlauben es, einem Objekt Funktionalität hinzuzufügen, ohne seine Schnittstelle zu verändern. Man spricht hierbei auch von Metadaten.

Einige der Elemente von C++, die im allgemeinen als unsicher gelten, wie beispielsweise Zeiger-Arithmetik, wurden in C# nur für so genannten "unsafe code" (unmanaged code) erlaubt. Dieser benötigt eine veränderte Sicherheitseinstellung, um auf einem Zielsystem ausgeführt zu werden, und einen zusätzlichen Compiler-Schalter, um ihn zu übersetzen. Somit wird vermieden, dass sich versehentlich unsicherer Code in eine Anwendung einschleicht.

Sprachelemente

Zu Beginn der Klassiker aller Programme in C#: {| style="background:#EEEEEE;" | using System;

class HalloWelt
{
    static void Main()
    {
        Console.WriteLine("Hallo Welt");
    }
} |}

Notationsregeln

if, elseif, else (Bedingte Ausführung)

if (Bedingung) {
    Anweisungen;
}
[else if (Bedingung) {
    Anweisungen;
}]
[else {
    Anweisungen;
}]

for (Startausdruck; Gültigkeitsbedingung; Inkrementierungsausdruck) {
    Anweisungen;
}

while (Bedingung) {
    Anweisungen;
}

do {
    Anweisungen;
} while (Bedingung);

Die Klasse object

Zugriffsmodifikatoren regeln den Zugriff auf Klassen und deren Mitglieder (Methoden, Eigenschaften, Variablen, Felder und/oder Ereignisse) in C#. Die folgende Tabelle führt die von C# unterstützten Zugriffsmodifikatoren auf und beschreibt deren Wirkung und den Sichtbarkeitskontext. {| style="background:#DDEEFF;border:1px solid black;" |----- valign="top" ! Name ! Wirkung |----- valign="top" | internal || internal beschränkt den Zugriff auf Klassen und deren Mitglieder auf eine Assembly. Im einfachsten Falle ist das die aktuelle Klasse (sofern kein Namespace definiert wurde), andernfalls ist der Zugriff auf den aktuellen Namespace und dessen Mitglieder beschränkt (unter Java entspricht das der Beschränkung auf ein package). |----- valign="top" | private || Beschränkt den Zugriff auf eine Klasse und deren Mitglieder. Eine mit private deklarierte Klasse kann nur innerhalb der Klasse selbst instanziiert werden (beispielsweise kann ein öffentlicher Konstruktor einer Klasse, oder die statische Main-Methode, einen privaten Konstruktor aufrufen, der aber nicht von außen aufgerufen werden kann. Oft wird private verwendet, um das Singleton-Pattern umzusetzen (z. B. bei der Verwendung einer Klasse als Fabrik; siehe Factory-Pattern) oder die Vererbung zu beeinflussen oder zu verbieten (siehe auch Schlüsselwort sealed). Hinweis: Eine abgeleitetet Klasse kann auf private Mitglieder der Oberklasse (vgl. Schlüsselwort base) ebenfalls nicht zugreifen. Soll ein solcher Zugriff möglich sein, so muss der Zugriffsmodifizierer protected verwendet werden. |----- valign="top" | protected || Dieser Modifikator ist mit dem Modifikator private identisch, bis auf einen Unterschied. Sofern die Klasse nicht mit dem Schlüsselwort sealed gegen das Beerben "versiegelt" wurde, können auch abgeleitete Klassen auf die Mitglieder einer Oberklasse (vgl. Schlüsselwort base) zugreifen oder diese überschreiben. Ansonsten ist die Sichtbarkeit auf die Klasse selbst beschränkt. |----- valign="top" | public || Auf als public gekennzeichnete Klasse oder Klassenmitglieder (z. B. Methoden oder Eigenschaften), kann unbeschränkt zugegriffen werden. Sie werden deshalb auch als "öffentlich" bezeichnet. Eine Klasse die eine statische Main-Methode enthält oder sonstige statische Methoden, muss immer als public deklariert werden, da sonst kein Zugriff möglich ist und es zu einem Fehler kommt. |}

Hinweise:

• Standardmäßig sind Klassenmitglieder (Methoden, Eigenschaften usw.), denen kein Zugriffsmodifikator zugewiesen wurde, automatisch als private deklariert. Klassen selbst dagegen besitzen automatisch den Modifikator internal und sind nur im aktuellen Namensraum (Namespace) sichtbar.

• Die Modifikatoren können bis auf protected und internal nicht kombiniert werden. protected internal spielt im Zusammenhang mit der Vererbung von Komponenten eine Rolle. Die Sichtbarkeit der beerbeten Klasse wird von der erbenden Klasse übernommen.

• Schnittstellen (interfaces) sind immer öffentlich definiert. Die Zuordnung eines Zugriffsmodifikators (mit Ausnahme von public) ist nicht zulässig.

Datentypen, Eigenschaften und Konstanten

C# kennt zwei Arten von Datentypen: Wertetypen (value types) und Referenztypen (reference types). Referenztypen dürfen dabei nicht mit Zeigern (pointer) gleichgesetzt werden, wie sie u. a. aus der Sprache C/C++ bekannt sind. Diese werden von C# zwar auch unterstützt, aber nur im unsicheren Modus (unsafe mode).

Wertetypen enthalten die Daten direkt, wobei Referenztypen im Gegensatz dazu nur Verweise auf die eigentlichen Daten, oder besser, Objekte darstellen. Bei Lesen und Schreiben von Wertetypen werden die Daten dagegen über einen Automatimus, Boxing genannt, in einer Instanz der jeweiligen Wrapper-Klasse gespeichert oder aus ihr geladen.

Die Zuweisung eines Wertes bzw. einer Referenz kann während der Deklaration erfolgen oder später, sofern die Variable nichts als Konstante deklariert wurde. Die Deklaration erfolgt durch Angabe eines Datentyps gefolgt von einem Variablennamen: {| style="background:#EEEEEE;" | // Datentyp Variable;
int i;
System.Collections.IList liste;
|}

Es können auch mehrere Variablen des gleichen Typs zeitgleich deklariert werden: {| style="background:#EEEEEE;" | // Datentyp Variable1, Variable2, ...;
int i, j, k;
System.Collections.IList liste1, liste2;
|}

Ferner besteht die Möglichkeit, der Variablen bei der Deklaration auch gleich einen Wert oder eine Referenz zuzuweisen (Initialwert): {| style="background:#EEEEEE;" | // Datentyp Variable=Wert/Referenz;
int i = 5;
int j = 2, k = 3;
System.Collections.IList liste = new System.Collections.ArrayList();
|}

Auch die Mehrfachzuweisung eines Wertes an verschiedene Variablen ist möglich: {| style="background:#EEEEEE;" | int i, j, k;
i = j = k = 123;
|}

Einen Sonderfall der Zuweisung stellt die Deklaration von Feldern (Arrays) dar. Näheres hierzu im entsprechenden Abschnitt.

Datentypen und Speicherbedarf

Konstanten (Schlüsselwort const)

Eine Konstante kann dabei sowohl ein Wertetyp sein (also ein einfacher Datentyp), als auch ein Referenztyp, der auf ein Objekt verweist. Das Schlüsselwort const sichert dabei nur, dass die Referenz nicht veränderbar ist, aber schützt nicht vor Änderungen am referenzierten Objekt. So kann beispielsweise einer Konstanten die Referenz auf eine Liste zugewiesen werden, aber es sind weiterhin Änderungen an der Liste selbst möglich (z. B. das Hinzufügen oder das Löschen von Listenelementen). {| style="background:#EEEEEE;" | using System;
using System.Collections;

public class ConstBeispiel
{
    public static void Main()
    {
        // Neue Konstante erstellen
        const IList liste = new ArrayList();

        // Der Liste zwei Elemente hinzufügen
        liste.Add("Element 1: string");
        liste.Add("Element 2: string");

        // FEHLER: Versuch der Variablen liste
        // eine neue Referenz zuzuweisen
        liste = new ArrayList();
    }
} |}

Das Schlüsselwort const existiert auch in anderen Sprachen (z. B. C++) oder es existieren vergleichbare Schlüsselworte (z. B. final in der Programmiersprache Java oder PARAMETER in Fortran).

Eigenschaften (Schlüsselworte get, set und value)

Eigenschaften (properties) sind Sichten auf öffentliche Variablen einer Klasse. Da es in der objektorientierten Programmierung schlechter Stil ist, Variablen public zu deklarieren, weil somit unkontrolliert Wertänderungen durch Klasseninstanzen (Objekte) erfolgen können, bietet C# die aus VisualBasic bekannten Eigenschaften. Die Variable selbst wird durch einen Zugriffsmodifizierer wie private oder protected (bei Variablen, die in abgeleiteten Klassen überschreiben werden sollen) für den Zugriff von außen gesperrt und über eine Eigenschaft zugänglich gemacht. Über die Eigenschaft kann dann bestimmt werden, ob ein lesender oder schreibender Zugriff auf die referenzierte Variable erfolgen darf. Natürlich sind auch beide Möglichkeiten kombinierbar.

Eine Eigenschaft wird durch Zuweisung eines Datentyps (der dem Datentyp der Variable entsprechen muss) zu einem Eigenschaftsnamen angelegt und hat eine ähnliche Struktur wie die Syntax einer Methode. Die Eigenschaft ist dabei wie eine Variable ansprechbar und ihr kann auch ein Zugriffsmodifizierer zugewiesen werden. Eine Eigenschaft enthält aber selbst keine Daten, sondern bildet diese auf die referenzierte Variable ab (vergleichbar mit einem Zeiger).

Zur Abfrage einer Eigenschaft existiert in C# das Schlüsselwort get und zum Setzen eines Wertes das Schlüsselwort set. Von außen stellt sich die Eigenschaft dann wie eine Variable dar und der Zugriff kann entsprechend erfolgen (vgl. VisualBasic).

Die Programmiersprache Java verfolgt mit den Set- und Get-Methoden (Bean-Pattern, Introspection) das gleiche Ziel - alle Zugriffe erfolgen nie direkt über eine Variable, sondern über die entsprechende Methode (OOP, Sichtbarkeit).

Beispiel einer Eigenschaftsdefinition Wohnort für eine private Variable (_wohnort): {| style="background:#eeeeee;" | public class EigenschaftBeispiel
{
    private string _wohnort;
    
    public string Wohnort
    {
        get
        {
            return (_wohnort);
        }
        set
        {
            _wohnort = "12345 " + value;
        }
    }
} |}

Durch das "Weglassen" des Schlüsselwortes set oder des Schlüsselwortes get kann gesteuert werden, ob die Eigenschaft nur gelesen oder nur geschrieben werden darf. Das Schlüsselwort value ist dabei ein Platzhalter für den der Eigenschaften zugewiesenen Wert, der gesetzt werden soll. Er kann nur in Verbindung mit dem Schlüsselwort set im entsprechenden Block verwendet werden (und entspricht in etwa einer temporären lokalen Variable).

Beispiel für den Zugriff auf die oben definierte Eigenschaft Wohnort: {| style="background:#eeeeee;" | EigenschaftBeispiel instanz = new EigenschaftBeispiel();
instanz.Wohnort = "Musterstadt";
System.Console.WriteLine(instanz.Wohnort);
// Ausgabe: 12345 Musterstadt
|}

Würde bei der oben gemachten Definition der Eigenschaft 'Wohnort' der get-Block weggelassen, so würde der lesende Zugriff zu einem Zugriffsfehler führen (im Beispiel in der Zeile, in der die Ausgabe erfolgt).

Neben dem einfachen Setzen oder Lesen einer Eigenschaft, können im set-Block bzw. get-Block auch Operationen ausgeführt werden, beispielweise die Potenzierung eines bei set übergebenen Wertes (value mal Exponent), bevor er der Variablen zugewiesen wird. Das gleiche gilt für das Schlüsselwort get. Theoretisch kann somit ein Zugriff für den Benutzer einer Klasse ganz unerwartete Ergebnisse bringen. Deshalb sollten alle Operationen, die Veränderungen auf einen Wert durchführen über normale Methoden abgebildet werden. Ausgenommen sind natürlich Wertprüfungen bei set.

Das Beispiel konkateniert den der Eigenschaft übergebenen Wert (hier: Musterstadt) zur Zeichenkette "12345 ". Diese Aktion ist syntaktisch und semantisch richtig, aber sollte dennoch in einer Methode ausgeführt werden.

Die Klasse string

Escape-Sequenzen

Zeilenkommentare beginnen dabei mit zwei aufeinanderfolgenden Schrägstrichen (//) und enden in der gleichen Zeile mit dem Zeilenumbruch. Alles was nach den Schrägstrichen folgt, wird bis zum Zeilenende als Kommentar angesehen und vom Compiler übergangen.

Blockkommentare, die sich über mehrere Zeilen erstrecken können, beginnen mit der Buchstabenkombination /* und enden mit */.

Sowohl Zeilen- als auch Blockkommentare können zu Beginn, aber auch mitten in einer Zeile beginnen. Blockkommentare können in der selben Zeile enden und es kann ihnen Sourcecode folgen, der vom Compiler ausgewertet wird. Alles was innerhalb des Blockkommentars steht wird vom Compiler übergangen. {| border="0" style="background:#eeeeee;" |

1. // Dies ist ein Zeilenkommentar, der mit dem Zeilenumbruch endet

2. System.Console.WriteLine("Ein Befehl"); // Ein Zeilenkommentar am Zeilenende

3. /* Dies ist ein Blockkommentar, der in der gleichen Zeile endet */

4. System.Console.WriteLine("Ein weiterer Befehl"); /* Ein mehrzeiliger
Blockkommentar */System.Console.WriteLine("Noch einer");

5. System.Console.WriteLine("Befehl 1"); /* Kommentar */ System.Console.WriteLine("Befehl 2");

Hinweis: Es sind auch Kommentare innerhalb eines Befehls, z. B. zur Kommentierung einzelner Methodenparameter möglich. Diese Art von Kommentaren sollte aber aus Gründen der Lesbarkeit und Wartbarkeit vermieden werden. Zur Dokumentation von Methoden stellt C# in Form von Metadaten (Attribute) einen Mechanismus bereit, der es ermöglicht, eine XML-basierte Dokumentation erzeugen zu lassen.

Verfügbare Klassenbibliotheken

• Collection
• Threads
• Reflection
• CodeDOM

• ADO.NET
• ASP.NET
• Windows.Forms

• C#-Builder von Borland
• Open Source-IDE SharpDevelop ( http://www.icsharpcode.net/OpenSource/SD/Default.aspx ).

• [1] Tutorial zur Programmiersprache C#. Enthält eine strukturierte Referenz aller Befehle und Schlüsselwörter.