C# und .NET – Zusammenfassung

Was ist C#?

C# wurde exklusiv für die Microsoft .NET Framework-Plattform entwickelt und wird als „See Sharp“ ausgesprochen.

Microsoft benötigte ein einheitliches, vollständig objektorientiertes integriertes Entwicklungsframework, um die Schwächen älterer Technologien zu beseitigen. Aus diesem Grund begann die Firma mit der Entwicklung einer neuen Code-Ausführungsumgebung samt kompletter Entwicklerwerkzeugkette.

Nach über 20 Jahren Weiterentwicklung hat sich C# von einem rein Windows-basierten Sprachwerkzeug zu einer plattformübergreifenden Programmiersprache gewandelt.

Heute bilden C# und .NET eine vollständige plattformübergreifende Lösung. Man kann damit Anwendungen für Windows, macOS, Linux und Android erstellen. Gleichzeitig ist es die bevorzugte Laufzeitumgebung für die meisten Cloud-Systeme.

Dank der starken Unterstützung von Microsoft werden C#-Versionen in sehr kurzen Abständen veröffentlicht. Im Jahr 2022 erschien Version 7. C# bleibt abwärtskompatibel zu Code, der vor 20 Jahren geschrieben wurde, während neue Versionen eine kompaktere, elegantere Syntax und gestraffte Strukturen bieten. Stand 2026 liegt die aktuelle Version 15 vor.

Kurze Versionsgeschichte von C# (Auszug)

• C# 1.0 (2001): Offizielle Erstveröffentlichung
• C# 2.0 (VS2005): Generika, Iteratoren, anonyme Methoden
• C# 3.0 (VS2008): Erweiterungsmethoden, Lambda-Ausdrücke, LINQ (sprachintegrierte Abfragen)
• C# 4.0 (2010): Benannte / optionale Parameter, dynamischer Typ dynamic, TPL Parallel Task Library zur vollen Ausnutzung von Mehrkernprozessoren
• C# 5.0: Native Unterstützung für asynchrone Aufgaben mit async/await
• C# 6.0: String-Interpolation, Expression-Body-Members, vereinfachte Eigenschaftssyntax
• C# 7.0~7.3: Mehrfachrückgabewerte per Tupel, vereinfachte out-Parameter, Musterabgleich, asynchrone Main-Methode
• C# 8.0/9.0/10.0: Records (unveränderliche Referenztypen), Top-Level-Statements (keine Main-Methode erforderlich), Standardschnittstellenmethoden, statische lokale Funktionen, asynchron freigebbare Typen, sprachweiter Musterabgleich
• C#11 (.NET7): Raw-Strings, generische Mathematik, required-Eigenschaften
• C#12 (.NET8): Primäre Konstruktoren, Kurzschreibweise für Collections, Inline-Arrays
• C#13 (.NET9): Partielle Eigenschaften, Erweiterungsindexer, Iterator-ref-Lokale
• C#14 (.NET10): Generische Aliase, tiefer Collection-Musterabgleich, SIMD-Syntaktischer Zucker

Windows bleibt nach wie vor die zentrale Plattform für C#. Über die .NET-Laufzeit lässt sich Code aber direkt unter Systemen wie Linux ausführen – damit schreibt man einmal und verteilt auf mehrere Betriebssysteme.

Das .NET Framework

Das .NET Framework wurde erstmals im Jahr 2002 veröffentlicht.

Das .NET Framework beseitigt die Schwächen älterer Entwicklungsverfahren und verfügt über diese zentralen Vorteile:

1. Mehrgeräte-Plattformunterstützung: Läuft auf Servern, PCs, PDAs, Mobiltelefonen und weiterer Hardware;
2. Einhaltung von Industriestandards: Native Unterstützung gängiger Kommunikationsprotokolle wie XML, HTTP, SOAP, JSON und WSDL;
3. Sicherheits-Sandbox: Isoliert die Ausführung von Code aus nicht vertrauenswürdigen Quellen zur Gewährleistung der Systemsicherheit.

Die drei zentralen Bestandteile des .NET Framework

1. CLR Common Language Runtime (Ausführungsumgebung) steuert den gesamten Lebenszyklus von Programmen: Speicherverwaltung und Garbage Collection, Code-Sicherheitsprüfung, Thread-Planung und Ausnahmebehandlung.
2. Entwicklerwerkzeugsammlung Integrierte Entwicklungsumgebungen, mehrsprachige .NET-Compiler (C#/VB.NET/F# u.a.), Debugger sowie Web-Backend-Technologien wie ASP.NET/WCF.
3. BCL Basisklassenbibliothek (auch FCL Framework Class Library genannt) Enthält eine riesige Auswahl vordefinierter generischer Klassen, die Entwickler direkt aufrufen können.

Verbesserungen von .NET gegenüber der klassischen Windows-Entwicklung

Einheitliches objektorientiertes System

CLR, BCL und C# sind eng verzahnt und stellen ein einheitliches OOP-Modell bereit. Desktop-, Mobile-, Web- und verteilte Anwendungen nutzen das gleiche Entwicklungsvorgehen, Syntax und Logik bleiben geräteübergreifend konsistent.

Automatische Garbage Collection GC

Die CLR bringt einen integrierten Garbage Collector mit, der Speicher nicht mehr genutzter Objekte automatisch freigibt. Entwickler müssen Speicher nicht manuell verwalten oder Speicherlecks aufspüren – der Wartungsaufwand sinkt deutlich.

Mehrdimensionale Interoperabilität

1. Sprachübergreifender Austausch innerhalb von .NET: Klassen aus verschiedenen .NET-Sprachen können sich gegenseitig aufrufen und erben; die Plattform ist nicht an eine einzelne Programmiersprache gebunden;
2. P/Invoke Plattformaufruf: Direkter Aufruf nativer Win32-C-DLL-Schnittstellen;
3. COM-Kompatibilität .NET-Komponenten und klassische COM-Komponenten können wechselseitig aufgerufen werden.

Vereinfachte Bereitstellung: Keine Abhängigkeit von der Windows-Registrierung; im Minimalfall genügt das Kopieren der Dateien zum Ausführen des Programms;

Side-by-Side-Assemblys: Auf einem Gerät können mehrere Versionen einer DLL parallel installiert sein. Jedes Programm bindet sich an die Bibliotheksversion, mit der es kompiliert wurde – DLL-Versionskonflikte werden beseitigt.

Typsicherheitsprüfung Die CLR (Common Language Runtime) prüft Parameter und Datentypen zwangsweise. Auch bei der Zusammenarbeit von Komponenten unterschiedlicher Sprachen bleibt die Typsicherheit erhalten, unzulässige Speicherzugriffe werden blockiert.

Umfangreiche BCL-Basisklassenbibliothek

Viele generische Hilfsklassen sind bereits integriert

• Basiswerkzeuge für Dateiverarbeitung, Zeichenketten, Verschlüsselung und Sicherheit;
• Collections-Container wie Listen, Dictionaries, Hashtabellen;
• Werkzeuge für Multithreading, Synchronisation und Parallelverarbeitung;
• Klassen zum Lesen und Schreiben von XML-Dokumenten
• und viele weitere Module

Sämtliche allgemeine Basislogik ist bereits implementiert. Entwickler brauchen nur geschäftsspezifische Logik zu schreiben und fertige Hilfsmodule wiederzuverwenden, um Doppelentwicklungen zu vermeiden.

Flussdiagramm eines .NET-Programms: Der von Ihnen geschriebene Code wird zu Zwischencode IL kompiliert. Der IL-Code kann Bibliotheken der BCL aufrufen und wird abschließend an die CLR zur Ausführung übergeben.

Die Beziehung zwischen C# und .NET

.NET Framework: Eine vollständige Entwicklungs- und Ausführungsplattform, bestehend aus zwei zentralen Komponenten

1. CLR (Common Language Runtime): Zuständig für Speicherverwaltung des Codes, Ausführungssteuerung und Sicherheitsprüfungen
2. BCL (Basisklassenbibliothek): Große Sammlung generischer Hilfscode (Dateien, Netzwerk, UI, Parallelverarbeitung u.v.m.)

C#: Eine Programmiersprache, die speziell für die .NET-Plattform entworfen wurde, um Code zu schreiben, das auf der CLR ausgeführt wird

Neben C# gibt es weitere Programmiersprachen mit .NET-Unterstützung, beispielsweise F# und VB.NET.

Ziel des .NET Frameworks ist plattform- und sprachübergreifende Funktionsweise. Plattformübergreifend bedeutet die Ausführung auf verschiedenen Betriebssystemen; sprachübergreifend bedeutet, dass Komponenten aus unterschiedlichen Sprachen gegenseitig aufeinander zugreifen können.

Kompilierung zum Common Intermediate Language (CIL)

Der Compiler jeder .NET-Sprache liest Quellcodedateien und erzeugt Ausgabedateien namens Assemblys

Es gibt zwei Typen von Assemblys: Ausführbare Dateien (exe) oder dynamische Linkbibliotheken (DLL)

Der Code innerhalb einer Assembly ist kein nativer Maschinencode des Prozessors, sondern Zwischencode mit dem Namen Common Intermediate Language (CIL).

Eine Assembly enthält hauptsächlich diese Inhalte:

1. CIL-Befehlscode des Programms
2. Metadaten zu allen im Programm definierten Typen
3. Metadaten mit Verweisbeziehungen zu externen Assemblys

Die Abkürzung für Zwischencode hat sich im Laufe der .NET-Entwicklung geändert, unterschiedliche Dokumente verwenden verschiedene Begriffe. Sowohl Intermediate Language (IL) als auch Microsoft Intermediate Language (MSIL) bezeichnen den CIL.

Kompilierung zu nativem Code und Ausführung

CIL wird nicht vorab in nativen Maschinencode umgewandelt. Erst beim Start des Programms führt die CLR diese drei Schritte durch:

1. Prüfung der Sicherheitsinformationen der Assembly
2. Zuweisung von Ausführungsspeicher
3. Übergabe an den JIT-Compiler zur abschnittsweisen Kompilierung zu nativem Code

JIT-On-Demand-Kompilierungsmechanismus

Nur tatsächlich ausgeführter Code wird kompiliert und danach im Cache zur Wiederverwendung abgelegt. Nicht aufgerufener Code bleibt unkompiliert, derselbe Codeabschnitt wird nur einmal umgewandelt.

Assembly (CIL + Typinformationen) → CLR (JIT-Compiler) → Nativer Code → Betriebssystemdienste

Verantwortungsbereiche der CLR-Verwaltung

Nach der Umwandlung von CIL zu nativem Code verwaltet die CLR automatisch: Rückgewinnung ungenutzten Speichers, Array-Grenzenprüfung, Parametertyp-Prüfung und Ausnahmebehandlung.

Verwalteter und nicht verwalteter Code

• Verwalteter Code: Code aus .NET-Sprachen, dessen Ausführung von der CLR gesteuert wird
• Nicht verwalteter Code: Unterliegt keiner CLR-Steuerung, Beispiele sind native Win32-DLLs aus C/C++

Microsoft bietet inzwischen die AOT-Kompilierung an: Man kann C#-Code direkt zu nativem Maschinencode bauen. Ähnlich wie bei C++ läuft die EXE-Datei ohne vorinstallierte .NET-Laufzeitumgebung.

Das NGen-Werkzeug

Es kompiliert Assemblys offline zu nativen Images. Beim Programmstart entfällt der JIT-Schritt, wodurch die Startgeschwindigkeit steigt.

.NET Core AOT ist die neue Generation der Vorabkompilierung, sie erzeugt eigenständige native Ausführungsdateien ohne Laufzeitabhängigkeiten.

Assembly (Typinformationen, CIL)
        ↓
JIT-Compiler
        ↓
Nativer Code
        ↓
Betriebssystemdienste

Unabhängig von der ursprünglichen Quellsprache folgt jeder Code dem gleichen Kompilierungs- und Ausführungsablauf.

Jede Sprache verfügt über einen eigenen Compiler: VB.NET hat einen VB-spezifischen Compiler, C# den C#-Compiler. Alle wandeln ihren Code zu CIL um, der über JIT zu nativem Code wird und vom Prozessor ausgeführt wird. Deshalb benötigen mit .NET entwickelte Software eine installierte .NET-Umgebung – genau wie Java das JRE erfordert.

flowchart TD
    subgraph Compile_Time
        A[C# Source] --> B[C# Compiler]
        B --> C[Assembly CIL]
        D[VB Source] --> E[VB Compiler]
        E --> C
        F[Xyz.NET Source] --> G[Xyz.NET Compiler]
        G --> C
    end

    subgraph Run_Time
        C --> H[JIT Compiler]
        H --> I[Native Code]
        I --> J[Operating System Services]
    end

Das obige Diagramm zeigt den vollständigen Ablauf von Kompilierung bis Ausführung für alle unterstützten Sprachen.

Common Language Runtime (CLR)

Die zentrale Komponente des .NET Framework ist die CLR. Sie liegt über dem Betriebssystem und verwaltet die gesamte Ausführung von Programmen.

• Automatische Garbage Collection (GC)
• Sicherheitsprüfung und Authentifizierung über die Basisklassenbibliothek (BCL)
• Bereitstellung umfangreicher Programmierfunktionen wie Webdienste, Datendienste und weitere Module

flowchart TD
    subgraph Unmanaged_Code
        A[Non-.NET Program] --> OS[Operating System]
    end

    subgraph Managed_Code
        B[Assembly] --> CLR[Common Language Runtime]
        C[Assembly] --> CLR
        D[Assembly] --> CLR

        subgraph CLR[Common Language Runtime]
            M[Memory Management] --- E[Exception Handling]
            G[Garbage Collection] --- R[Reflection Services]
            J[JIT Compiler] --- L[Class Loader]
            S[Security Services]
        end

        CLR --> OS
    end

Common Language Infrastructure (CLI)

Jede Programmiersprache enthält eine Menge grundlegender nativer Typen zur Darstellung von Ganzzahlen, Gleitkommazahlen, Zeichen und weiteren Datentypen.

Common Language Infrastructure (CLI) ist eine Sammlung von Standards, die alle Komponenten des .NET Framework zu einem einheitlichen, kompatiblen Gesamtsystem verbinden.

Beispielsweise ist die Bitgröße von Ganzzahlen in allen unterstützten Sprachen identisch festgelegt.

flowchart TD
    subgraph CLI[CLI]
        CLR[Common Language Runtime] --- CLS[Common Language Specification]
        BCL[Base Class Library] --- MDS[Metadata Definition & Semantics]
        CTS[Common Type System] --- CIL[Common Intermediate Language]
    end

Die meisten Entwickler müssen nicht die vollständigen CLI-Spezifikationen durchdringen, aber das Common Type System (CTS) und die Common Language Specification (CLS) sind zwingend erforderliches Grundwissen.

CTS Common Type System

• Bereitstellung eines standardisierten Satzes grundlegender Datentypen mit fest definierten Eigenschaften;
• Alle spracheigenen Typen jeder .NET-Sprache werden auf eine Teilmenge dieser Standardtypen abgebildet;
• Alle Typen erben von der Basisklasse object;
• Durch den einheitlichen Standard können systemeigene und benutzerdefinierte Typen zwischen jeder beliebigen .NET-Sprache ausgetauscht werden.

CLS Common Language Specification

Sie definiert einheitliche Regeln, die alle .NET-kompatiblen Sprachen einhalten müssen. Es umfasst Einschränkungen für den sprachübergreifenden Austausch: Datentypen, Klassenkonstruktoren, Parameterübergabe und mehr.

Unterschiede zwischen .NET und .NET Framework

.NET ist Microsofts moderne plattformübergreifende Entwicklungsplattform, das .NET Framework die ältere, ausschließlich Windows-basierte Laufzeit- und Bibliotheks-Sammlung. Neue Funktionen werden nur noch in .NET weiterentwickelt, das .NET Framework befindet sich im Wartungsmodus und erhält ausschließlich Sicherheitsupdates.

.NET arbeitet plattformübergreifend und ist die derzeit zentrale Entwicklungsplattform von Microsoft. Alle weiteren Ausführungen konzentrieren sich auf .NET.

Merkmal	.NET	.NET Framework
Plattformunterstützung	Plattformübergreifend (Windows, Linux, macOS, Container, Mobil per MAUI)	Nur Windows
Status	Fortlaufende Updates (.NET 5 bis .NET 10, jährliche Veröffentlichungen mit LTS-Langzeitunterstützung)	Wartungsmodus (4.8 ist die letzte Version, nur Sicherheits-Patches)
Leistung	Schnellerer Start, höherer Durchsatz, optimierte Garbage Collection	Ältere Architektur, abhängig von Windows-APIs, geringere Performance
Einsatzszenarien	Neuprojekte: Web-API, Microservices, Cloud-Native, plattformübergreifende Desktop/Mobil-Anwendungen	Altprojekte: Web Forms, WCF, Windows Workflow u.a.
Bereitstellung	Vollständig kompatibel mit Docker, Containern und Cloud-Umgebungen	Keine Container-Unterstützung, abhängig von Windows Server
Unterstützte Sprachen	C#, F#, VB.NET (plattformübergreifend)	C#, VB.NET (nur Windows)

Die Unterschiede zwischen .NET und .NET Framework sind gering. Beide nutzen Sprachen wie C#, F# und VB.NET und teilen sich die zentrale Syntax. Der größte Teil des geschriebenen C#-Codes lässt sich sowohl auf .NET Framework als auch auf .NET (Core/5/6/7/8…) kompilieren und ausführen.

Die Abweichungen liegen vor allem bei der verfügbaren Klassenbibliothek, nicht bei der Syntax.

Technologien, die im .NET Framework integriert waren wie WCF, Web Forms und Windows Workflow, wurden im modernen .NET entfernt oder durch Alternativen ersetzt.

Im neuen .NET wurden moderne APIs wie Span<T>, ValueTask und Records hinzugefügt, die im alten .NET Framework nicht vorhanden sind.

Da das .NET Framework nur für Windows ausgelegt ist und .NET plattformübergreifend arbeitet, wurden einige Windows-exklusive Bibliotheken aus .NET entfernt. Beispielsweise läuft System.Drawing unter Windows, im plattformübergreifenden .NET ist es als rein Windows-kompatibel markiert. Wenn Sie Zeichenfunktionen in .NET benötigen, dürfen Sie nicht System.Drawing nutzen, sondern müssen Drittbibliotheken wie Googles SkiaSharp verwenden.

Hinweis: Die genannten Unterschiede betreffen die Framework-Ebene. Auf Sprachebene, also bei C#, gibt es praktisch keine Abweichungen. Die C#-Syntax ist in beiden Umgebungen identisch. Der echte Unterschied liegt bei Klassenbibliotheken und Laufzeitumgebung – also dem Satz an nutzbaren APIs.