Sprachelemente von C-Sharp

Der sogenannte if-Block hat zur Folge, dass die zwischen den geschweiften Klammern liegenden Anweisungen nur dann in Kraft treten, wenn die angegebene Bedingung erfüllt ist, d. h. ihr Wert true ist.

Der else-Block, der nur in Verbindung mit einem if-Block stehen kann, wird nur dann ausgeführt, wenn die Anweisungen des if-Blocks nicht ausgeführt wurden.

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

Die switch-Anweisung ist die Darstellung eines Falles, in dem, je nach Wert eines Ausdrucks, andere Anweisungen ausgeführt werden müssen.

Es wird immer bei dem case-Label fortgefahren, dessen Wert mit dem Ausdruck in der switch-Anweisung übereinstimmt. Wenn keiner der Fälle zutrifft, wird zum optionalen default-Zweig gesprungen.

switch (Ausdruck)
{
    case Fall_1:
        Anweisungen;
        break;
    case Fall_2:
        Anweisungen;
        break;
    default:
        Anweisungen;
        break;
}

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

switch (Ausdruck)
{
    case Fall_1:
    case Fall_2:
        Anweisungen;
        break;
}

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

string cmd;
//...
switch (cmd)
{
    case "run":
        Anweisungen;
        break;
    case "save":
        Anweisungen;
        break;
    default:
        Anweisungen;
        break;
}

Wird eine for-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 false ergibt, d. h., ungültig wird.

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

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

while (Bedingung)
{
    Anweisungen;
}

Die Bedingung der Do-While-Schleife wird immer nach dem Anweisungsblock ausgeführt. Die Schleife wird daher mindestens ein Mal durchlaufen.

do
{
    Anweisungen;
} while (Bedingung);

Mit der foreach-Schleife wird durch alle Mitglieder einer Sequenz iteriert. In der Schleife besteht nur lesender Zugriff auf die Schleifenvariable.

foreach (Typ Variablename in Sequenz)
{
    Anweisungen;
}

for (int i = 0; i < 10; ++i)
{
    if (i < 8)
        continue;
    Console.WriteLine("Continue wurde nicht ausgeführt.");
}

Die Anweisung continue 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.

for (int i = 0; i < 100; ++i)
{
    if (i == 5)
        break;
    Console.WriteLine(i);
}

Die Anweisung break 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.

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

Mit goto springt das Programm an das angegebene Sprungziel.

Die Benutzung von goto 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 goto lesbarer ist als durch mehrfache Verwendung von break oder anderen Sprachmitteln. Siehe auch Spaghetticode.

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

int result = ImQuadrat(2);

static int ImQuadrat(int x)
{
    int a;
    a = x*x;
    return a;
}

Mit return 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 void gekennzeichnet.

Eine Besonderheit bildet der Ausdruck yield return. 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 System.Collections.Generic.IEnumerable<T> abgeleitet ist und somit mit einem foreach-Block durchlaufen werden kann. Jeder Aufruf von yield return fügt bis zum Verlassen der Methode/Eigenschaft ein neues Element der Sequenz hinzu. Wird das Konstrukt nicht einmal aufgerufen, ist die Sequenz leer:

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;
    }
}

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

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;
    }
}

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

Zum Abbrechen des Vorgangs kann die Anweisung yield break verwendet werden:

// 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;
    }
}

Die Anweisungen return und yield return 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:

// 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);
}

Die using-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 using-Anweisung sicher, dass diese immer ausnahmesicher bereinigt werden.

using (Font myFont = new Font("Arial", 10.0f))
{
    g.DrawString("Hallo Welt!", myFont, Brushes.Black);
}

Hier wird ein Font-Objekt erzeugt, das am Ende des Blocks automatisch durch Aufruf seiner Dispose-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:

Font myFont = new Font("Arial", 10.0f);

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

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

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.

Jedes Objekt kann durch verschiedene Attribute beschrieben werden und verschiedene Zustände annehmen und diese auch auslösen.

Übertragen auf die objektorientierte Programmierung und C# ist ein Objekt ein Exemplar (siehe Schlüsselwort new) einer Klasse. Eine Klasse kann man dabei als Bauplan oder Gerüst eines Objektes ansehen.

Eine Klasse besitzt Eigenschaften (Variablen), Methoden (die Tätigkeiten darstellen) und Ereignisse, die die Folge von Zuständen sind bzw. diese auslösen.

Beispiel für den Bauplan eines Autos:

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; }
    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; }

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

    public delegate void MotorDelegat(bool laeuft);
    public delegate void GeschwindigkeitDelegat(double geschwindigkeit);
}

Die Klasse object (ein Alias für System.Object) ist ein Referenztyp, von dem jede Klasse abgeleitet wird. So kann durch implizite Typumwandlung jeder Objekttyp in object umgewandelt werden.

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

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

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}";
    }
}

C# fasst eine über das Schlüsselwort struct 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 dienen zur automatischen Nummerierung der in der Aufzählung enthaltenen Elemente. Die Syntax für die Definition von Aufzählungen verwendet das Schlüsselwort enum (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 int verwendet.

public enum Wochentag
{
    Montag = 1, Dienstag, Mittwoch, Donnerstag, Freitag, Samstag, Sonntag
}

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.

Wochentag Tag = Wochentag.Mittwoch;
System.Console.WriteLine(Tag); // Ausgabe: Mittwoch
System.Console.WriteLine((int)Tag); // Ausgabe: 3
System.Console.WriteLine((Wochentag)3); // Ausgabe: Mittwoch

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

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

Hinweise:

• Per Voreinstellung 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 in der aktuellen Assembly sichtbar.
• Die Modifikatoren können bis auf protected und internal nicht miteinander kombiniert werden. protected internal 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 public deklariert werden oder der Schnittstellenmember muss explizit implementiert werden.

C# kennt zwei Arten von Datentypen: Wertetypen und Referenztypen. Referenztypen dürfen dabei nicht mit Zeigern gleichgesetzt werden, wie sie u. 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, Objekte darstellen. Beim Lesen und Schreiben von Wertetypen werden die Daten dagegen über einen Automatismus, Autoboxing genannt, in einer Instanz der jeweiligen 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:

// Datentyp Variable;
int i;
System.Collections.IList liste;

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

// 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):

// 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:

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.

1234.ToString();
int i = 17;
i.ToString();

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);
    }
}

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;
}

public class EigenschaftBeispiel
{
    private string _wohnort;
    public string Wohnort
    {
        get
        {
            return _wohnort;
        }
        set
        {
            _wohnort = "12345 " + value;
        }
    }
}

EigenschaftBeispiel instanz = new EigenschaftBeispiel();
instanz.Wohnort = "Musterstadt";
Console.WriteLine(instanz.Wohnort);
// Ausgabe: ''12345 Musterstadt''

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;
}

struct Point
{
    public double X { get; set; }
    public double Y { get; set; }
}

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

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
        }
    }
}

LINQ definiert drei Dinge:

1. Eine Syntax für Abfrage-Ausdrücke, die sich stark an SQL orientiert,
2. Übersetzungsregeln,
3. 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.

// 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;

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

SELECT m.Vorname FROM MitarbeiterListe AS m
WHERE m.Nachname = "Mustermann"
ORDER BY m.Vorname DESC, m.MitarbeiterNummer ASC

In C# ist jeder 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:

(Zieldatentyp) Variable_des_Ursprungsdatentyps

Variable_des_Ursprungsdatentyps as Zieldatentyp

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 Nullzeiger zugewiesen.

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;
    }
}

Die unchecked-Anweisung bzw. Anweisungsblock dient dazu den Überlauf einer Ganzzahl zu ignorieren. Mit checked 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“.

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.

Siehe .NET Assemblies

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 während der Laufzeit ausgelesen werden. In C# werden diese mit eckigen Klammern über dem Ziel angegeben. Das STAThread-Attribut wird z. B. benötigt, wenn ein Programm 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.“

[STAThread()]
public static void Main(string[] argumente)
{
    //...
}

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

Beispiel:

[AttributeUsage(AttributeTargets.All)]
public class Autor : System.Attribute
{
    public int Age
    {
        get;
        set;
    }

    public Autor(string name)
    {
        //...
    }
}

Verwendung:

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

Abfrage von Attributen:

Autor[] a = typeof(IrgendeineKlasse).GetCustomAttributes(typeof(Autor), false) as Autor[];

Schema:

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
}

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

Zudem ist es möglich, mehrere catch-Blöcke zu definieren. Wird im try-Bereich eine Ausnahme ausgelöst, so werden alle vorhandenen catch-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 catch-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 Exception abzuleiten, sondern von ApplicationException.

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:

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);
        }
    }
}

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

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

// 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 */ "..." )

Hinweis: Es sind auch Kommentare innerhalb einer Anweisung bzw. Deklaration möglich, z. 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 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. 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.

/// <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));
}

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

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

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. B. ähnlich wie bei Javadoc zur Erstellung einer 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.

• ADO.NET
• ASP.NET
• Mono
• Anonymer Datentyp
• .NET Framework Class Library. In: MSDN. Microsoft, abgerufen am 11. Mai 2013 (englisch, Klassenbibliotheken des .NET-Frameworks).
• NDoc

• Andreas Kühnel: Visual C♯ 2012 das umfassende Handbuch. 6., aktualisierte und erweiterte Auflage. Galileo Press, Bonn 2013, ISBN 978-3-8362-1997-6.

1. Benutzerdefinierte bedingte logische Operatoren. Microsoft Developer Network (MSDN), abgerufen am 25. April 2011.