Quelltext der Seite Sprachelemente von C-Sharp

{{Überarbeiten}}
Dieser Artikel bietet eine Übersicht einiger '''Sprachelemente von [[C-Sharp|C#]]'''.

== Bedingte Ausführung (if, else, switch) ==
Der <code>if</code>-Block hat zur Folge, dass Anweisungen zwischen geschweiften Klammern nur in Kraft treten, wenn die angegebene Bedingung erfüllt ist, also ihr Wert <code>true</code> ist.

Der <code>else</code>-Block kann nur in Verbindung mit einem <code>if</code>-Block stehen und wird nur ausgeführt, wenn die Anweisungen des if-Blocks ''nicht'' ausgeführt wurden.

<syntaxhighlight lang="csharp">
if (Bedingung)
{
    Anweisungen;
}
else if (Bedingung)
{
    Anweisungen;
}
else
{
    Anweisungen;
}
</syntaxhighlight>

Die <code>switch</code>-Anweisung stelle eine Fallunterscheidung dar, welche je nach Wert des Ausdrucks, andere Anweisungen ausgeführt.

Es wird immer bei dem <code>case</code>-Label fortgefahren, dessen Wert mit dem Ausdruck in der <code>switch</code>-Anweisung übereinstimmt. Wenn kein Fall zutrifft, wird zum optionalen <code>default</code>-Zweig gesprungen.

<syntaxhighlight lang="csharp">
switch (Ausdruck)
{
    case Fall_1:
        Anweisungen;
        break;
    case Fall_2:
        Anweisungen;
        break;
    default:
        Anweisungen;
        break;
}
</syntaxhighlight>

Im Gegensatz zu C und C++ hat die C#-<code>switch</code>-Anweisung keine ''fall-through''-Semantik. Nicht-leere Zweige müssen mit einem <code>break</code>, <code>continue</code>, <code>goto</code>, <code>throw</code> oder <code>return</code> enden; leere Zweige können jedoch von weiteren case-Zweigen fortgesetzt werden, um mehrere Fälle mit einem Satz von Anweisungen zu behandeln:

<syntaxhighlight lang="csharp">
switch (Ausdruck)
{
    case Fall_1:
    case Fall_2:
        Anweisungen;
        break;
}
</syntaxhighlight>

In C# sind auch Strings als Prüfausdruck erlaubt:

<syntaxhighlight lang="csharp">
string cmd;
//...
switch (cmd)
{
    case "run":
        Anweisungen;
        break;
    case "save":
        Anweisungen;
        break;
    default:
        Anweisungen;
        break;
}
</syntaxhighlight>

== Schleifen (for, do, while, foreach) ==
Wird eine <code>for</code>-Schleife ausgeführt, wird zuerst der Startausdruck gültig. Ist dieser vollständig bearbeitet, werden die Anweisungen im Schleifenrumpf und anschließend der Inkrementierungsausdruck solange wiederholt abgearbeitet, bis die Gültigkeitsbedingung <code>false</code> ergibt, d.&nbsp;h., ungültig wird.

<syntaxhighlight lang="csharp">
for (Startausdruck; Gültigkeitsbedingung; Inkrementierungsausdruck)
{
    Anweisungen;
}
</syntaxhighlight>

Die <code>while</code>-Schleife ist dagegen recht primitiv: sie wiederholt die Anweisungen, solange die Bedingung <code>true</code> zurückgibt. Die Bedingung der <code>while</code>-Schleife wird immer ''vor'' dem Anweisungsblock ausgewertet. Wenn die Bedingung von Anfang an nicht erfüllt ist, wird der Schleifenrumpf nicht durchlaufen.

<syntaxhighlight lang="csharp">
while (Bedingung)
{
    Anweisungen;
}
</syntaxhighlight>

Die Bedingung der [[Schleife (Programmierung)|Do-While-Schleife]] wird immer nach dem Anweisungsblock geprüft. Die Schleife wird daher mindestens ein Mal durchlaufen.

<syntaxhighlight lang="csharp">
do
{
    Anweisungen;
} while (Bedingung);
</syntaxhighlight>

Mit der <code>foreach</code>-Schleife wird durch alle Mitglieder einer [[Folge (Mathematik)|Sequenz]] [[Iteration|iteriert]]. In der Schleife besteht nur lesender Zugriff auf die Schleifenvariable.

<syntaxhighlight lang="csharp">
foreach (Typ Variablename in Sequenz)
{
    Anweisungen;
}
</syntaxhighlight>

== Die Sprunganweisungen ''break'', ''continue'', ''goto'', ''return'', ''yield'' ''return''/''break'' ==
<syntaxhighlight lang="csharp">
for (int i = 0; i < 10; ++i)
{
    if (i < 8)
        continue;
    Console.WriteLine("Continue wurde nicht ausgeführt.");
}
</syntaxhighlight>

Die Anweisung <code>continue</code> veranlasst den nächsten Durchlauf einer Schleife (Dabei wird der restliche Code im Schleifenkörper nicht abgearbeitet). Im Beispiel wird der Text nur zweimal ausgegeben.

<syntaxhighlight lang="csharp">
for (int i = 0; i < 100; ++i)
{
    if (i == 5)
        break;
    Console.WriteLine(i);
}
</syntaxhighlight>

Die Anweisung <code>break</code> veranlasst das Programm, die nächste umschließende Schleife (oder das umschließende ''switch'') zu verlassen. In diesem Beispiel werden nur die Zahlen 0, 1, 2, 3 und 4 ausgegeben.

<syntaxhighlight lang="csharp">
int a = 1;
Top:
a++;
if (a <= 5)
    goto Top;
Console.WriteLine("a sollte jetzt 6 sein.");
</syntaxhighlight>

Mit <code>goto</code> springt das Programm an das angegebene Sprungziel.

Die Benutzung von <code>goto</code> sollte jedoch möglichst vermieden werden, da dadurch der Quellcode in der Regel unleserlicher wird. Es gilt jedoch als akzeptiertes Sprachmittel, um tief verschachtelte Schleifen zu verlassen, da in diesen Fällen der Code mit <code>goto</code> lesbarer ist als durch mehrfache Verwendung von <code>break</code> oder anderen Sprachmitteln. Siehe auch [[Spaghetticode]].

Innerhalb einer <code>switch</code>-Anweisung kann mittels <code>goto case</code> bzw. <code>goto default</code> zu einem der Fälle gesprungen werden.

<syntaxhighlight lang="csharp">
int result = ImQuadrat(2);

static int ImQuadrat(int x)
{
    int a;
    a = x*x;
    return a;
}
</syntaxhighlight>

Mit <code>return</code> wird die aktuelle Methode verlassen und der im Kopf der Methode vereinbarte Referenz- bzw. Wertetyp als Rückgabewert zurückgeliefert. Methoden ohne Rückgabewert werden mit dem [[Schlüsselwort (Programmierung)|Schlüsselwort]] <code>void</code> gekennzeichnet.

Eine Besonderheit bildet der Ausdruck <code>yield return</code>. Zweck ist es, in verkürzter Schreibweise eine Rückgabesequenz für eine Methode oder eine Eigenschaft zu erzeugen. Der Compiler nutzt hierzu einen eigenen Typ, der von <code>System.Collections.Generic.IEnumerable<T></code> abgeleitet ist und somit mit einem <code>foreach</code>-Block durchlaufen werden kann. Jeder Aufruf von <code>yield return</code> fügt bis zum Verlassen der Methode/Eigenschaft ein neues Element der Sequenz hinzu. Wird das Konstrukt nicht einmal aufgerufen, ist die Sequenz leer:

<syntaxhighlight lang="csharp">
private int[] zahlen = new int[] { 5980, 23980 };

public IEnumerable<int> ZahlenMinusEins
{
    get
    {
        foreach (int zahl in this.zahlen)
        {
            yield return zahl - 1;
        }
    }
}

public IEnumerable<double> ToDouble(IEnumerable<int> intZahlen)
{
    foreach (int zahl in intZahlen)
    {
        yield return (double)zahl;
    }
}
</syntaxhighlight>

Hierdurch muss keine temporäre Liste erzeugt werden, die die umgewandelten Zahlen erst zwischenspeichert und dann zurückgibt:

<syntaxhighlight lang="csharp">
private int[] zahlen = new int[] { 5980, 23980 };

// bspw. aus einer Eigenschaft heraus
public IEnumerable<int> ZahlenMinusEins
{
    get
    {
        List<int> rückgabe = new List<int>();

        foreach (int zahl in this.zahlen)
        {
            rückgabe.Add(zahl −1);
        }

        return rückgabe;
    }
}
</syntaxhighlight>

Jedes Element, das zurückgegeben wird, muss implizit in den Typ der Rückgabesequenzelemente konvertierbar sein.

Zum Abbrechen des Vorgangs kann die Anweisung <code>yield break</code> verwendet werden:

<syntaxhighlight lang="csharp">
// bspw. aus einer Methode heraus
public IEnumerable<double> ToDouble(IEnumerable<int> intZahlen)
{
    int i = 0;
    foreach (int zahl in intZahlen)
    {
        if (i++ == 3)
        {
            // nach 3 Durchläufen beenden
            yield break;
        }

        yield return (double)zahl;
    }
}
</syntaxhighlight>

Die Anweisungen <code>return</code> und <code>yield return</code> können nicht gemeinsam verwendet werden.

Bei der Verwendung muss beachtet werden, dass die zurückgegebene Sequenz die ihr zugrundeliegende Logik ''verzögert'' ausführt, was bedeutet, dass der erste Durchlauf ein und derselben Sequenz andere Werte liefern kann, als beim zweiten Mal:

<syntaxhighlight lang="csharp">

// interner Zähler
private int i = 0;

public IEnumerable<DateTime> GetNow() {
    // aktuelle Uhrzeit (einziges Element)
    yield return DateTime.Now;
}

public IEnumerable<int> GetZahl() {
    // internen Zähler um 1 erhöhen (einziges Element)
    yield return this.i++;
}

public void TestZahl() {
    IEnumerable<int> sequenz = this.GetZahl();

    foreach (int zahl in sequenz)
        Console.WriteLine(zahl);  // 0

    foreach (int zahl in sequenz)
        Console.WriteLine(zahl);  // 1

    foreach (int zahl in sequenz)
        Console.WriteLine(zahl);  // 2
}

public void TestZeit() {
    IEnumerable<DateTime> sequenz = this.GetNow();

    // [1] einziges Element mit der aktuellen Uhrzeit
    foreach (DateTime now in sequenz)
        Console.WriteLine(now);

    // 2 Sekunden warten
    Thread.Sleep(2000);

    // [2] einziges Element wie der Wert aus [1]
    //   + ca. 2 Sekunden
    foreach (DateTime now in sequenz)
        Console.WriteLine(now);
}

</syntaxhighlight>

== Die using-Anweisung ==
Die <code>using</code>-Anweisung definiert einen Geltungsbereich, an dessen Ende der Speicher von nicht mehr benötigten Objekten automatisch freigegeben wird. Bei begrenzten Ressourcen wie Dateihandler stellt die <code>using</code>-Anweisung sicher, dass diese immer ausnahmesicher bereinigt werden.

<syntaxhighlight lang="csharp">
using (Font myFont = new Font("Arial", 10.0f))
{
    g.DrawString("Hallo Welt!", myFont, Brushes.Black);
}
</syntaxhighlight>

Hier wird ein <code>Font</code>-Objekt erzeugt, das am Ende des Blocks automatisch durch Aufruf seiner <code>Dispose</code>-Methode wieder freigegeben wird. Dies geschieht selbst dann, wenn in dem Block eine Ausnahme ausgelöst wird. Der Vorteil liegt in der vereinfachten Schreibweise, denn intern wird daraus folgendes Konstrukt, das ansonsten manuell so formuliert werden müsste:

<syntaxhighlight lang="csharp">
Font myFont = new Font("Arial", 10.0f);

try
{
    g.DrawString("Hallo Welt!", myFont, Brushes.Black);
}
finally
{
    if (myFont != null)
    {
        myFont.Dispose();
    }
}
</syntaxhighlight>

Klassen müssen die <code>System.IDisposable</code>-Schnittstelle implementieren, damit die <code>using</code>-Anweisung auf diese Weise eingesetzt werden kann.

== Objekte und Klassen ==
Wenn man von einem Objekt spricht, handelt es sich dabei in der Umgangssprache normalerweise um ein reales Objekt oder einen Gegenstand des täglichen Lebens. Beispielsweise kann das ein Tier, ein Fahrzeug, ein Konto oder Ähnliches sein.

Übertragen auf die objektorientierte Programmierung und C# ist ein Objekt ein Exemplar (siehe Schlüsselwort <code>new</code>) einer Klasse. Eine Klasse kann man dabei als Bauplan oder Baustelle von Objekten ansehen.

Jedes Objekt kann mittels der in ihm enthaltenen ''Felder'' (Variablen) verschiedene Zustände annehmen. Natürlich kann jede Klasse auch ''Methoden'' (Funktionen, die Tätigkeiten bewirken) anbieten. Zugriffe auf die Variablen können mittels ''Eigenschaften'', einer speziellen Art von Funktionen die nach außen hin wie Felder aussehen, auf bestimmte zulässige Änderungen beschränkt werden, wodurch auch sogenannte ''Ereignisse'' ausgelöst werden können, über deren Stattfinden sich andere Objekte informieren lassen können. Wie in der objektorientierten Programmierung üblich, können sich alle vier Arten von Klassenbestandteilen wahlweise sowohl auf die einzelnen Exemplare als auch auf die Klasse als solche beziehen.

{| style="border:1px solid; padding:4px; text-align:center;" rules="all"
! Klasse
|-
| Feld(er)
|-
| Eigenschaft(en)
|-
| Methode(n)
|-
| Ereignis(se)
|}

Beispiel für den Bauplan eines Autos:
<syntaxhighlight lang="csharp">
class Auto
{
    // Konstruktor, dient zur Erzeugung
    public Auto(string name, System.Drawing.Color farbe)
    {
        this.GeschwindigkeitKMH = 0; this.Name = name; this.Farbe = farbe;
    }

    // Eigenschaften:
    public double GeschwindigkeitKMH { get; private set; }
    public string Name { get; private set; }
    public System.Drawing.Color Farbe { get; private set; }

    // Feld:
    private bool motorLaeuft = false;

    // Methoden:
    public void Beschleunigung(double AenderungKMH)
    {
        this.GeschwindigkeitKMH += AenderungKMH;
        GeschwindigkeitGeaendert(this.GeschwindigkeitKMH);
    }
    public void VollBremsung()
    {
        this.GeschwindigkeitKMH = 0d;
        GeschwindigkeitGeaendert(this.GeschwindigkeitKMH);
    }
    public void MotorStarten()
    {
        if (!this.motorLaeuft)
        {
            this.motorLaeuft = true;
            MotorEreignis(this.motorLaeuft);
        }
    }
    public void AutoStoppen()
    {
        if (this.GeschwindigkeitKMH != 0d) { VollBremsung(); }
        if (this.motorLaeuft)
        {
            this.motorLaeuft = false;
            MotorEreignis(this.motorLaeuft);
        }
    }
    public void Umlackieren(System.Drawing.Color neueFarbe) { this.Farbe = neueFarbe; }

    // Delegat-Typen. Sie könnten auch außerhalb der Klasse definiert sein.
    public delegate void MotorDelegat(bool laeuft);
    public delegate void GeschwindigkeitDelegat(double geschwindigkeit);

    // Ereignisse
    public event MotorDelegat MotorEreignis;
    public event GeschwindigkeitDelegat GeschwindigkeitGeaendert;

}
</syntaxhighlight>

== Die Klasse namens „object“ ==
Die Klasse <code>object</code> (ein Alias für System.Object) ist ein [[Referenztyp]], von dem jede Klasse [[abgeleitete Klasse|abgeleitet]] wird. So kann durch [[implizite Typumwandlung]] jeder Objekttyp in <code>object</code> umgewandelt werden.

.NET (und damit auch C#) unterscheidet zwischen Werttypen und Referenztypen. Werttypen sind jedoch auch (über den Zwischenschritt ValueType) von <code>object</code> abgeleitet. Deshalb kann (mittels eines boxing/unboxing genannten Verfahrens) auch eine Variable vom Typ <code>object</code> auf einen Werttyp, z.&nbsp;B. <code>int</code> verweisen.

== Strukturen (''struct'') ==
[[Verbund (Datentyp)|Strukturen]] sind bereits als Sprachmittel aus Sprachen wie [[C++]] oder Delphi (Records) bekannt. Sie dienen primär zur Erstellung eigener komplexer Datenstrukturen oder eigener Datentypen.

So kann zum Beispiel eine [[Raum (Physik)|Raumkoordinate]], bestehend aus einer X-, einer Y- und einer Z-Position, durch eine Datenstruktur Koordinate abgebildet werden, die sich aus drei Gleitkommazahlen einfacher oder doppelter Genauigkeit zusammensetzt.

<syntaxhighlight lang="csharp">
public struct Koordinate
{
    public double X { get; }
    public double Y { get; }
    public double Z { get; }

    public Koordinate(double x, double y, double z)
    {
         X = x;
         Y = y;
         Z = z;
    }

    public override string ToString()
    {
        return $"x: {X}, y: {Y}, z: {Z}";
    }
}
</syntaxhighlight>

C# fasst eine über das Schlüsselwort <code>struct</code> definierte Struktur als einen Wertetyp auf. Strukturen in C# können außerdem Methoden, Eigenschaften, Konstruktoren und andere Elemente von Klassen aufweisen; sie können aber nicht beerbt werden.

Der Unterschied einer Strukturinstanz im Vergleich zu einem Objekt besteht in ihrer Repräsentation im Speicher. Da keine zusätzlichen Speicherreferenzen benötigt werden, wie es bei einem Objekt erforderlich ist (Referenztyp), können Strukturinstanzen wesentlich ressourcenschonender eingesetzt werden. So basieren beispielsweise alle primitiven Datentypen in C# auf Strukturen.

== Aufzählungen (Enumerationen) ==
Aufzählungen dienen zur automatischen Nummerierung der in der Aufzählung enthaltenen Elemente. Die Syntax für die Definition von Aufzählungen verwendet das Schlüsselwort <code>enum</code> (Abkürzung für Enumeration).

Der in C# verwendete [[Aufzählungstyp]] ähnelt dem in C, mit der Ausnahme, dass ein optionaler ganzzahliger Datentyp für die Nummerierung der Elemente angegeben werden kann. Ohne Angabe eines Datentyps wird <code>int</code> verwendet.

<syntaxhighlight lang="csharp">
public enum Wochentag
{
    Montag = 1, Dienstag, Mittwoch, Donnerstag, Freitag, Samstag, Sonntag
}
</syntaxhighlight>

Die Elementnummerierung in C# beginnt bei 0. Es ist aber auch möglich, wie in C, jedem Element – oder nur dem ersten Element – einen eigenen Startwert zuzuweisen (wie im obigen Beispiel). Dabei können sich die Anfangswerte wiederholen. Die Zählung beginnt dann jeweils von neuem bei dem definierten Startwert und Element.

In C# ist es auch möglich, ein bestimmtes Element einer Enumeration über seine Ordinalzahl anzusprechen. Hierzu ist aber eine explizite Typumwandlung notwendig.

<syntaxhighlight lang="csharp">
Wochentag Tag = Wochentag.Mittwoch;
System.Console.WriteLine(Tag); // Ausgabe: Mittwoch
System.Console.WriteLine((int)Tag); // Ausgabe: 3
System.Console.WriteLine((Wochentag)3); // Ausgabe: Mittwoch
</syntaxhighlight>

=== Flags ===
Neben der beschriebenen Variante des enum-Aufzählungstyps existiert noch eine spezielle Variante von Enumeration. [[Flag (Informatik)|Flags]] definieren Enumerationen auf Bitebene und werden durch die Metainformation <nowiki>[Flags]</nowiki> vor der Enum-Deklaration definiert. Flag-Elemente können auf Bitebene verknüpft werden, sodass mehrere Elemente zu einem neuen kombiniert werden können. Hierzu müssen den zu kombinierenden Elementen Zweierpotenzen als Werte zugewiesen werden, damit eine Kombination ermöglicht wird.

<syntaxhighlight lang="csharp">
[Flags]
public enum AccessMode
{
    None = 0,
    Read = 1,
    Write = 2,
    // Erhält den Wert 3 (Kombination aus 1 und 2)
    ReadAndWrite = Read | Write
}
</syntaxhighlight>

== Zugriffsmodifikatoren ==
[[Zugriffsmodifikator]]en regeln den Zugriff auf Klassen und deren Mitglieder (Methoden, Eigenschaften, Variablen, Felder und Ereignisse) in C#. Die folgende Tabelle führt die von C# unterstützten Zugriffsmodifikatoren auf und beschreibt deren Wirkung und den Sichtbarkeitskontext.
{| class="wikitable toptextcells"
|-
! Name
! Wirkung
|-
| <code>abstract</code>
| Abstrakte Member sind zwar deklariert, aber nicht implementiert. Die Implementierung erfolgt zwingend in der abgeleiteten Klasse. Von einer abstrakten Klasse kann keine Instanz erzeugt werden.
|-
| <code>internal</code>
| <code>internal</code> beschränkt den Zugriff auf Klassen und deren Mitglieder auf eine Assembly.
Es handelt sich hierbei nicht um eine Beschränkung auf Namespaces, sondern auf die Assembly (also auf die jeweilige ausführbare Datei oder die Klassenbibliothek). Unter Java entspricht das der Beschränkung auf ein <code>package</code>.
|-
| <code>new</code>
| Hier ist nicht der Aufruf des Konstruktors gemeint. Mit dem <code>new</code>-Modifizierer wird ein Member der Basisklasse verdeckt. Der Klassen-Member besitzt dieselbe Signatur, aber eine andere Funktionalität und steht mit dem verdeckten Member der Basisklasse nicht in Beziehung. Beim Aufruf sind alle Basisklassenmember mit demselben Namen ausgeblendet. Ohne diesen Modifizierer gibt der Compiler eine Warnung aus.
|-
| <code>override</code>
| Der Modifizierer <code>override</code> überschreibt die abstrakte oder virtuelle Implementierung einer Methode oder Eigenschaft bzw. eines Indexers oder Ereignisses der Basisklasse. <code>override</code>-Member sind automatisch <code>virtual</code>. In der Vererbungshierarchie handelt es sich um eine weitere Implementierung.
|-
| <code>private</code>
|Beschränkt den Zugriff auf eine Klasse und deren Mitglieder. Eine mit <code>private</code> deklarierte Klasse kann nur innerhalb der Klasse selbst instanziert werden (beispielsweise kann ein öffentlicher Konstruktor einer Klasse, oder die statische Funktion ''Main'', einen privaten Konstruktor aufrufen, der nicht von außen aufgerufen werden kann).

Oft wird <code>private</code> verwendet, um das [[Singleton (Entwurfsmuster)|Singleton-Muster]] umzusetzen (z.&nbsp;B. bei der Verwendung einer Klasse als Fabrik; siehe [[Fabrikmethode]]) oder die Vererbung zu beeinflussen oder zu verbieten (siehe auch Schlüsselwort <code>sealed</code>). Hinweis: Eine abgeleitete Klasse kann auf private Mitglieder der Basisklasse (vgl. Schlüsselwort <code>base</code>) ebenfalls nicht zugreifen. Soll ein solcher Zugriff möglich sein, so muss der Zugriffsmodifikator <code>protected</code> verwendet werden.
|-
| <code>protected</code>
|Der Modifikator <code>protected</code> erlaubt den Zugriff nur in der eigenen Vererbungshierarchie, also nur für die deklarierende Klasse und alle abgeleiteten Klassen.
|-
| <code>protected internal</code>
|Der Modifikator <code>protected internal</code> ist eine Kombination aus den Modifikatoren <code>protected</code> und <code>internal</code>. Die Methode ist sichtbar für die deklarierende und für alle abgeleiteten Klassen sowie für alle Klassen innerhalb der Assembly. Eine Sichtbarkeit nur für abgeleitete Klassen innerhalb der Assembly existiert in C# nicht. In diesem Fall muss auf den Modifikator <code>internal</code> zurückgegriffen werden.
|-
| <code>public</code>
|Auf als <code>public</code> gekennzeichnete Klassen oder Klassenmitglieder (z.&nbsp;B. Methoden oder Eigenschaften) kann unbeschränkt zugegriffen werden. Sie werden deshalb auch als „öffentlich“ bezeichnet.
|-
| <code>sealed</code>
| <code>sealed</code> kann auf Klassen, Instanzmethoden und Eigenschaften angewendet werden. Von versiegelten Klassen kann nicht abgeleitet werden. Eine versiegelte Methode überschreibt eine virtuelle Methode der Basisklasse. Die versiegelte Methode bleibt für erbende Klassen sichtbar, eine weitere Überschreibung durch sie ist jedoch ''nicht'' mehr möglich. Dies ist somit die letzte Implementierung in der Vererbungshierarchie.
|-
| <code>static</code>
| <code>static</code>-Member sind klassenspezifisch, aber nicht instanzspezifisch. Von statischen Klassen kann keine Instanz erzeugt werden. Statische Member einer Klasse werden mit dem Namen der Klasse, nicht mit dem Namen der Objektinstanz aufgerufen (Beispiel: <code>Math.Sqrt()</code>). Für jede Instanz einer Klasse wird eine separate Kopie aller Instanzenfelder erzeugt, bei statischen Feldern ist lediglich eine Kopie vorhanden.
|-
| <code>virtual</code>
| Der <code>virtual</code>-Modifizierer gibt an, dass es sich um die erste Implementierung in der Vererbungshierarchie handelt. Virtuelle Member können in einer abgeleiteten Klasse mit dem Modifikator <code>override</code> überschrieben werden. Fehlt <code>virtual</code> bei einem Member, handelt es sich um die einzige Implementierung.
|}

Hinweise:
* Per Voreinstellung sind Klassenmitglieder (Methoden, Eigenschaften usw.), denen kein Zugriffsmodifikator zugewiesen wurde, automatisch als <code>private</code> deklariert. Klassen selbst dagegen besitzen automatisch den Modifikator <code>internal</code> und sind nur in der aktuellen Assembly sichtbar.
* Die Modifikatoren können bis auf <code>protected</code> und <code>internal</code> nicht miteinander kombiniert werden. <code>protected internal</code> spielt im Zusammenhang mit der Vererbung von Komponenten eine Rolle. Die Sichtbarkeit der Basisklasse wird von der abgeleiteten Klasse übernommen.
* Zur Implementierung eines Schnittstellenmembers muss ein Klassenmember entweder als <code>public</code> deklariert werden oder der Schnittstellenmember muss explizit implementiert werden.

== Datentypen, Operatoren, Eigenschaften und Konstanten ==
C# kennt zwei Arten von [[Datentyp]]en: [[Wertetyp]]en und [[Referenztyp]]en. Referenztypen dürfen dabei nicht mit [[Zeiger (Informatik)|Zeigern]] gleichgesetzt werden, wie sie u.&nbsp;a. aus der Sprache C++ bekannt sind. Diese werden von C# auch unterstützt, aber nur im „unsicheren Modus“ (engl. ''unsafe mode'').

Wertetypen enthalten die Daten direkt, wobei Referenztypen im Gegensatz dazu nur Verweise auf die eigentlichen Daten, oder besser, [[Objekt (Programmierung)|Objekte]] darstellen. Beim Lesen und Schreiben von Wertetypen werden die Daten dagegen über einen Automatismus, [[Adapter (Entwurfsmuster)#Hüllenklassen für primitive Datentypen|Autoboxing]] genannt, in einer Instanz der jeweiligen [[Adapter (Entwurfsmuster)|Hüllenklasse]] (engl. ''wrapper'') gespeichert oder aus ihr geladen.

Die Zuweisung eines Wertes bzw. einer Referenz kann während der Deklaration erfolgen oder später, sofern nicht eine Konstante deklariert wurde. Die Deklaration erfolgt durch Angabe eines Datentyps gefolgt von einem Variablennamen:

<syntaxhighlight lang="csharp">
// Datentyp Variable;
int i;
System.Collections.IList liste;
</syntaxhighlight>

Es können auch mehrere Variablen des gleichen Typs zeitgleich deklariert werden:

<syntaxhighlight lang="csharp">
// Datentyp Variable1, Variable2, ...;
int i, j, k;
System.Collections.IList liste1, liste2;
</syntaxhighlight>

Ferner besteht die Möglichkeit, der Variablen bei der Deklaration auch gleich einen Wert oder eine Referenz zuzuweisen ([[Initialwert]]):

<syntaxhighlight lang="csharp">
// Datentyp Variable=Wert/Referenz;
int i = 5;
int j = 2, k = 3;
System.Collections.IList liste = new System.Collections.ArrayList();
</syntaxhighlight>

Auch die Mehrfachzuweisung eines Wertes an verschiedene Variablen ist möglich:

<syntaxhighlight lang="csharp">
int i, j, k;
i = j = k = 123;
</syntaxhighlight>

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

=== Datentypen und Speicherbedarf ===
{| class="float-right wikitable"
! Datentyp
! Bit
! Suffix
! Vorz.
! Alias für (struct type)
|-
| <code>bool</code> ||style="text-align:right;"| 8 ||
|style="text-align:center;"| - || <code>System.Boolean</code>
|-
| <code>byte</code> ||style="text-align:right;"| 8 ||
|style="text-align:center;"| N || <code>System.Byte</code>
|-
| <code>char</code> ||style="text-align:right;"| 16 ||
|style="text-align:center;"| - || <code>System.Char</code>
|-
| <code>decimal</code> ||style="text-align:right;"| 128 || <code>m</code>, <code>M</code>
|style="text-align:center;"| - || <code>System.Decimal</code>
|-
| <code>double</code> ||style="text-align:right;"| 64 || <code>d</code>, <code>D</code>
|style="text-align:center;"| - || <code>System.Double</code>
|-
| <code>float</code> ||style="text-align:right;"| 32 || <code>f</code>, <code>F</code>
|style="text-align:center;"| - || <code>System.Single</code>
|-
| <code>int</code> ||style="text-align:right;"| 32 ||
|style="text-align:center;"| J || <code>System.Int32</code>
|-
| <code>long</code> ||style="text-align:right;"| 64 || <code>l</code>, <code>L</code>
|style="text-align:center;"| J || <code>System.Int64</code>
|-
| <code>sbyte</code> ||style="text-align:right;"| 8 ||
|style="text-align:center;"| J || <code>System.SByte</code>
|-
| <code>short</code> ||style="text-align:right;"| 16 ||
|style="text-align:center;"| J || <code>System.Int16</code>
|-
| <code>uint</code> ||style="text-align:right;"| 32 || <code>u</code>, <code>U</code>
|style="text-align:center;"| N || <code>System.UInt32</code>
|-
| <code>ulong</code> ||style="text-align:right;"| 64 || <code>ul</code>, <code>UL</code>
|style="text-align:center;"| N || <code>System.UInt64</code>
|-
| <code>ushort</code> ||style="text-align:right;"| 16 ||
|style="text-align:center;"| N || <code>System.UInt16</code>
|}
[[Datentyp]]en sind in C# nicht elementar, sondern [[Objektbasierte Programmiersprache|objektbasiert]]. Jeder der in der Tabelle aufgeführten Datentypen stellt einen Alias auf eine Klasse des Namensraumes ''System'' dar. Beispielsweise wird der Datentyp <code>bool</code> durch die Klasse <code>System.Boolean</code> abgebildet.
Durch die Objektbasiertheit ist es möglich, Methoden auf Datentypen anzuwenden:

<syntaxhighlight lang="csharp">
1234.ToString();
int i = 17;
i.ToString();
</syntaxhighlight>

Vergleichbar mit C++, und anders als bei [[Java (Programmiersprache)|Java]], gibt es unter C# vorzeichenbehaftete und vorzeichenlose Datentypen. Diese werden durch Voranstellen des Buchstabens ''s'' (für ''signed'', englisch für ''vorzeichenbehaftet'') und durch Voranstellen des Buchstabens ''u'' (für ''unsigned'', englisch für ''vorzeichenlos'') gekennzeichnet (<code>sbyte, uint, ulong, ushort,</code> mit Ausnahme von <code>short</code>). Die [[Gleitkommazahl|Gleitkomma]]-Datentypen (<code>float, double, decimal</code>) können neben einfacher auch [[doppelte Genauigkeit]] aufweisen und unterscheiden sich im Speicherbedarf.
Dadurch ändert sich die Genauigkeit, was in der Anzahl der möglichen Nachkommastellen zum Ausdruck kommt.

=== Konstanten (Schlüsselwort ''const'') ===
Einem mit <code>const</code> deklarierten „Objekt“ kann nach der [[Deklaration (Programmierung)|Deklaration]] und Initialisierung kein neuer Inhalt zugewiesen werden. Das „Objekt“ wird dadurch zu einer [[Konstante (Programmierung)|Konstanten]].

Es muss dabei vom Compiler festgestellt werden können, dass der Wert, der einer Konstante zugewiesen wird, unveränderlich ist. Es ist also auch möglich, eine Konstante von einem Referenztypen zu definieren, allerdings darf dieser nur [[null]] zugewiesen werden.

Grund dafür ist, dass der Compiler alle Verwendungen von Konstanten bereits zum Zeitpunkt des Kompilierens ersetzt. Strukturen können nicht konstant sein, da sie in einem [[Konstruktoren und Destruktoren|Konstruktor]] einen [[Zufallszahlengenerator|Zufallsgenerator]] benutzen könnten.

Fehlerhafte Zuweisungen einer Konstanten werden mit dem Kompilierfehler CS0133 vom C-Sharp-Kompilierer moniert.

<syntaxhighlight lang="csharp">
using System;
using System.IO;

public class ConstBeispiel
{
    public static void Main()
    {
        //Es wird eine Konstante für die Länge eines Arrays angelegt
        const int arrayLength = 1024;
        //Es wird eine Konstante festgelegt, welche die Zugriffsart auf eine Datei beschreibt (Enum)
        const FileMode fm = FileMode.Open;
        //Es wird eine Konstante festgelegt, welche den Namen der zu öffnenden Datei festlegt
        const string fileName = "beispiel.txt";

        //Buffer erstellen
        byte[] readBuffer = new byte[arrayLength];
        //Stream zur Datei öffnen
        FileStream fs = new FileStream(fileName,fm);
        //Daten Lesen
        fs.Read(readBuffer,0,readBuffer.Length);
        //Stream schließen
        fs.Close();
        //Daten ggf. bearbeiten.
        //...

        // FEHLER: IList wird ein Referenzdatentyp zugewiesen, nicht konstant
        const IList liste = new ArrayList();

        // FEHLER: const + struct
        const TimeSpan zeitSpanne = new TimeSpan(10);
    }
}
</syntaxhighlight>

Konstanten gibt es auch in anderen Sprachen (z.&nbsp;B. C++, Java). In Java werden Konstanten durch das Schlüsselwort <code>final</code> gekennzeichnet, in [[Fortran]] durch <code>PARAMETER</code>.

=== Operatoren ===
Operatoren führen verschiedene Operationen an Werten durch und erzeugen dabei einen neuen Wert. Je nach Anzahl der Operanden wird zwischen unären, binären und ternären Operatoren unterschieden. Die Reihenfolge der Auswertung wird durch die Priorität und [[Assoziativgesetz|Assoziativität]] bestimmt und kann durch Klammerausdrücken geändert werden.
{| class="wikitable" style="text-align:center"
| '''Operatorrangfolge'''
| '''Operator'''
| '''Beschreibung'''
|-
|rowspan="14"| 1. Primäre Operatoren
| x.y
| Memberzugriff
|-
| f(x)
| Aufrufen von Methoden und Delegaten
|-
| a[x]
| Array- und Indexerzugriff
|-
| x++
| Postinkrement
|-
| x--
| Postdekrement
|-
| new T(...)
| Objekt- und Delegaterstellung
|-
| new T(...){...}
| Objekterstellung mit Initialisierern
|-
| new {...}
| Anonymer Objektinitialisierer
|-
| new T[...]
| Arrayerstellung
|-
| typeof(T)
| Abrufen des System.Type-Objekts für T
|-
| checked(x)
| Auswerten von Ausdrücken in überprüftem Kontext
|-
| unchecked(x)
| Auswerten von Ausdrücken in nicht überprüftem Kontext
|-
| default (T)
| Abrufen des Standardwerts vom Typ T
|-
| delegate {}
| Anonyme Methode
|-
|rowspan="7"| 2. Unäre Operatoren
| +x
| Identität
|-
| -x
| Negation
|-
| !x
| Logische Negation
|-
| ~x
| Bitweise Negation
|-
| ++x
| Präinkrement
|-
| --x
| Prädekrement
|-
| (T)x
| Explizites Konvertieren von x in den Typ T
|-
|rowspan="3"| 3. Multiplikative Operatoren
| *
| Multiplikation
|-
| /
| Division
|-
| %
| Modulo
|-
|rowspan="2"| 4. Additive Operatoren
| x + y
| Addition, Zeichenfolgenverkettung, Delegatkombination
|-
| x - y
| Subtraktion, Delegatentfernung
|-
|rowspan="2"| 5. Schiebeoperatoren
| x << y
| Linksverschiebung
|-
| x >> y
| Rechtsverschiebung
|-
|rowspan="6"| 6. Relationale Operatoren und Typoperatoren
| x < y
| Kleiner als
|-
| x > y
| Größer als
|-
| x <= y
| Kleiner oder gleich
|-
| x >= y
| Größer oder gleich
|-
| x is T
| Gibt true zurück, wenn x vom Typ T ist, andernfalls false.
|-
| x as T
| Gibt x als T typisiert zurück, oder NULL, wenn x nicht vom Typ T ist.
|-
|rowspan="2"| 7. Gleichheitsoperatoren
| x == y
| Gleich
|-
| x != y
| Ungleich
|-
|rowspan="7"| 8. Logische, bedingte und NULL-Operatoren
| x & y
| Ganzzahliges bitweises AND, boolesches logisches AND
|-
| x ^ y
| Ganzzahliges bitweises XOR, boolesches logisches XOR
|-
| x &#x7c; y
| Ganzzahliges bitweises OR, boolesches logisches OR
|-
| x && y
| Wertet y nur aus, wenn x den Wert true hat.
|-
| x &#x7c;&#x7c; y
| Wertet y nur aus, wenn x den Wert false hat.
|-
| x ?? y
| Ergibt y, wenn x den Wert NULL hat, andernfalls x
|-
| x ? y : z
| Wird zu y ausgewertet, wenn x den Wert true hat, und zu z, wenn x den Wert false hat.
|-
|rowspan="3"| 9. Zuweisungsoperatoren und anonyme Operatoren
| =
| Zuweisung
|-
| x op= y
| Verbundzuweisung. Entspricht x = x op y, wobei op der Operator +, -, *, /, %, &, &#x7c; << oder >> ist.
|-
| (T x) => y
| Anonyme Methode (Lambda-Ausdruck)
|-
|}

==== Operatoren überladen ====
C# bietet die Möglichkeit, Operatoren für benutzerdefinierte Datentypen zu implementieren. Als benutzerdefinierter Datentyp gilt eine selbst geschriebene Klasse oder Struktur. Die Implementierung geschieht mit öffentlichen statischen Methoden. Statt eines Namens tragen sie das Schlüsselwort <code>operator</code> gefolgt von dem Operator-Zeichen welches überladen werden soll. Eine implizite oder explizite Typkonvertierung geschieht mittels <code>implicit operator</code> oder <code>explicit operator</code> als Methoden-Namen. Der Compiler ersetzt je nach Typ der Operanden den Quelltext in einen Aufruf der entsprechenden Methode:
<syntaxhighlight lang="csharp">
struct SpecialDouble
{
    public SpecialDouble(double argument)
    {
        _value = argument;
    }

    // SpecialDouble lhs = 9d, rhs = 0.5, result;
    // result = lhs ^ rhs; // Compiler ersetzt Operator ^ mit dieser Methode
    public static SpecialDouble operator ^(SpecialDouble lhs, SpecialDouble rhs)
    {
        return Math.Pow(lhs._value, rhs._value);
    }

    // SpecialDouble lhs = 9d; // 9d wird mit 'new SpecialDouble(9d)' ersetzt
    public static implicit operator SpecialDouble(double argument)
    {
        return new SpecialDouble(argument);
    }
    public static implicit operator double(SpecialDouble argument)
    {
        return argument._value;
    }

    // explizite Typkonvertierung:
    // Nachkommastellen gehen verloren, Exception kann auftreten
    public static explicit operator int(SpecialDouble argument)
    {
        return (int)argument._value;
    }

    double _value;
}
</syntaxhighlight>

Einschränkungen:
* Mindestens ein Parameter der Methode für die Überladung muss den Typ besitzen, für den der Operator überladen wird.
* Vergleichsoperatoren können nur paarweise überladen werden.
* Es können keine neuen Symbole verwendet werden. Nur die Operator-Symbole sind erlaubt, die in der Sprache definiert sind. ''Siehe dazu:'' [[#Operatoren|Tabelle Operatoren]]
* Die Operatoren <code>=</code>, <code>.</code>, <code>?:</code>, <code>-></code>, <code>new</code>, <code>is</code>, <code>sizeof</code>, <code>typeof</code> und <code>=></code> können nicht überladen werden.
* Die Priorität eines benutzerdefinierten Operators kann nicht geändert werden. Der Vorrang und die Orientierung basiert auf dem Symbol des Operators.
* Die Anzahl der Operanden ist ebenfalls an das Symbol des Operators gebunden.
* Operatoren, die nicht reserviert sind, können nicht implementiert werden.

Um den Operator <code>[]</code> zu simulieren, können [[#Indexer|Indexer]] verwendet werden. Die Operatoren <code>&&</code> und <code>||</code> können nicht direkt überladen werden. Sie werden über die speziellen überladbaren Operatoren <code>true</code> und <code>false</code> ausgewertet.

Die Operation <code>x && y</code> wird als <code>T.false(x) ? x : T.&(x, y)</code> ausgewertet, wobei <code>T.false(x)</code> ein Aufruf von dem in <code>T</code> deklarierten Operator <code>false</code> ist und <code>T.&(x, y)</code> ein Aufruf des ausgewählten Operator <code>&</code>.<ref name="Nachweis Operator true false">{{Internetquelle |url=http://msdn.microsoft.com/de-de/library/aa691312(v=vs.71).aspx |titel=Benutzerdefinierte bedingte logische Operatoren |hrsg=Microsoft Developer Network (MSDN) |zugriff=2011-04-25}}</ref>

Die Operation <code>x || y</code> wird als <code>T.true(x) ? x : T.|(x, y)</code> ausgewertet, wobei <code>T.true(x)</code> ein Aufruf von dem in <code>T</code> deklarierten Operator <code>true</code> ist und <code>T.|(x, y)</code> ein Aufruf des ausgewählten Operator <code>|</code>.<ref name="Nachweis Operator true false" />

=== Eigenschaften (Schlüsselwörter ''get'', ''set'' und ''value'') ===
Eine ''Eigenschaft'' (''property'') ist eine Sicht auf eine öffentliche Variable einer Klasse. Die Variable selbst wird durch einen Zugriffsmodifikator wie <code>private</code> oder <code>protected</code> (bei Variablen, die in abgeleiteten Klassen überschrieben 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. Beide Möglichkeiten sind auch miteinander 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 Zugriffsmodifikator zugewiesen werden. Eine Eigenschaft enthält 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 <code>get</code> und zum Setzen eines Wertes das Schlüsselwort <code>set</code>. Von außen stellt sich die Eigenschaft dann wie eine Variable dar und der Zugriff kann entsprechend erfolgen (vgl. Visual Basic).

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.

Beispiel einer Eigenschaftsdefinition <code>Wohnort</code> für eine private Variable (<code>_wohnort</code>):

<syntaxhighlight lang="csharp">
public class EigenschaftBeispiel
{
    private string _wohnort;
    public string Wohnort
    {
        get
        {
            return _wohnort;
        }
        set
        {
            _wohnort = "12345 " + value;
        }
    }
}
</syntaxhighlight>

Durch das „Weglassen“ des Schlüsselwortes <code>set</code> oder des Schlüsselwortes <code>get</code> kann gesteuert werden, ob die Eigenschaft nur gelesen oder nur geschrieben werden darf. Das Schlüsselwort <code>value</code> ist dabei ein Platzhalter für den der Eigenschaft zugewiesenen Wert, der gesetzt werden soll. Es wird nur innerhalb eines <code>set</code>-Blocks als Schlüsselwort betrachtet (und entspricht in etwa einer temporären lokalen Variable).

Beispiel für den Zugriff auf die oben definierte Eigenschaft <code>Wohnort</code>:

<syntaxhighlight lang="csharp">
EigenschaftBeispiel instanz = new EigenschaftBeispiel();
instanz.Wohnort = "Musterstadt";
Console.WriteLine(instanz.Wohnort);
// Ausgabe: ''12345 Musterstadt''
</syntaxhighlight>

Würde bei der obigen Definition der Eigenschaft ‚Wohnort‘ der <code>get</code>-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 <code>set</code>-Block bzw. <code>get</code>-Block auch Operationen ausgeführt werden, beispielsweise die Potenzierung eines bei <code>set</code> übergebenen Wertes (<code>value</code> mal Exponent), bevor er der Variablen zugewiesen wird. Das Gleiche gilt für das Schlüsselwort <code>get</code>. 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 <code>set</code>.

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

Ab C# 3.0 ist es möglich, Eigenschaften automatisch zu implementieren. Dies ist eine verkürzte Schreibweise für Eigenschaften, bei denen es sich um den Zugriff auf eine Variable handelt, die innerhalb der Klasse bzw. Struktur als Feld deklariert wurde.

Beispiel anhand der Struktur Point:
<syntaxhighlight lang="csharp">
struct Point
{
    public double X
    {
        get { return this.x; }
        set { this.x = value; }
    }

    public double Y
    {
        get { return this.y; }
        set { this.y = value;}
    }

    private double x, y;
}
</syntaxhighlight>

Das gleiche Beispiel mit Hilfe automatisch implementierter Eigenschaften:
<syntaxhighlight lang="csharp">
struct Point
{
    public double X { get; set; }
    public double Y { get; set; }
}
</syntaxhighlight>
Mit Hilfe des Objektinitialisierers (ab .NET 3.5) ist ein Konstruktor überflüssig:
<syntaxhighlight lang="csharp">
Point p = new Point { X = 1.2, Y = -3.75 }; // Objektinitialisierer
Console.WriteLine(p.X); // Ausgabe: 1,2
Console.WriteLine(p.Y); // Ausgabe: −3,75
</syntaxhighlight>

=== Indexer ===
Der Indexer ist die Standardeigenschaft von einem Objekt. Der Aufruf geschieht wie bei einem Array mit eckigen Klammern.

Beispiel: Zugriff auf die 32 Bits einer <code>int</code> Variable mit Hilfe eines Indexers.

<syntaxhighlight lang="csharp">
using System;

namespace DemoIndexers
{
    class Program
    {
        struct IntBits
        {
            public bool this[int index]
            {
                get { return (bits & (1 << index)) != 0; }
                set
                {
                   if (value)
                   {
                     bits |= (1 << index);
                   }
                   else
                   {
                     bits &= ~(1 << index);
                   }
                }
            }

            private int bits;
        }

        static void Main(string[] args)
        {
            IntBits bits = new IntBits();
            Console.WriteLine(bits[6]); // False
            bits[2] = true;
            Console.WriteLine(bits[2]); // True
            bits[2] = false;
            Console.WriteLine(bits[2]); // False
        }
    }
}
</syntaxhighlight>

Wie bei Eigenschaften kann der Zugriff auf nur lesend oder nur schreibend beschränkt werden, indem man den get-Accessor bzw. set-Accessor weglässt.

Unterschiede zu Arrays, Methoden und Eigenschaften:
* Indexer müssen mindestens ein Parameter besitzen.
* Im Gegensatz zu Arrays können beim Zugriff auch nicht ganzzahlige Werte verwendet werden.
<code>public double this[string name]{} // ist erlaubt</code>
* Indexer können überladen werden.
* Statische Indexer sind nicht erlaubt, sowie <code>void</code> als Rückgabewert.
* <code>ref</code> und <code>out</code> dürfen bei Indexern nicht verwendet werden.

=== Darstellung spezieller Zeichen oder Zeichenfolgen („escapen“) ===
{| class="float-right wikitable toptextcells"
|-
! Seq.
! Beschreibung
! Hexadezimal
|-
| <code>\</code> || Einleitung alternativer Interpretation
| 0x001B
|-
| <code>\'</code> || Einfaches Anführungszeichen
| 0x0007
|-
| <code>\"</code> || Doppeltes Anführungszeichen
| 0x0022
|-
| <code>\\</code>
| Umgekehrter Schrägstrich
| 0x005C
|-
| <code>\0</code> || Null || 0x0000
|-
| <code>\a</code> || Signalton (engl. '''''a'''lert'')
| 0x0007
|-
| <code>\b</code> || Rückschritt (engl. '''''b'''ackspace'')
| 0x0008
|-
| <code>\f</code> || Seitenvorschub (engl. '''''f'''orm feed'')
| 0x000C
|-
| <code>\n</code> || Zeilenwechsel (engl. '''''n'''ew line'')
| 0x000A
|-
| <code>\r</code> || Wagenrücklauf (engl. ''carriage '''r'''eturn'')
| 0x000D
|-
| <code>\t</code> || Tabulatorzeichen, horizontal
| 0x0009
|-
| <code>\v</code> || Tabulatorzeichen, vertikal
| 0x000B
|-
| <code>\x</code>
|colspan="2"| Hexadezimale Zeichenfolge für ein einzelnes ''Unicode''-Zeichen
|-
| <code>\u</code>
|colspan="2"| Zeichenfolge für ''Unicode''-Zeichen in Zeichenliteralen.
|-
| <code>\U</code>
|colspan="2"| Zeichenfolge für ''Unicode''-Zeichen in Zeichenketten-Literalen.
|}

Ein auf das Zeichen „\“ (umgekehrter Schrägstrich, engl. ''backslash'') folgendes Zeichen wird anders interpretiert als sonst. Dabei handelt es sich meistens um nicht darstellbare Zeichen. Soll der umgekehrte Schrägstrich selbst dargestellt werden, so muss er doppelt angegeben werden („\\“).

Hexadezimale Zeichenfolge als Platzhalter für ein einzelnes [[Unicode]]-Zeichen: Das Zeichen wird dabei aus dem Steuerzeichen \x gefolgt von dem hexadezimalen Wert des Zeichens gebildet.

Zeichenfolge für ''Unicode''-Zeichen in Zeichenliteralen: Das Zeichen wird dabei aus dem Steuerzeichen \u gefolgt von dem hexadezimalen Wert des Zeichens gebildet, z.&nbsp;B. „\u20ac“ für „€“ Der Wert muss zwischen U+0000 und U+FFFF liegen.

Zeichenfolge für Unicode-Zeichen in Zeichenkettenliteralen: Das Zeichen wird dabei aus dem Steuerzeichen \U gefolgt von dem hexadezimalen Wert des Zeichens gebildet. Der Wert muss zwischen U+10000 und U+10FFFF liegen. Hinweis: Unicode-Zeichen im Wertbereich zwischen U+10000 und U+10FFFF sind nur für Zeichenfolgen-Literale zulässig und werden als zwei Unicode-„Ersatzzeichen“ kodiert bzw. interpretiert (s.&nbsp;a. ''[[UTF-16]]'').

== Vererbung ==
=== Schnittstellen ===
[[Mehrfachvererbung]] wird in C# nur in Form von [[Schnittstelle (Objektorientierung)|Schnittstellen]] (engl. ''interfaces'') unterstützt.

Schnittstellen dienen in C# zur Definition von Methoden, ihrer Parameter, ihrer Rückgabewerte sowie von möglichen Ausnahmen.

An dieser Stelle ein Anwendungsbeispiel für die Mehrfachvererbung:

<syntaxhighlight lang="csharp">
public class MyInt : IComparable, IDisposable
{
    // Implementierung
}
</syntaxhighlight>

Schnittstellen in C# ähneln den Schnittstellen der Programmiersprache Java. Anders als in Java, dürfen Schnittstellen in C# keine Konstanten enthalten und auch keine Zugriffsmodifikator bei der Definition einer Methode vereinbaren.

<syntaxhighlight lang="csharp">
public interface A
{
    void MethodeA();
}
public interface B
{
    void MethodeA();
    void MethodeB();
}
public class Klasse : A, B
{
    void A.MethodeA() {Console.WriteLine("A.A");} // MethodeA aus Schnittstelle A
    void B.MethodeA() {Console.WriteLine("A.B");} // MethodeA aus Schnittstelle B
    public void MethodeA() {Console.WriteLine("A.C");} //MethodeA für Klasse
    public void MethodeB() {Console.WriteLine("B.B");} // MethodeB aus Schnittstelle B
}
</syntaxhighlight>

Eine Klasse, die ein oder mehrere Schnittstellen einbindet, muss jede in der Schnittstelle definierte (virtuelle) Methode implementieren. Werden mehrere Schnittstellen eingebunden, die Methoden mit dem gleichen Namen und der gleichen Struktur besitzen (d.&nbsp;h. gleiche Parametertypen, Rückgabewerte usw.), so muss die jeweilige Methode in der implementierenden Klasse durch das Voranstellen des Namens der Schnittstelle gekennzeichnet werden. Dabei wird die jeweilige Funktion nur dann aufgerufen, wenn der Zeiger auf das Objekt vom entsprechenden Typ ist:

<syntaxhighlight lang="csharp">
public static void Main()
{
    Klasse k = new Klasse();
    (k as A).MethodeA();
    (k as B).MethodeA();
    k.MethodeA();
    Console.ReadLine();
}
</syntaxhighlight>

;Ausgabe
<pre>
A.A
A.B
A.C
</pre>

Auch Schnittstellen ohne Methodendefinition sind möglich. Sie dienen dann als sogenannte [[Markierungsschnittstelle]]n (engl. ''marker interface''). Auf die Verwendung von ''marker interfaces'' sollte zu Gunsten von Attributen verzichtet werden. Schnittstellen können jedoch keine statischen Methoden definieren.

Das Einbinden einer Schnittstelle erfolgt analog zur Beerbung einer Klasse. Schnittstellen werden per Konvention mit einem führenden „I“ (für Interface) benannt.

==== Vererbung von Schnittstellen ====
{| class="wikitable"
|+ Auswirkung der [[#Zugriffsmodifikatoren|Zugriffsmodifikatoren]] bei Vererbung mit Interface
! !! kein Modifikator !! ''new''
|-
! Code
|
<syntaxhighlight lang="csharp">
interface IMessage {
   string Message { get; }
}

public class MyClass : IMessage {
   public string Message {
      get { return "MyClass"; }
   }
}

public class MyDerivedClass : MyClass {
   public string Message {
      get { return "MyDerivedClass"; }
   }
}
</syntaxhighlight>
|
<syntaxhighlight lang="csharp" highlight="12">
interface IMessage {
   string Message { get; }
}

public class MyClass : IMessage {
   public string Message {
      get { return "MyClass"; }
   }
}

public class MyDerivedClass : MyClass {
   public new string Message {
      get { return "MyDerivedClass"; }
   }
}
</syntaxhighlight>
|-
! Test<br />(Verwendung)
|
<syntaxhighlight lang="csharp" highlight="6-7">
MyDerivedClass mdc = new MyDerivedClass();
MyClass mc = mdc as MyClass;
IMessage m = mdc as IMessage;

Assert.AreEqual(mdc.Message, "MyDerivedClass");
Assert.AreEqual(mc.Message, "MyClass");
Assert.AreEqual(m.Message, "MyClass");
</syntaxhighlight>
|
<syntaxhighlight lang="csharp" highlight="6">
MyDerivedClass mdc = new MyDerivedClass();
MyClass mc = mdc as MyClass;
IMessage m = mdc as IMessage;

Assert.AreEqual(mdc.Message, "MyDerivedClass");
Assert.AreEqual(mc.Message, "MyClass");
Assert.AreEqual(m.Message, "MyDerivedClass");
</syntaxhighlight>
|-
! !! ''virtual'' & ''override'' || ''abstract'' & ''override''
|-
! Code
|
<syntaxhighlight lang="csharp" highlight="6,12">
interface IMessage {
   string Message { get; }
}

public class MyClass : IMessage {
   public virtual string Message {
      get { return "MyClass"; }
   }
}

public class MyDerivedClass : MyClass {
   public override string Message {
      get { return "MyDerivedClass"; }
   }
}
</syntaxhighlight>
|
<syntaxhighlight lang="csharp" highlight="6-7,12">
interface IMessage {
   string Message { get; }
}

public class MyClass : IMessage {
   public abstract string Message {
      get;
   }
}

public class MyDerivedClass : MyClass {
   public override string Message {
      get { return "MyDerivedClass"; }
   }
}
</syntaxhighlight>
|-
! Test<br />(Verwendung)
|
<syntaxhighlight lang="csharp">
MyDerivedClass mdc = new MyDerivedClass();
MyClass mc = mdc as MyClass;
IMessage m = mdc as IMessage;

Assert.AreEqual(mdc.Message, "MyDerivedClass");
Assert.AreEqual(mc.Message, "MyDerivedClass");
Assert.AreEqual(m.Message, "MyDerivedClass");
</syntaxhighlight>
|
<syntaxhighlight lang="csharp">
MyDerivedClass mdc = new MyDerivedClass();
MyClass mc = mdc as MyClass;
IMessage m = mdc as IMessage;

Assert.AreEqual(mdc.Message, "MyDerivedClass");
Assert.AreEqual(mc.Message, "MyDerivedClass");
Assert.AreEqual(m.Message, "MyDerivedClass");
</syntaxhighlight>
|}

Das Überschreiben einer Methode durch eine abgeleitete Klasse kann mit <code>sealed</code> verhindert werden:

<syntaxhighlight lang="csharp" highlight="6,11,13">
interface IMessage {
   string Message { get; }
}

public class MyClass : IMessage {
   public virtual void OnMessage() {
      // kann von abgeleiteter Klasse implementiert werden
   }

   // kann nicht überschrieben werden
   public sealed string Message {
      get {
         OnMessage();
         return "MyClass";
      }
   }
}
</syntaxhighlight>

Ein Interface kann auch durch eine Basisklasse implementiert werden:
<syntaxhighlight lang="csharp">
interface IMessage {
   string Message { get; }
}

public class Messenger {
   public string Message {
      get { return "Messenger"; }
   }
}

public class MyClass : Messenger, IMessage {
   // interface bereits implementiert
}
</syntaxhighlight>

=== Das Schlüsselwort ''base'' ===
Das Schlüsselwort wird im Zusammenhang von [[Vererbung (Programmierung)|Vererbung]] genutzt. Vereinfacht gesagt ist die [[Basisklasse]], das was <code>this</code> für die aktuelle Klasse ist. Java hingegen sieht hierfür das Schlüsselwort <code>super</code> vor.

Nun folgt ein Beispiel, das die Verwendung von <code>base</code> zeigt:

<syntaxhighlight lang="csharp">
public class Example : Basisklasse
{
    private int myMember;
    public Example() : base(3)
    {
        myMember = 2;
    }
}
</syntaxhighlight>

In diesem Beispiel wurde die Verwendung nur anhand des Basisklassenkonstruktors gezeigt. Wie in der Einleitung beschrieben, kann base auch für den Zugriff auf die Mitglieder der Basisklasse benutzt werden. Die Verwendung erfolgt äquivalent zur Verwendung von this bei der aktuellen Klasse.

=== Versiegelte Klassen ===
''Versiegelte'' Klassen sind Klassen, von denen keine [[Objektorientierte Programmierung|Ableitung]] möglich ist und die folglich nicht als Basisklassen benutzt werden können. Bekanntester Vertreter dieser Art von Klassen ist die Klasse <code>String</code> aus dem Namensraum <code>System</code>. Der Modifizierer <code>sealed</code> kennzeichnet Klassen als versiegelt. Es ist jedoch möglich versiegelte Klassen mit [[#Erweiterungsmitglieder|Erweiterungsmitgliedern]] (Eigenschaften, Methoden und Operatoren) zu erweitern.

=== Statische Klassen ===
Analog zu [[Visual Basic .NET]] Modulen, können in C# Klassen definiert werden, die ausschließlich aus statischen Elementen bestehen:

<syntaxhighlight lang="csharp">
static class MeineStatischeKlasse
{
    public static int StatischeEigenschaft
    {
        get { return 5979; }
    }

    public static void StatischeMethode()
    {
    }

    /* Dies würde der Compiler als Fehler ansehen, da diese Methode nicht statisch ist

    public void NichtStatischeMethode()
    {
    }
    */
}
</syntaxhighlight>

=== {{Anker|Erweiterungsmitglied}} Erweiterungsmitglieder ===
Bereits ab der Version 3.0 konnten Datentypen um zusätzliche Methoden auf Objektebene ''erweitert'' werden.
Seit C#&nbsp;14 können auch Eigenschaften und Operatoren nachträglich einem Datentyp hinzugefügt werden. Der Sammelbegriff dafür lautet ''Erweiterungsmitglieder'' (auch ''Erweiterungsmember'', {{enS|extension members}}). Es ist seitdem auch möglich, diese auf Klassenebene (''static'') hinzuzufügen.<ref name="ExtensionMembers_Spec">{{Internetquelle |url=https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/proposals/csharp-14.0/extensions |titel=Extension members |werk=learn.microsoft.com |hrsg=Microsoft |sprache=en |abruf=2025-11-18}}</ref>

Erweiterungen werden seit C#&nbsp;14 in einem <code>extension</code>-Block deklariert. Hier können diverse Erweiterungsmitglieder (Eigenschaften, Methoden und Operatoren) so implementiert werden, als ob sich diese direkt im zu erweiternden Datentyp befinden würden. Erweiterungsblöcke müssen in einer statischen Klasse eingebettet werden.

<syntaxhighlight lang="csharp">
public static class CharExtensions
{
    //Erweiterungen für den Datentyp char
    extension(char c)
    {
        //Erweiterungseigenschaft auf Objektebene
        //Handelt es sich bei einem konkreten Wert um einen Umlaut?
        public bool IsUmlaut
            => (new char[] { 'ä', 'ö', 'ü', 'Ä', 'Ö', 'Ü' }).Contains(c);

        //Erweiterungseigenschaft auf Klassenebene
        //Der Lesezugriff der Eigenschaft liefert einen zufälligen Großbuchstaben (A-Z) zurück.
        public static char RandomLetter
            => (char) new Random().Next(65, 90);
    }
}
</syntaxhighlight>

==== Erweiterungsmethoden ====
{{Hauptartikel|Erweiterungsmethode}}

Es existieren zwei Möglichkeiten, um Erweiterungsmethoden ({{enS|extension methods}}) zu erstellen.

Die erste Variante existiert bereits seit C#&nbsp;3 und wird nach wie vor unterstützt.
Dabei wird in einer statischen Klasse eine statische Methode definiert, deren erster Parameter mit dem Schlüsselwort ''this'' beginnt, gefolgt von der gewöhnlichen Definition des Parameters.

<syntaxhighlight lang="csharp">
public static class ExtensionKlasse
{
    public static int MalDrei(this int zahl)
    {
        return zahl * 3;
    }
}
</syntaxhighlight>

Die zweite Variante ist ab C#&nbsp;14 verfügbar.
Hier wird in einer statischen Klasse ein Erweiterungsblock angelegt. Im Gegensatz zur ersten Variante wird der erste Parameter in den Erweiterungsblock ausgelagert und steht potentiell allen Erweiterungsmitliedern für den betroffenen Datentyp zentral zur Verfügung.

Innerhalb eines Erweiterungsblocks werden Erweiterungsmethoden so implementiert, als würden sie sich regulär im betroffenen Datentyp befinden.
Sofern es sich also wie bei der früheren Variante um eine Methode auf Objektebene handeln soll, darf diese nicht mehr als statisch ausgezeichnet werden.
Sollte eine Methode bei dieser Variante dennoch als statisch deklariert werden, gilt sie auf Klassenebene. Dies war vor C#&nbsp;14 nicht möglich.

<syntaxhighlight lang="csharp">
public static class ExtensionKlasse
{
    extension(int zahl)
    {
        public int MalDrei()
        {
            return zahl * 3;
        }
    }
}
</syntaxhighlight>

Das Resultat der beiden Varianten ist identisch.

<syntaxhighlight lang="csharp">
using System;
public static class Programm
{
    public static void Main()
    {
        // 5979
        Console.WriteLine(1993.MalDrei());
    }
}
</syntaxhighlight>

Sofern die Klasse ''ExtensionKlasse'' für eine andere Klasse sichtbar ist, werden nun alle Zahlen vom Typ ''int'' mit der Methode ''MalDrei'' erweitert ohne aber den Typ ''int'' wirklich zu ändern. Der Compiler macht hierbei intern nichts anderes als die Methode ''MalDrei'' der Klasse ''ExtensionKlasse'' aufzurufen und den Wert 1993 als ersten Parameter zu übergeben.

== Methoden ==
=== Anonyme Methoden ===
Anonyme Methoden werden u.&nbsp;a. verwendet, um Code für ein Event zu hinterlegen, ohne in einer Klasse eine Methode mit einem eindeutigen Namen definieren zu müssen. Anstelle des Methodennamens steht das Schlüsselwort ''delegate'':

<syntaxhighlight lang="csharp">
Button btn = new Button()
{
    Name = "MeinButton",
    Text = "Klick mich!"
};

btn.Click += delegate(object sender, EventArgs e)
{
    Button button = (Button)sender;

    MessageBox.Show("Der Button '" + button.Name + "' wurde angeklickt!");
};
</syntaxhighlight>

=== Lambdaausdrücke ===
Ab der Version 3.0 besteht die Möglichkeit, anonyme Methoden in kürzerer Form zu definieren. Dies geschieht mit dem Operator Lambda <code>=></code> (ausgesprochen: ''„wechselt zu“''). Auf der linken Seite des Lambda-Operators werden die Eingabeparameter angegeben, auf der rechten Seite befindet sich der Anweisungsblock bzw. ein Ausdruck. Handelt es sich um einen Anweisungsblock, spricht man von einem ''Anweisungslambda''. Ein ''Ausdruckslambda'', wie zum Beispiel <code>x => x * x</code>, ist hingegen ein Delegate, dessen einzige Anweisung ein <code>return</code> ist. Der Typ der Eingabeparameter kann weggelassen werden, wenn der Compiler diese ableiten kann. Lambda-Ausdrücke können sich auf äußere Variablen beziehen, die im Bereich der einschließenden Methode oder des Typs liegen, in dem der Lambda-Ausdruck definiert wurde.

<syntaxhighlight lang="csharp">
Button btn = new Button()
{
    Name = "MeinButton",
    Text = "Klick mich!"
};

// 'sender' wird implizit als System.Object betrachtet
//
// 'e' wird implizit als System.EventArgs betrachtet
btn.Click += (sender, e) => {
    Button button = (Button)sender;

    MessageBox.Show("Der Button '" + button.Name + "' wurde angeklickt!");
};
</syntaxhighlight>

== LINQ ==
{{Hauptartikel|LINQ}}
LINQ definiert drei Dinge:
# Eine Syntax für Abfrage-Ausdrücke, die sich stark an [[SQL]] orientiert,
# Übersetzungsregeln,
# Namen (kaum mehr) für Methoden, die in Übersetzungsergebnissen benutzt werden.
Implementiert wird die Funktionalität durch sogenannte LINQ-Provider, die die namentlich definierten Methoden zur Verfügung stellen. Einer davon ist zum Beispiel LINQ-to-Objects.

<syntaxhighlight lang="csharp">
// nimm die Liste der Mitarbeiter und
// schreibe jedes Element nach 'm'
var liste = from m in this.MitarbeiterListe

// lies das Property 'Nachname' und nimm nur die
// Elemente, die gleich 'Mustermann' sind
where m.Nachname == "Mustermann"

// sortiere zuerst ABsteigend nach dem Property 'Vorname'
// dann AUFsteigend nach dem Property 'MitarbeiterNummer'
orderby m.Vorname descending, m.MitarbeiterNummer

// wähle nun zum Schluss als Element für die Liste namens 'liste'
// den Wert aus dem Property 'Vorname' jedes Elements aus
select m.Vorname;
</syntaxhighlight>

In [[MySQL]] könnte der obere Ausdruck bspw. folgendermaßen aussehen:

<syntaxhighlight lang="mysql">
SELECT m.Vorname FROM MitarbeiterListe AS m
WHERE m.Nachname = "Mustermann"
ORDER BY m.Vorname DESC, m.MitarbeiterNummer ASC
</syntaxhighlight>

== Typumwandlungen ==
In C# ist jeder [[Variable (Programmierung)|Variablen]] ein Datentyp zugeordnet. Manchmal ist es nötig, Typen von Variablen ineinander umzuwandeln. Zu diesem Zweck gibt es Typumwandlungsoperationen. Dabei gibt es implizite und explizite Typumwandlungen.

Eine implizite Typumwandlung erscheint nicht im Quelltext. Sie wird vom [[Compiler]] automatisch in den erzeugten Maschinen-Code eingefügt. Voraussetzung dafür ist, dass zwischen Ursprungs- und Zieltyp eine implizierte Typumwandlungsoperation existiert.

Für explizite Typumwandlungen sind in C# zwei Konstrukte vorgesehen:

<code>(Zieldatentyp) Variable_des_Ursprungsdatentyps</code>

<code> Variable_des_Ursprungsdatentyps <span style="color: blue;">as</span> Zieldatentyp</code>

Während erstere Umwandlung im Fall einer ungültigen Typumwandlung eine Ausnahme auslöst, ist Letztere nur möglich, wenn der Zieldatentyp ein [[Referenzdatentyp]] ist. Bei einer ungültigen Typumwandlung wird hier dem Ziel der [[Nullwert#Nullwert als grundverschiedener Wert|Nullzeiger]] zugewiesen.

<syntaxhighlight lang="csharp">
using System.Collections;
public class CastBeispiel
{
    public static void Main()
    {
        long aLong = long.MaxValue;
        //Typumwandlung nach int, aInt hat danach den Wert −1,
        //nicht in einem unchecked{}-Block eingeschlossen, wird jedoch eine Ausnahme geworfen.
        unchecked {
            int aInt = (int) aLong;
        }
        //Umwandlung nach object
        object aObject = aInt as object;
        //ungültige Typumwandlung, liste2 erhält den Wert null
        IList liste2 = aObject as IList;

        //ungültige Typumwandlung, löst zur Laufzeit eine InvalidCastException aus,
        //da das Object nicht vom Typ Liste ist.
        IList liste = (IList)aObject;
        //Löst den Kompilierfehler CS0077 aus, da int kein Referenztyp ist
        int aInt2 = aLong as int;
    }
}
</syntaxhighlight>
Die <code>unchecked</code>-Anweisung bzw. Anweisungsblock dient dazu den Überlauf einer Ganzzahl zu ignorieren. Mit <code>checked</code> hingegen wird bei einem Überlauf ein OverflowException ausgelöst.

Zu den Typumwandlungen gehört auch das sogenannte ''„Boxing“''. Es bezeichnet die Umwandlung zwischen Wert- und Referenztypen. Der Zieltyp wird wie bei der expliziten Konvertierung in Klammern vor den umzuwandelnden Typ geschrieben. Erfolgt dies implizit, so spricht man von ''„Autoboxing“''.

=== Benutzerdefinierte Typumwandlungen ===
C# erlaubt die Definition von benutzerdefinierten Typumwandlungen. Diese können als explizit oder implizit markiert werden. Implizite benutzerdefinierte Typumwandlung kommen u.&nbsp;a. bei der Überladungsauflösung zum Tragen, während explizite dann verwendet werden, wenn oben genannte explizite Typumwandlungssyntax benutzt wird.

''Siehe auch:'' [[#Operatoren überladen|Operatoren überladen]], [[Typumwandlung|Explizite Typumwandlung]]

== Parametrische Polymorphie (Generics) ==
Bei der Definition von Interfaces, Klassen, Strukturen, Delegate-Typen und Methoden können Typparameter angegeben und gegebenenfalls mit Einschränkungen versehen werden. Werden Typparameter angegeben, so erhält man ''generische'' Interfaces, Klassen, und so weiter. Bei der späteren Benutzung solcher Generics füllt man die Typparameter mit konkreten Typargumenten.

=== Definitionsseitige Ko- und Kontravarianz ===
Ab C#4 ist es möglich, Typparametern von Interfaces und Delegate-Typen eine Varianzannotation mitzugeben. Diese beeinflusst die Subtyprelation. Angenommen, der generische Typ heiße <code>K</code> und habe einen einzigen Typparameter <code>T</code>. Möglich sind dann:
* ''Kovarianz'': <code>K&lt;out T></code>; Wenn <code>A</code> Subtyp von <code>B</code> ist, dann ist <code>K&lt;A></code> Subtyp von <code>K&lt;B></code>,
* ''Kontravarianz'': <code>K&lt;in T></code>; Wenn <code>A</code> Subtyp von <code>B</code> ist, dann ist <code>K&lt;B></code> Subtyp von <code>K&lt;A></code>,
* ''Invarianz'': <code>K&lt;T></code>; Es gibt keine Untertypbeziehung zwischen Instanziierungen von <code>K</code> mit verschiedenen Typargumenten <code>T</code>.

(Jedem Typparameter kann unabhängig von anderen eine Varianzannotation mitgegeben werden.)

Neben der Fortsetzung von Untertypbeziehungen von Typargumenten auf Instanzen von Generics beeinflusst die Varianzannotation auch, an welchen Stellen ein Typparameter benutzt werden darf. So sind beispielsweise die Benutzung von kovarianten Typparametern als Typen von Methodenargumenten und die Benutzung von kontravarianten Typparametern als Rückgabetypen nicht erlaubt.
<!-- == Überladen im Vergleich zu Überschreiben == -->

== Assemblies ==
{{Hauptartikel|.Net-Framework#Assemblies|titel1=.NET Assemblies}}
== Attribute (Metadaten) ==
Attribute geben die Möglichkeit Metadaten für Assemblies, Funktionen, Parameter, Klassen, Strukturen, Enumerationen oder Felder anzugeben. Diese können Informationen für den Compiler enthalten, für die [[Laufzeitumgebung]] oder über [[Reflexion (Programmierung)|Reflexion]] während der Laufzeit ausgelesen werden. In C# werden diese mit eckigen Klammern über dem Ziel angegeben. Das STAThread-Attribut wird z.&nbsp;B. benötigt, wenn ein Programm [[Component Object Model|COM]] Interoperabilität unterstützen soll – Die Fehlermeldung lautet sonst: „Es wurde eine steuernde ‚IUnknown‘ ungleich NULL angegeben, aber entweder war die angeforderte Schnittstelle nicht 'IUnknown', oder der Provider unterstützt keine COM Aggregation.“
<syntaxhighlight lang="csharp">
[STAThread()]
public static void Main(string[] argumente)
{
    //...
}
</syntaxhighlight>

Attribute selbst sind wiederum Klassen, die von der Klasse ''Attribute'' abgeleitet sind, und können beliebig selbst definiert werden.

Beispiel:

<syntaxhighlight lang="csharp">
[AttributeUsage(AttributeTargets.All)]
public class Autor : System.Attribute
{
    public int Age
    {
        get;
        set;
    }

    public Autor(string name)
    {
        //...
    }
}
</syntaxhighlight>

Verwendung:

<syntaxhighlight lang="csharp">
[Autor("Name des Autors")]
[Autor("Name des 2. Autors",Age=20)]
[Version(1,0,0,0)]
public class IrgendeineKlasse()
{
    //...
}
</syntaxhighlight>

Abfrage von Attributen:

<syntaxhighlight lang="csharp">
Autor[] a = typeof(IrgendeineKlasse).GetCustomAttributes(typeof(Autor), false) as Autor[];
</syntaxhighlight>

== Ausnahmen/Exceptions ==
Schema:

<syntaxhighlight lang="csharp">
try {
    // öffnet den Block um den Codeteil, dessen
    // Fehler abgefangen werden sollen.
    // ...unsichere Verarbeitung...
}
catch (ExceptionTypException exception_data) {
    // Fängt alle Exceptions vom Typ ExceptionTypException
    // ...tut was wenn ExceptionTypException geworfen wurde...
}
catch (Exception ex){
    //Fängt alle Exceptions welche von Exception abgeleitet wurden
    // ...tut was wenn Exception geworfen wurde...
}
finally {
    // Wird zwingend ausgeführt
}
</syntaxhighlight>

Es ist nicht zwingend erforderlich, dass immer alle Blöcke (<code>catch</code>, <code>finally</code>) angegeben werden. Den Umständen entsprechend kann auf einen <code>try</code>-Block auch direkt ein <code>finally</code>-Block folgen, wenn beispielsweise keine Behandlung einer Ausnahme erwünscht ist. Zudem ist es nicht zwingend erforderlich, dass auf ein <code>try</code>-<code>catch</code>-Konstrukt ein <code>finally</code>-Block folgen muss. Es ist jedoch nicht möglich, nur einen <code>try</code>-Block zu definieren. Ein <code>try</code>-Block muss mindestens von einem weiteren Block gefolgt werden.

Zudem ist es möglich, mehrere <code>catch</code>-Blöcke zu definieren. Wird im <code>try</code>-Bereich eine Ausnahme ausgelöst, so werden alle vorhandenen <code>catch</code>-Blöcke der Reihe nach durchgegangen, um zu sehen, welcher Block sich um die Ausnahme kümmert. Somit ist es möglich, gezielt verschiedene Reaktionen auf Ausnahmen zu programmieren.

Wird eine Ausnahme von keinem <code>catch</code>-Block abgefangen, so wird diese an die nächsthöhere Ebene weitergegeben.

Beispiele vordefinierter Ausnahme-Klassen:
* Exception
* SystemException
* IndexOutOfRangeException
* NullReferenceException
* InvalidOperationException
* ArgumentException
* ArgumentNullException
* ArithmeticException
* ArithmeticOutOfRangeException
* OverflowException
* DllNotFoundException

Bei der Implementierung eigener, nicht-kritischer Ausnahmen, ist darauf zu achten, nicht von der Klasse <code>Exception</code> abzuleiten, sondern von <code>ApplicationException</code>.

=== Throw ===
Mittels <code>throw</code> ist es möglich eine, in einem <code>catch</code>-Block, aufgefangene Ausnahme eine Ebene höher zu „werfen“ (weitergeben). Somit ist es möglich, dass auch nachfolgender Code von der aufgetretenen Ausnahme informiert wird und somit seinerseits Aktionen unternehmen kann, um auf die Ausnahme zu reagieren. Der Aufruf-Stack bleibt erhalten.

Durch <code>throw</code> kann auch eine neue Ausnahme ausgelöst werden, beispielsweise eine programmspezifische Ausnahme, die nicht durch bereits vorhandene C#-Ausnahmen abgedeckt wird.

== Unsicherer Code ==
Durch die [[Codeverifizierung]] und [[.NET-Zugriffsverifizierung]] werden bei C# Speicherzugriffsfehler verhindert. Bei Verwendung von Zeigern werden diese Sicherheitsmechanismen umgangen. Dies ist nur in der Betriebsart „Unsafe Code“ möglich.

Beispiel:

<syntaxhighlight lang="csharp">
using System;
class us_code {
    public static void Main() {
        unsafe {
            int i = 1; // i hat den Wert 1
            int* p = &i; // p zeigt auf den Speicher von i mit dem Wert 1
            Console.WriteLine("p = " + *p + ", i = " + i);
            i = 2;   // Sowohl i als auch *p haben nun den Wert 2...
            Console.WriteLine("p = " + *p + ", i = " + i);
        }
    }
}
</syntaxhighlight>

Zudem können Klassen und Methoden als ''unsafe'' deklariert werden.

== Kommentare und Dokumentation ==
In C# sind, wie in C, C++ und Java, sowohl Zeilen- als auch Blockkommentare möglich.

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 (Programmierung)|Kommentar]] angesehen und vom [[Compiler]] übergangen.

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

Sowohl Zeilen- als auch Blockkommentare können zu Beginn oder auch mitten in einer Zeile beginnen. Blockkommentare können in derselben Zeile enden und es kann ihnen Quelltext folgen, der vom Compiler ausgewertet wird. Alles was innerhalb des Blockkommentars steht, wird vom Compiler übergangen.

<syntaxhighlight lang="csharp">
// Dies ist ein Zeilenkommentar, der mit dem Zeilenumbruch endet
System.Console.WriteLine("Ein Befehl"); // Ein Zeilenkommentar am Zeilenende
/* Dies ist ein Blockkommentar, der in der gleichen Zeile endet */
System.Console.WriteLine("Ein weiterer Befehl"); /* Ein mehrzeiliger
Blockkommentar */System.Console.WriteLine("Noch ein Befehl");
System.Console.WriteLine("Befehl 1"); /* Kommentar */ System.Console.WriteLine("Befehl 2");
System.Console/* Kommentar */.WriteLine( /* Kommentar */ "..." )
</syntaxhighlight>

Hinweis: Es sind auch Kommentare innerhalb einer Anweisung bzw. Deklaration möglich, z.&nbsp;B. zur Kommentierung einzelner Methodenparameter. Diese Art von Kommentaren sollte 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 [[Extensible Markup Language|XML]]-basierte Dokumentation erzeugen zu lassen.

Zur Dokumentation von Typen (das heißt, Klassen und deren Elemente wie Attribute oder Methoden) steht eine spezielle Form von Zeilenkommentaren bereit. Hierzu beginnt der Zeilenkommentar mit einem weiteren, dritten Schrägstrich (''///'') und befindet sich direkt über dem zu dokumentierenden Typ (z.&nbsp;B. einer Methode). Es folgen nun XML-Tags, die jeweils eine bestimmte Funktion bei der Dokumentation übernehmen, beispielsweise eine Zusammenfassung durch einen ''Summary-Tag''. Alternativ kann auch ein Blockkommentar verwendet werden, der mit ''/**'' statt ''/*'' eingeleitet wird.

<syntaxhighlight lang="csharp">
/// <summary>
/// Diese Funktion gibt den größeren Betrag zurück
/// </summary>
/// <param name="a">Der erste Übergabeparameter</param>
/// <param name="b">Der zweite Übergabeparameter</param>
/// <returns>Die Zahl mit dem größeren Betrag</returns>
/// <remarks>Diese Funktion gibt den größeren Betrag der beiden Übergebenen <see cref="Int32"/>zurück.
/// Sind die Beträge gleich groß, ist dies ein Fehler</remarks>
/// <exception cref="ArgumentException">Der Betrag der beiden Zahlen ist gleich groß</exception>
public int GetGreaterAbs(int a, int b)
{
    return Math.Max(Math.Abs(a), Math.Abs(b));
}
</syntaxhighlight>

Statt die Dokumentation explizit einzufügen, kann auch eine externe Ressource referenziert werden, die die Dokumentation enthält:

<syntaxhighlight lang="csharp">
/// <include file='xml_include_tag.doc' path='MyDocs/MyMembers[@name="test"]/*' />
</syntaxhighlight>

Dokumentation im XMLDoc-API-Dokumentationsformat wird vom Compiler als ein normaler Zeilenkommentar angesehen. Erst durch Angabe der Compiler-Option „/doc“ werden Kommentare, die mit drei Schrägstrichen beginnen, als XMLDoc erkannt und aus dem Quellcode in eine Datei extrahiert. Diese kann dann weiterverarbeitet werden, z.&nbsp;B. ähnlich wie bei [[Javadoc]] zur Erstellung einer [[Hypertext Markup Language|HTML]]-Hilfe verwendet werden (NDoc). Wenn die Entwicklungsumgebung dazu in der Lage ist, kann sie die formalisierte Dokumentation dazu benutzen, um an Verwendungsstellen aufgerufener Funktionen deren Beschreibung als Tooltip anzuzeigen; ebenso bei der Eingabe von Funktionsparametern.

{{Siehe auch|Kommentar (Programmierung)}}

== Schlüsselwörter ==
=== Reservierte Schlüsselwörter ===
Die folgenden Bezeichner sind ''reservierte Schlüsselwörter'' und dürfen nicht für eigene Bezeichner verwendet werden, sofern ihnen nicht ein <code>@</code>-Zeichen vorangestellt wird (zum Beispiel <code>@else</code>).<ref name="reserved">{{Internetquelle |url=https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/ |titel=C#&nbsp;Keywords |werk=learn.microsoft.com |hrsg=Microsoft |sprache=en |abruf=2025-11-19}}</ref>

<div style="font-family:monospace, monospace;">
[[#Zugriffsmodifikatoren|abstract]] [[#Typumwandlungen|as]]<br />[[#Das Schlüsselwort base|base]] [[#Datentypen und Speicherbedarf|bool]] [[#Die Sprunganweisungen break, continue, goto, return, yield return/break|break]] [[#Datentypen und Speicherbedarf|byte]]<br />[[#Bedingte Ausführung (if, else, switch)|case]] [[#Ausnahmen/Exceptions|catch]] [[#Datentypen und Speicherbedarf|char]] [[#Typumwandlungen|checked]] [[#Objekte und Klassen|class]] [[#Konstanten (Schlüsselwort const)|const]] [[#Die Sprunganweisungen break, continue, goto, return, yield return/break|continue]]<br />[[#Datentypen und Speicherbedarf|decimal]] [[#Bedingte Ausführung (if, else, switch)|default]] delegate [[#Schleifen (for, do, while, foreach)|do]] [[#Datentypen und Speicherbedarf|double]]<br />[[#Bedingte Ausführung (if, else, switch)|else]] [[#Aufzählungen (Enumerationen)|enum]] event explicit extern<br />false [[#Ausnahmen/Exceptions|finally]] fixed [[#Datentypen und Speicherbedarf|float]] [[#Schleifen (for, do, while, foreach)|for]] [[#Schleifen (for, do, while, foreach)|foreach]]<br />[[#Die Sprunganweisungen break, continue, goto, return, yield return/break|goto]]<br />[[#Bedingte Ausführung (if, else, switch)|if]] implicit [[#Schleifen (for, do, while, foreach)|in]] [[#Datentypen und Speicherbedarf|int]] [[#Schnittstellen|interface]] [[#Zugriffsmodifikatoren|internal]] is<br />lock [[#Datentypen und Speicherbedarf|long]]<br />namespace new null<br />[[#Die Klasse namens „object“|object]] operator out [[#Zugriffsmodifikatoren|override]]<br />params [[#Zugriffsmodifikatoren|private]] [[#Zugriffsmodifikatoren|protected]] [[#Zugriffsmodifikatoren|public]]<br />readonly ref [[#Die Sprunganweisungen break, continue, goto, return, yield return/break|return]]<br />[[#Datentypen und Speicherbedarf|sbyte]] [[#Zugriffsmodifikatoren|sealed]] [[#Datentypen und Speicherbedarf|short]] sizeof stackalloc [[#Zugriffsmodifikatoren|static]] string [[#Strukturen (struct)|struct]] [[#Bedingte Ausführung (if, else, switch)|switch]]<br />this [[#Throw|throw]] true [[#Ausnahmen/Exceptions|try]] typeof<br />[[#Datentypen und Speicherbedarf|uint]] [[#Datentypen und Speicherbedarf|ulong]] [[#Typumwandlungen|unchecked]] [[#Unsicherer Code|unsafe]] [[#Datentypen und Speicherbedarf|ushort]] [[#Die using-Anweisung|using]]<br />[[#Zugriffsmodifikatoren|virtual]] void volatile<br />[[#Schleifen (for, do, while, foreach)|while]]
</div>

=== Kontextschlüsselwörter ===
Die folgenden Bezeichner sind ''Kontextschlüsselwörter'', das heißt innerhalb eines gültigen Kontextes – und nur dort – haben sie eine besondere Bedeutung. Sie stellen aber keine reservierten Wörter dar, das heißt außerhalb ihres Kontextes sind sie für eigene Bezeichner erlaubt.<ref name="reserved" />

<div style="font-family:monospace, monospace;">
add allows alias and ascending args async await<br />by<br />descending dynamic<br />equals extension<br />field file from<br />[[#Eigenschaften (Schlüsselwörter get, set und value)|get]] global group<br />init into<br />join<br />let<br />managed<br />nameof nint not notnull nuint<br />on or orderby<br />partial<br />record remove required<br />scoped select [[#Eigenschaften (Schlüsselwörter get, set und value)|set]]<br />unmanaged<br />[[#Eigenschaften (Schlüsselwörter get, set und value)|value]] var<br />when where with<br />[[#Die Sprunganweisungen break, continue, goto, return, yield return/break|yield]]
</div>

== Siehe auch ==
* [[ADO.NET]]
* [[ASP.NET]]
* [[Mono (Software)|Mono]]
* [[Anonymer Datentyp]]
* {{Internetquelle
   |url=https://msdn.microsoft.com/en-us/library/gg145045(v=VS.110).aspx
   |kommentar=Klassenbibliotheken des .NET-Frameworks
   |titel=.NET Framework Class Library
   |hrsg=Microsoft
   |werk=MSDN
   |zugriff=2013-05-11
   |sprache=en}}
* [https://ndoc.sourceforge.net/ NDoc]

== Literatur ==
* {{Literatur
   |Autor=Andreas Kühnel
   |Titel=Visual C♯ 2012 das umfassende Handbuch
   |Auflage=6., aktualisierte und erweiterte
   |Verlag=Galileo Press
   |Ort=Bonn
   |Datum=2013
   |ISBN=978-3-8362-1997-6}}

== Einzelnachweise ==
<references />

[[Kategorie:C-Sharp|!Sprachelemente]]