.NET/C#/VB.NET Glossar

A

Abbruchtoken

(siehe „Cancellation Token“)

Abhängigkeit

(siehe „Dependency“)

Abstract Class

(siehe „Abstrakte Klasse“)

Abstract Method

(siehe „Abstrakte Methode“)

Abstraction

(siehe „Abstraktion“)

Abstrakte Klasse

Synonyme:
Abstract Class

Kurz:
Eine abstrakte Klasse ist eine Klasse, die nicht direkt instanziiert werden kann und nur als Basisklasse für andere Klassen dient. Sie kann sowohl vollständig implementierte als auch abstrakte (nicht implementierte) Member enthalten, die von abgeleiteten Klassen implementiert werden müssen.

Länger:
In C# wird eine abstrakte Klasse mit dem Modifizierer abstract vor der Klassendeklaration gekennzeichnet; in VB.NET erfüllt das Schlüsselwort MustInherit denselben Zweck. Eine abstrakte Klasse kann nicht mit new instanziiert werden, sie ist implizit sealed-unabhängig zu betrachten, kann aber selbst nicht sealed/NotInheritable sein, da sie ja vererbt werden muss. Abstrakte Klassen dürfen abstrakte Methoden, Eigenschaften, Indexer oder Ereignisse enthalten (in C# mit abstract, in VB.NET mit MustOverride markiert), die keinen Methodenkörper besitzen und von jeder nicht abstrakten abgeleiteten Klasse überschrieben (implementiert) werden müssen. Gleichzeitig können abstrakte Klassen auch normale, vollständig implementierte Member bereitstellen, die von den abgeleiteten Klassen einfach geerbt werden – dies unterscheidet sie von Schnittstellen (Interfaces), die traditionell keine Implementierung vorgeben. Der zentrale Anwendungsfall ist die Definition einer gemeinsamen Basis für eine Gruppe verwandter Klassen, wobei gewisse Details der abgeleiteten Klasse überlassen werden, z. B. eine Klasse WashingMachine, die eine abstrakte Methode Wash() deklariert, welche jede konkrete Waschmaschinen-Unterklasse implementieren muss.

Abstrakte Methode

Synonyme:
Abstract Method

Kurz:
Eine abstrakte Methode ist eine Methode ohne Implementierung, die in einer abstrakten Klasse deklariert wird und von jeder nicht abstrakten abgeleiteten Klasse überschrieben werden muss. Sie legt nur die Signatur fest, nicht das konkrete Verhalten.

Länger:
In C# wird eine abstrakte Methode mit dem Modifizierer abstract deklariert; die Deklaration endet mit einem Semikolon statt eines Methodenkörpers in geschweiften Klammern, da keinerlei Implementierung erlaubt ist. Abstrakte Methodendeklarationen sind ausschließlich in abstrakten Klassen zulässig, und eine abstrakte Methode ist implizit virtuell – die Modifizierer static oder virtual dürfen deshalb nicht zusätzlich verwendet werden. Jede nicht abstrakte Klasse, die von der abstrakten Klasse erbt, muss die abstrakte Methode mit dem Schlüsselwort override implementieren, sofern sie nicht selbst wieder als abstrakt deklariert wird. In VB.NET entspricht dies dem Schlüsselwort MustOverride, wobei die umschließende Klasse dann zwingend mit MustInherit gekennzeichnet sein muss. Abstrakte Methoden sind ein zentrales Werkzeug, um in einer Klassenhierarchie ein einheitliches Verhalten zu erzwingen, während die konkrete Umsetzung den abgeleiteten Klassen überlassen bleibt, etwa eine Methode CalculateArea() in einer abstrakten Basisklasse Shape.

Abstraktion

Synonyme:
Abstraction

Kurz:
Abstraktion bezeichnet in der objektorientierten Programmierung das Modellieren der relevanten Attribute und Interaktionen von Entitäten als Klassen, um eine vereinfachte Darstellung eines Systems zu erstellen. Implementierungsdetails werden dabei hinter einer klar definierten Schnittstelle verborgen.

Länger:
Abstraktion gilt neben Kapselung, Vererbung und Polymorphismus als eines der vier Grundprinzipien der objektorientierten Programmierung in C#. Sie beschreibt allgemein die Trennung zwischen Konzept und konkreter Umsetzung: Strukturen werden über ihre Bedeutung bzw. ihr Verhalten definiert, während Details der tatsächlichen Implementierung ausgeblendet bleiben. In C# und VB.NET wird Abstraktion technisch unter anderem durch abstrakte Klassen (abstract/MustInherit) und Schnittstellen (interface) umgesetzt, die festlegen, welche Operationen ein Typ unterstützt, ohne die konkrete Realisierung vorzugeben. Ein Beispiel ist eine Klassenhierarchie mit einer gemeinsamen Basisklasse Shape, die abstrakt definiert, dass jede Form eine Fläche berechnen können muss, ohne selbst festzulegen, wie diese Berechnung für Kreis oder Rechteck konkret aussieht. Abstraktion reduziert die Komplexität eines Systems für den Anwender des Codes (Clientcode) und ist eng verwandt mit, aber nicht identisch mit Kapselung, die sich auf das Verbergen von internem Zustand konzentriert.

Access Modifier

Synonyme:
Zugriffsmodifizierer

Kurz:
Ein Access Modifier (Zugriffsmodifizierer) ist ein Schlüsselwort in C# bzw. VB.NET, das die Sichtbarkeit und Zugreifbarkeit eines Typs oder Typmembers für anderen Code festlegt.

Länger:
In C# gibt es die Zugriffsmodifizierer public, private, protected, internal, die Kombinationen protected internal und private protected sowie seit C# 11 zusätzlich file. Sie werden bei der Deklaration einer Klasse, eines Structs, einer Methode, einer Eigenschaft oder eines Felds angegeben und bestimmen, aus welchem Code heraus (derselbe Typ, abgeleitete Typen, dieselbe Assembly oder beliebiger Code) auf das Element zugegriffen werden darf. Wird kein Zugriffsmodifizierer angegeben, gilt ein typabhängiger Standardwert (z.B. private für Klassenmember, internal für Top-Level-Klassen). Zugriffsmodifizierer sind ein zentrales Werkzeug der Kapselung (Encapsulation) im objektorientierten Design, da sie steuern, welche Teile einer API nach außen sichtbar sind und welche Implementierungsdetails verborgen bleiben. In VB.NET existieren die gleichen Konzepte mit den Schlüsselwörtern Public, Private, Protected, Friend (Entsprechung zu internal) usw.

Ahead-of-Time-Kompilierung

Synonyme:
AOT

Kurz:
Ahead-of-Time-Kompilierung (AOT) bezeichnet die Übersetzung von Programmcode in nativen Maschinencode bereits vor der Ausführung – etwa zum Zeitpunkt der Veröffentlichung –, im Gegensatz zur Just-in-Time-Kompilierung zur Laufzeit. In .NET umfasst der Begriff sowohl das Native-AOT-Modell als auch verwandte Techniken wie ReadyToRun und Mono-AOT.

Länger:
In .NET Core 3.0 wurde erstmals eine AOT-Kompilierungsmöglichkeit eingeführt, die IL-Code für die Zielplattform vorkompiliert und sogenannte ReadyToRun-Images erzeugt; diese starten schneller, weil die Laufzeit den Code vor der Ausführung nicht mehr per JIT übersetzen muss, enthalten aber weiterhin zusätzlich IL-Code für Szenarien, die dynamische Nachkompilierung benötigen. Mit .NET 7 (November 2022) stellte Microsoft die erste Version einer vollständigen, „nativen“ Ahead-of-Time-Kompilierung namens Native AOT bereit, die – anders als ReadyToRun – ganz ohne Just-in-Time-Compiler und ohne separat installierte .NET-Laufzeit auskommt. AOT-Kompilierung wird auch außerhalb von .NET Core/.NET eingesetzt, etwa bei Blazor WebAssembly, wo .NET-Code direkt in WebAssembly übersetzt werden kann, um die Ausführungsgeschwindigkeit im Browser gegenüber der IL-Interpretation zu verbessern. Der Kompromiss bei AOT-Verfahren liegt meist zwischen Startzeit/Laufzeitleistung (Vorteil von AOT) und Kompatibilität mit dynamischen Sprachfeatures wie Reflection Emit oder dynamischem Assembly-Laden (Nachteil von AOT, Vorteil von JIT).

Anonyme Funktion

Synonyme:
Anonymous Function

Kurz:
Anonyme Funktion ist der Oberbegriff in der C#-Sprachreferenz für Funktionsausdrücke ohne eigenen Namen, zu denen sowohl anonyme Methoden als auch Lambda-Ausdrücke gehören.

Länger:
Laut Microsoft-Dokumentation wird ein Lambda-Ausdruck verwendet, „um eine anonyme Funktion zu erstellen“ – der Begriff „anonyme Funktion“ bezeichnet damit die übergeordnete Sprachkategorie, während „anonyme Methode“ (mit dem delegate-Schlüsselwort) und „Lambda-Ausdruck“ (mit dem Operator =>) zwei konkrete Ausprägungen dieser Kategorie sind. Beide Formen können überall dort eingesetzt werden, wo ein Delegattyp erwartet wird, etwa als Argument einer Methode oder zur Initialisierung eines benannten Delegaten. Anonyme Funktionen können lokale Variablen aus dem umschließenden Gültigkeitsbereich erfassen (Closures) und sind zentral für funktionale Programmiermuster in C#, etwa bei LINQ-Abfragen oder beim Registrieren von Ereignishandlern.

Anonyme Methode

Synonyme:
Anonymous Method

Kurz:
Eine anonyme Methode ist ein mit dem Schlüsselwort delegate eingeleiteter Codeblock ohne eigenen Namen, der als Delegatparameter übergeben werden kann.

Länger:
Anonyme Methoden wurden mit C# 2.0 eingeführt und bieten im Wesentlichen eine Möglichkeit, einen Anweisungsblock direkt an einer Delegat-Erwartungsstelle zu übergeben, ohne zuvor eine separat benannte Methode deklarieren zu müssen; die Syntax lautet delegate (Parameter) { Anweisungen }. Der Gültigkeitsbereich der Parameter einer anonymen Methode ist auf den anonymen Methodenblock beschränkt, und anonyme Methoden können – wie Lambda-Ausdrücke – Variablen aus dem umgebenden Gültigkeitsbereich (Closures) erfassen. Seit der Einführung von Lambda-Ausdrücken in C# 3.0 werden anonyme Methoden in der Praxis kaum noch verwendet, da Lambda-Ausdrücke eine kompaktere, meist äquivalente Syntax bieten; im Unterschied zu einem Lambda-Ausdruck kann eine anonyme Methode jedoch nicht zu einer Ausdrucksbaumstruktur (Expression Tree) kompiliert werden und erlaubt implizit typisierte Parameter nicht in derselben Form.

Anonymous Function

(siehe „Anonyme Funktion“)

Anonymous Method

(siehe „Anonyme Methode“)

AOT

(siehe „Ahead-of-Time-Kompilierung“)

API

Synonyme:
Application Programming Interface

Kurz:
Eine API (Application Programming Interface, deutsch Programmier- bzw. Anwendungsschnittstelle) ist ein Programmteil, der von einem Softwaresystem anderen Programmen zur Anbindung an dieses System zur Verfügung gestellt wird.

Länger:
Im Gegensatz zu einer Benutzeroberfläche, die einen Computer mit einer Person verbindet, verbindet eine Programmierschnittstelle Computer bzw. Softwarekomponenten miteinander. Eine API besteht aus einer Spezifikation, die festlegt, wie Informationen zwischen Programmen als Anforderung (Request) und zugehörige Antwort (Response) ausgetauscht werden, sowie aus einer entsprechend dieser Spezifikation implementierten Softwareschnittstelle. Im Gegensatz zu einer Binärschnittstelle (ABI) definiert eine API die Programmanbindung nur auf Quelltext-Ebene. Im .NET- und C#-Kontext wird der Begriff API sowohl für Programmierschnittstellen von Bibliotheken und Frameworks (z. B. die .NET-Basisklassenbibliothek) als auch, häufig synonym mit "Web-API", für über HTTP erreichbare Dienste verwendet, wie sie z. B. mit ASP.NET Core erstellt werden.

Application Programming Interface

(siehe „API“)

Assembly

Synonyme:
—

Kurz:
Eine Assembly ist die grundlegende Einheit der Bereitstellung, Versionssteuerung, Wiederverwendung, Aktivierungsdefinition und Sicherheitsberechtigungen für .NET-basierte Anwendungen – eine Sammlung von Typen und Ressourcen, die zusammen eine logische Funktionseinheit bilden.

Länger:
Assemblys bilden ausführbare Dateien (*.exe) oder Dynamic Link Libraries (*.dll) und sind damit die Bausteine von .NET-Anwendungen; für die Common Language Runtime (CLR) existiert ein Typ nur innerhalb des Kontexts einer Assembly. Jede Assembly verfügt über ein Assemblymanifest, das Angaben zur Identität (Name, Version), eine Dateitabelle mit allen zur Assembly gehörenden Dateien sowie eine Liste externer Abhängigkeiten (Assemblyverweise) enthält; das im Manifest enthaltene Common Intermediate Language (CIL)-Code wird nur ausgeführt, wenn eine solche Manifestzuordnung vorliegt. Assemblys definieren für die CLR unter anderem eine Sicherheitsgrenze, eine Typgrenze, eine Grenze für den Referenzbereich, eine Versionsgrenze sowie eine Einheit für Bereitstellung und parallele Ausführung mehrerer Versionen. Man unterscheidet statische Assemblys, die als PE-Dateien (Portable Executable) auf einem Datenträger gespeichert werden, und dynamische Assemblys, die zur Laufzeit direkt im Arbeitsspeicher erzeugt werden können, etwa über System.Reflection.Emit. In .NET Framework können Bibliotheken zur gemeinsamen Nutzung durch mehrere Anwendungen zusätzlich in den globalen Assemblycache (GAC) abgelegt werden, wofür ein starker Name erforderlich ist.

Async

(siehe „async/await“)

async/await

Synonyme:
Async, Await

Kurz:
async und await sind in C# kontextbezogene Schlüsselwörter (in VB.NET: Async und Await), die das Herzstück der asynchronen Programmierung bilden: async markiert eine Methode als asynchron, await unterbricht deren Ausführung nicht blockierend, bis eine erwartete Aufgabe abgeschlossen ist.

Länger:
Der async-Modifizierer kennzeichnet eine Methode, einen Lambdaausdruck oder eine anonyme Methode als asynchrone Methode und erlaubt es, im Methodentext das Schlüsselwort await zu verwenden. Eine solche Methode läuft synchron, bis sie den ersten await-Ausdruck erreicht; an dieser Stelle wird sie angehalten, bis die erwartete asynchrone Operation abgeschlossen ist, während die Kontrolle in der Zwischenzeit an den Aufrufer zurückgegeben wird – der aufrufende Thread wird dabei nicht blockiert. Der Operand von await ist üblicherweise ein Task, Task<TResult>, ValueTask oder ValueTask<TResult>, kann aber grundsätzlich jeder „awaitable“ Typ mit zugänglicher GetAwaiter-Methode sein. Enthält eine mit async markierte Methode keinen await-Ausdruck, wird sie vollständig synchron ausgeführt. In VB.NET entsprechen die C#-Schlüsselwörter async/await den Schlüsselwörtern Async und Await, die im aufgabenbasierten asynchronen Muster (TAP) seit .NET Framework 4.5 bzw. C# 5.0/VB 11 zur Verfügung stehen.

Asynchrone Programmierung

Synonyme:
Asynchronous Programming

Kurz:
Asynchrone Programmierung ist ein Programmiermodell, bei dem lang laufende Operationen (z.B. E/A- oder Netzwerkoperationen) ausgeführt werden, ohne den aufrufenden Thread zu blockieren, sodass die Anwendung währenddessen reaktionsfähig bleibt oder andere Arbeit fortsetzen kann.

Länger:
In .NET wird asynchrone Programmierung primär über das aufgabenbasierte asynchrone Programmiermodell (Task Asynchronous Programming, TAP) realisiert, dessen zentrale Bausteine die Schlüsselwörter async und await sowie die Typen Task und Task<TResult> sind. Anstatt Code als Sequenz blockierender Aufrufe zu schreiben, startet man eine Operation, erhält ein Task-Objekt als Platzhalter für die noch laufende Arbeit zurück und nutzt await, um die Fortsetzung der Methode erst dann fortzusetzen, wenn das Ergebnis vorliegt – ohne dabei den aktuellen Thread zu blockieren. Das TAP-Modell bietet damit eine Abstraktionsebene über klassischer asynchroner Programmierung mit Callbacks oder manuellem Threading und ermöglicht Code, der sequenziell lesbar ist, aber tatsächlich in komplexerer, ereignisgesteuerter Reihenfolge ausgeführt wird. Asynchrone Programmierung ist eng verwandt mit, aber nicht identisch zu paralleler Programmierung: Während asynchrone Operationen primär Wartezeiten (z.B. auf E/A) effizient überbrücken, zielt Parallel Programming auf die gleichzeitige Ausführung mehrerer Rechenoperationen auf mehreren Threads oder Kernen ab.

Asynchronous Programming

(siehe „Asynchrone Programmierung“)

Attribut

Synonyme:
Attribute

Kurz:
Ein Attribut ist eine deklarative Information, die einem Programmelement (z. B. Klasse, Methode, Property) zugeordnet wird und zur Laufzeit über Reflexion ausgewertet werden kann.

Länger:
Laut C#-Sprachspezifikation ermöglichen Attribute es, neue Arten deklarativer Informationen zu definieren, die verschiedenen Programmentitäten zugeordnet und zur Laufzeit über eine Umgebung wie Reflexion abgerufen werden können. Technisch sind Attribute Klassen, die (direkt oder indirekt) von der Basisklasse System.Attribute erben; sie werden in eckigen Klammern unmittelbar vor dem Codeelement platziert, auf das sie angewendet werden, und können sowohl Positions- als auch benannte Parameter besitzen. Attribute selbst verändern das Verhalten des annotierten Codes nicht automatisch – sie stellen lediglich Metadaten bereit, die von Werkzeugen, dem Compiler oder zur Laufzeit über Attribute.GetCustomAttribute(), Type.GetCustomAttributes() oder vergleichbare Reflection-APIs ausgelesen werden müssen, um Wirkung zu entfalten. Bekannte Beispiele aus dem .NET-Framework sind [Serializable], [Obsolete] oder [DefaultValue].

Attribute

(siehe „Attribut“)

Aufrufstapel-Protokoll

(siehe „Stack Trace“)

Aufzählungstyp

(siehe „Enumeration“)

Ausdrucksbaum

(siehe „Expression Tree“)

Ausnahme

(siehe „Exception“)

Ausnahmebehandlung

Synonyme:
Exception Handling

Kurz:
Ausnahmebehandlung ist der in .NET/C#/VB.NET verwendete Mechanismus, um Laufzeitfehler mithilfe von Ausnahmeobjekten (Exceptions) und den Schlüsselwörtern try, catch und finally strukturiert zu erkennen und zu behandeln.

Länger:
In C# wird Code, der eine Ausnahme auslösen könnte, in einen try-Block gesetzt; zugeordnete catch-Blöcke fangen die dabei auftretenden Ausnahmen ab und ermöglichen eine gezielte Reaktion, etwa Protokollierung oder Wiederherstellung eines definierten Zustands. Ein optionaler finally-Block enthält Code, der unabhängig davon ausgeführt wird, ob eine Ausnahme aufgetreten ist – typischerweise zur Freigabe von Ressourcen. Ausnahmen werden von der Common Language Runtime (CLR), von .NET-Bibliotheken, Drittanbieterbibliotheken oder dem eigenen Anwendungscode mit dem Schlüsselwort throw ausgelöst und sind Objekte, die von der Klasse System.Exception erben. Die Ausnahmebehandlung ist damit der konkrete .NET-Mechanismus, mit dem der allgemeinere Begriff der Fehlerbehandlung technisch umgesetzt wird; VB.NET verwendet dieselbe Struktur mit den Schlüsselwörtern Try, Catch und Finally.

Await

(siehe „async/await“)

B

Base Class Library

Synonyme:
BCL

Kurz:
Die Base Class Library (BCL, Basisklassenbibliothek) ist die Sammlung grundlegender .NET-Bibliotheken, die vor allem die Namespaces System.* und in begrenztem Umfang Microsoft.* umfasst und als allgemeines, plattformnahes Fundament dient, auf dem höhere Anwendungsframeworks wie ASP.NET Core aufbauen.

Länger:
Laut dem offiziellen .NET-Glossar ist die BCL ein allgemeines Framework auf niedriger Ebene; ihr Quellcode ist im .NET-Laufzeit-Repository (dotnet/runtime) enthalten, wobei die meisten BCL-APIs auch im .NET Framework verfügbar sind, sodass die moderne BCL inhaltlich als Fortführung des .NET-Framework-BCL-Quellcodes betrachtet werden kann. Für dieselbe Sammlung von APIs werden in der Dokumentation häufig auch die Begriffe „.NET-Kernbibliotheken“, „Frameworkbibliotheken“, „Runtimebibliotheken“ oder „freigegebenes Framework“ verwendet. Zu den in der BCL enthaltenen Bereichen zählen unter anderem grundlegende Datentypen und Ausnahmen im Namespace System, Ein-/Ausgabefunktionen (System.IO), generische Collections (System.Collections.Generic), Threading (System.Threading.Tasks) und Reflection (System.Reflection); ein Großteil dieser Typen ist historisch in der Assembly System.Private.CoreLib.dll (früher mscorlib.dll) sowie in weiteren System.*-Assemblys implementiert. Begrifflich ist die BCL als Kernteil zu verstehen, der in der wesentlich umfassenderen Framework Class Library (FCL) des .NET Frameworks enthalten ist – die FCL schließt zusätzlich Anwendungsframeworks wie ASP.NET, Windows Forms oder WPF ein, die auf der BCL aufsetzen, aber begrifflich über sie hinausgehen.

BCL

(siehe „Base Class Library“)

Bedingung

Synonyme:
Condition

Kurz:
Eine Bedingung ist ein Ausdruck, der zu einem booleschen Wert (true oder false) ausgewertet wird und in Auswahlanweisungen wie if oder im bedingten Operator ?: steuert, welcher Codepfad ausgeführt wird.

Länger:
Die if-Anweisung prüft den Wert eines booleschen Ausdrucks: Ergibt die Bedingung true, wird die zugehörige Anweisung bzw. der zugehörige Codeblock ausgeführt, andernfalls wird er übersprungen oder – bei Vorhandensein eines else-Zweigs – der alternative Codeblock ausgeführt. Eine Bedingung kann aus einem einzelnen booleschen Ausdruck bestehen (z.B. einem Vergleich mit ==, < oder >=) oder mehrere Teilausdrücke mittels logischer Operatoren wie && und || kombinieren; mehrere if/else if-Zweige erlauben die sequenzielle Prüfung verschiedener Bedingungen. Neben der klassischen if-Anweisung nutzt C# denselben Bedingungsbegriff auch beim ternären bedingten Operator ?: (condition ? consequent : alternative), der abhängig vom Wahrheitswert der Bedingung genau einen von zwei Ausdrücken auswertet, sowie in switch-Anweisungen und -Ausdrücken. Wichtig ist, dass die Bedingung stets ein boolescher Ausdruck sein muss – in C# gibt es im Gegensatz zu manchen anderen Sprachen keine implizite Umwandlung numerischer Werte in einen Wahrheitswert.

Boxing

Synonyme:
—

Kurz:
Boxing ist die (implizite) Konvertierung eines Werttyps in den Typ object oder in einen von diesem Werttyp implementierten Schnittstellentyp. Dabei verpackt die Laufzeitumgebung den Wert in eine Instanz auf dem verwalteten Heap.

Länger:
Wenn die Common Language Runtime (CLR) einen Werttyp boxt, wird der Wert in eine System.Object-Instanz eingebettet und auf dem verwalteten Heap gespeichert; Boxing erfolgt implizit, das heißt ohne besondere Syntax, z. B. wenn ein int-Wert einer object-Variablen zugewiesen wird. Das Konzept von Boxing und Unboxing bildet eine Brücke zwischen Werttypen und Referenztypen, indem jeder Wert eines Werttyps in object konvertiert und wieder daraus zurückgewonnen werden kann; dies ermöglicht eine einheitliche Sicht auf das Typsystem, in der letztlich jeder Wert als Objekt behandelt werden kann. Für jeden Enumerationstyp existieren beispielsweise Boxing-Konvertierungen zum Basistyp System.Enum. Boxing hat einen Laufzeit- und Speicher-Overhead, da eine zusätzliche Heap-Allokation und eine Kopie des Werts erforderlich sind; in performancekritischem Code sollte häufiges Boxing daher vermieden werden, etwa durch Verwendung generischer Typen statt object-basierter APIs.

Breakpoint

Synonyme:
Haltepunkt

Kurz:
Ein Breakpoint (Haltepunkt) ist eine Markierung an einer bestimmten Codezeile, an der Visual Studio die Ausführung eines Programms während des Debuggens anhält, damit der aktuelle Zustand von Variablen, Speicher und Aufrufstapel untersucht werden kann.

Länger:
Haltepunkte gehören zu den wichtigsten Debugverfahren: Sie werden an der Stelle festgelegt, an der die Ausführung angehalten werden soll, etwa durch Klicken auf den linken Rand neben einer Codezeile, Auswahl der Zeile und Drücken von F9, oder über „Debuggen > Haltepunkt ein/aus“. Ein gesetzter Haltepunkt wird als roter Punkt am linken Rand des Code-Editors angezeigt; beim Start des Debuggens (z.B. mit F5) läuft der Code bis zum ersten erreichten Haltepunkt und pausiert dort, bevor die betreffende Zeile ausgeführt wird. Haltepunkte lassen sich deaktivieren, ohne sie zu löschen, mit Bedingungen und Trefferzählern versehen (bedingte Haltepunkte), oder im „Haltepunkte“-Fenster (Strg+Alt+B) zentral verwalten, exportieren und importieren. Neben Haltepunkten im Quellcode unterstützt Visual Studio auch Haltepunkte auf Funktionsebene, im Disassemblierungsfenster oder als Datenhaltepunkte, die bei Wertänderungen auslösen.

Build Configuration

(siehe „Buildkonfiguration“)

Build Process

(siehe „Buildprozess“)

Build System

(siehe „Buildsystem“)

Buildkonfiguration

Synonyme:
Build Configuration

Kurz:
Eine Buildkonfiguration (Build Configuration) ist eine benannte Zusammenstellung von Projekt- bzw. Projektmappeneinstellungen, mit der ein Projekt auf unterschiedliche Weise erstellt werden kann, etwa für Entwicklung oder Auslieferung.

Länger:
Projektkonfigurationen werden benötigt, wenn Projekte mit unterschiedlichen Einstellungen erstellt werden müssen; Projektmappenkonfigurationen organisieren dabei die Projektkonfigurationen auf Ebene der gesamten Projektmappe und fungieren quasi als Container für die einzelnen Projektkonfigurationen. Visual-Studio-Vorlagen legen standardmäßig die Konfigurationen Debug und Release an. Auf .NET-CLI-Ebene wird die Buildkonfiguration bei Befehlen wie dotnet build, dotnet publish oder dotnet run über die Option -c|--configuration gesteuert, wobei die Standardkonfiguration meist Debug ist (bei dotnet publish ab .NET 8 für Projekte mit Zielframework net8.0 oder höher Release). Auf MSBuild-Ebene wird die Konfiguration über die Eigenschaft $(Configuration) abgebildet, die zusammen mit $(Platform) als Bedingung in PropertyGroup-Elementen der Projektdatei verwendet wird, etwa Condition="'$(Configuration)|$(Platform)' == 'Debug|AnyCPU'".

Buildprozess

Synonyme:
Build Process

Kurz:
Der Buildprozess (Build Process, auch Erstellungsprozess) bezeichnet in der Softwareentwicklung den automatisierten Vorgang, durch den aus Quellcode ein fertiges, ausführbares Anwendungsprogramm erzeugt wird.

Länger:
Laut deutscher Wikipedia besteht der Erstellungsprozess typischerweise aus der Code-Kompilierung und dem Linken des kompilierten Codes an Bibliotheken; in der Praxis umfasst der Begriff darüber hinaus häufig auch das Ausführen von Tests, das Erstellen von Dokumentation und das Verpacken der Software für die Bereitstellung. In .NET-Projekten wird der Buildprozess durch MSBuild gesteuert, das über die CLI-Befehle dotnet build, dotnet publish oder dotnet run aufgerufen wird und dabei Ziele (Targets) und Aufgaben (Tasks) gemäß der Projektdatei abarbeitet. In SDK-Style-Projekten lassen sich zusätzliche Schritte über eigene MSBuild-Ziele mit den Namen PreBuild (BeforeTargets="PreBuildEvent") und PostBuild (AfterTargets="PostBuildEvent") in den Buildprozess einhängen.

Buildsystem

Synonyme:
Build System

Kurz:
Ein Buildsystem (Build System) ist die Gesamtheit der Werkzeuge und Prozesse, die den automatisierten Buildprozess einer Software steuern, typischerweise durch Kompilieren, Linken und Verpacken des Codes.

Länger:
Die deutsche Wikipedia leitet den Begriff „Buildsystem“ direkt zum Artikel über den Erstellungsprozess (Buildprozess) weiter und beschränkt die Beschreibung im Kern auf Kompilierung und Linken mit Bibliotheken; in der Praxis wird zwischen den eigentlichen Build-Tools, die den Buildprozess ausführen, und Werkzeugen unterschieden, die Skripte für diese Tools generieren. Im .NET-Umfeld ist MSBuild die zentrale Buildsystem-Plattform: Sie verarbeitet XML-basierte Projektdateien (.csproj, .vbproj, .sln) und führt darin definierte Ziele und Aufgaben aus, um Quellcode zu kompilieren und Ausgabeartefakte zu erzeugen. Die .NET-CLI-Befehle wie dotnet build oder dotnet publish stellen eine komfortable Kommandozeilenschnittstelle zu diesem zugrunde liegenden MSBuild-basierten Buildsystem dar.

ByRef

Synonyme:
—

Kurz:
ByRef ist ein VB.NET-Modifizierer, der festlegt, dass ein Argument per Verweis an eine Prozedur übergeben wird, sodass die Prozedur den Wert der zugrunde liegenden Variablen im aufrufenden Code ändern kann; die Entsprechung in C# ist der ref-Modifizierer.

Länger:
Bei der Übergabe ByRef erhält die aufgerufene Prozedur in Visual Basic einen direkten Verweis auf das zugrunde liegende Programmierelement des Aufrufers, statt nur eine Kopie seines Werts. Ändert die Prozedur den Parameter, wirkt sich diese Änderung dauerhaft auf die Variable im aufrufenden Code aus, sobald die Kontrolle zurückgegeben wird – dies erlaubt es einer Prozedur, quasi einen zusätzlichen Rückgabewert über das Argument zu liefern. Der ByRef-Modifizierer kann in Declare-, Function- und Sub-Anweisungen verwendet werden. Ist ein Parameter mit ByRef deklariert, kann der aufrufende Code den Übergabemechanismus dennoch für einen einzelnen Aufruf auf ByVal erzwingen, indem der Argumentname beim Aufruf in zusätzliche Klammern eingeschlossen wird. In C# entspricht ByRef funktional dem Modifizierer ref, der ebenfalls verlangt, dass das Argument vor dem Aufruf initialisiert ist und der Methode erlaubt, ihm einen neuen Wert zuzuweisen.

ByVal

Synonyme:
—

Kurz:
ByVal ist der Standard-Übergabemodifizierer in VB.NET: Ein Argument wird als Kopie an die Prozedur übergeben, sodass die Prozedur die Variable im aufrufenden Code nicht verändern kann; dies entspricht in C# der normalen (modifikatorlosen) Wertübergabe.

Länger:
Ist ein Parameter mit ByVal deklariert, kopiert Visual Basic den Wert des zugrunde liegenden Programmierelements des Aufrufers in eine eigene Variable innerhalb der Prozedur. Die Prozedur hat dadurch keinen Zugriff auf das Originalelement im aufrufenden Code, sondern nur auf ihre eigene Kopie; Änderungen an dieser Kopie bleiben ohne Auswirkung auf die Variable des Aufrufers. Wird bei der Parameterdeklaration kein Modifizierer angegeben, ist ByVal der Standardwert. Der Vorteil dieser Übergabeart besteht darin, dass eine Variable im aufrufenden Code vor unbeabsichtigten Änderungen durch die Prozedur geschützt ist. Zu beachten ist, dass bei Objekten (Referenztypen) auch mit ByVal nur der Verweis kopiert wird, sodass die Prozedur weiterhin die Member des referenzierten Objekts ändern kann. In C# entspricht ByVal der Standardübergabe ohne Parametermodifizierer, bei der für Werttypen der Wert selbst und für Referenztypen eine Kopie des Verweises übergeben wird.

C

Synonyme:
C Sharp, CSharp

Kurz:
C# (gesprochen „C Sharp“) ist eine von Microsoft entwickelte, objektorientierte, typsichere Allzweck-Programmiersprache, die 2001 erschien und heute die populärste Sprache der .NET-Plattform ist.

Länger:
C# ist eine multiparadigmatische Sprache (u. a. strukturiert, imperativ, deklarativ, objektorientiert, ereignisorientiert, funktional, generisch, reflexiv, parallel), die statisch und stark typisiert ist, optional aber auch dynamische Typisierung erlaubt. Sie wurde zusammen mit dem .NET-Framework von Microsoft eingeführt und wird seit .NET Core bzw. dem heutigen .NET auf einer freien, plattformübergreifenden und Open-Source-Entwicklungsumgebung ausgeführt, die Programme auf Geräten von IoT bis zur Cloud unterstützt. C#-Quellcode wird zunächst in Common Intermediate Language (CIL/IL) übersetzt und anschließend von der .NET-Laufzeitumgebung (CLR) just-in-time in nativen Code kompiliert. Die Sprachspezifikation wird sowohl von Microsoft als auch als ECMA/ISO-Standard gepflegt, und die Sprache entwickelt sich fortlaufend weiter (Stand der Wikipedia-Angabe: Version 14.0, November 2025).

C Sharp

(siehe „C#“)

C#-Compiler

Synonyme:
Roslyn, csc

Kurz:
Der C#-Compiler übersetzt C#-Quellcode in Common Intermediate Language (CIL); die moderne Implementierung ist Teil der .NET Compiler Platform mit dem Codenamen „Roslyn“ und wird über die ausführbare Datei csc.exe (bzw. csc auf anderen Plattformen) aufgerufen.

Länger:
Die .NET Compiler Platform (Roslyn) ist eine von Microsoft entwickelte, seit 2014 als Open-Source-Projekt verfügbare Plattform, die Compiler für C# und Visual Basic .NET umfasst und als Nachfolger der ursprünglichen Compiler für diese Sprachen entwickelt wurde, unter anderem um mit dem gestiegenen Funktionsumfang der Sprachen besser umgehen zu können; sie stellt zusätzlich sogenannte Compiler-as-a-Service-APIs bereit, mit denen Werkzeuge wie Codeanalysen, Refactorings und IDE-Features auf Syntaxbäume und semantische Modelle des Compilers zugreifen können. Der C#-Compiler kann über die Befehlszeile direkt mit csc.exe aufgerufen werden, etwa csc File.cs zum Erzeugen einer ausführbaren Datei oder csc /target:library File.cs für eine DLL; jede Compileroption ist sowohl in der Form -option als auch /option verfügbar. Für moderne SDK-Style-.NET-Projekte wird csc.exe in der Regel nicht mehr direkt aufgerufen, sondern indirekt über MSBuild bzw. den CLI-Befehl dotnet build, wobei Compileroptionen als MSBuild-Eigenschaften in der .csproj-Datei gesetzt werden (z. B. <LangVersion>preview</LangVersion>); für reine .NET-Framework-Projekte bleibt der direkte Aufruf von csc.exe über die Befehlszeile eine gängige Alternative zur Kompilierung außerhalb von Visual Studio.

Callback

Synonyme:
Rückruffunktion

Kurz:
Ein Callback (Rückruffunktion) ist eine Methode, die als Parameter an eine andere Methode oder Funktion übergeben und von dieser zu einem definierten Zeitpunkt mit definierten Argumenten aufgerufen wird.

Länger:
Laut deutscher Wikipedia bezeichnet eine Rückruffunktion in der Informatik eine Funktion, die einer anderen Funktion – meist einer vorgefertigten Bibliotheks- oder Betriebssystemfunktion – als Parameter übergeben und von dieser unter bestimmten Bedingungen aufgerufen wird. In .NET wird dieses Muster in verwaltetem Code typischerweise über Delegates realisiert: Eine Methode akzeptiert einen Delegatparameter, dem eine konkrete Methode zugewiesen wird, die dann intern aufgerufen (zurückgerufen) wird; dies umfasst sowohl synchrone (sofortige) als auch asynchrone (verzögerte) Rückrufe. Ein besonderer Anwendungsfall ist der Aufruf von nicht verwalteten (unmanaged) DLL-Funktionen aus .NET heraus, etwa der Win32-API-Funktion EnumWindows, die einen Funktionszeiger auf eine Rückruffunktion erwartet – hierbei muss in C# ein passender Delegattyp deklariert und als Argument übergeben werden, wobei sichergestellt werden muss, dass der Garbage Collector den Delegaten nicht vorzeitig freigibt. Auch Ereignishandler, die über Delegates aufgerufen werden, lassen sich konzeptionell als Callbacks verstehen.

Cancellation Token

Synonyme:
Abbruchtoken

Kurz:
Ein Cancellation Token (Abbruchtoken, System.Threading.CancellationToken) ist ein leichtgewichtiger Werttyp, mit dem in .NET auf einheitliche Weise die kooperative Beendigung asynchroner oder lang laufender synchroner Vorgänge signalisiert und überwacht wird.

Länger:
Seit .NET Framework 4 verwendet .NET ein einheitliches Modell für den kooperativen Abbruch: Ein CancellationTokenSource-Objekt erzeugt und verwaltet ein oder mehrere zugehörige CancellationToken-Instanzen und kann über die Methode Cancel eine Abbruchanforderung an alle Kopien des Tokens ausgeben. Das Token selbst kann keinen Abbruch auslösen, sondern wird an Tasks, Threads oder Threadpool-Arbeitselemente weitergegeben, die den Wert der Eigenschaft IsCancellationRequested per Abfrage, Rückruf oder Wait-Handle überwachen und selbst entscheiden, wie sie geordnet auf die Anforderung reagieren – Abbruch ist somit kooperativ und wird dem Listener nicht erzwungen aufgenötigt. Reagiert ein Vorgang auf einen Abbruch, wird üblicherweise eine OperationCanceledException ausgelöst, deren Konstruktor das Token als Parameter entgegennimmt, oder die Methode ThrowIfCancellationRequested verwendet; die Task- und Task<TResult>-Klassen sind vollständig mit CancellationTokenSource und CancellationToken integriert, und viele TPL-Methoden wie Task.Run oder Parallel.For akzeptieren ein CancellationToken als Parameter. Da CancellationTokenSource die Schnittstelle IDisposable implementiert, sollte sie nach Gebrauch mit Dispose freigegeben werden.

Cast

Synonyme:
Typumwandlung

Kurz:
Ein Cast ist die explizite Syntax zur Typkonvertierung in C#, geschrieben als Zieltyp in Klammern vor dem zu konvertierenden Ausdruck, z. B. (int)wert. Ein Cast ist notwendig, wenn eine Konvertierung nicht automatisch (implizit) erfolgen kann.

Länger:
Wenn eine Konvertierung nicht ohne das Risiko von Datenverlust vorgenommen werden kann, verlangt der Compiler eine explizite Konvertierung, die als Cast bzw. Umwandlung bezeichnet wird; ein Cast ist somit eine Möglichkeit, die Konvertierung explizit und bewusst vorzunehmen und signalisiert, dass möglicherweise Daten verloren gehen oder die Umwandlung zur Laufzeit fehlschlagen kann (z. B. mit einer InvalidCastException). Typische Beispiele für notwendige Casts sind die numerische Konvertierung in einen Typ mit geringerer Genauigkeit (etwa double nach int, wobei Nachkommastellen abgeschnitten werden) oder die Konvertierung einer Basisklasseninstanz in eine davon abgeleitete Klasse. Neben dem klassischen Cast-Ausdruck (Zieltyp)Ausdruck unterstützt C# auch benutzerdefinierte explizite Konvertierungsoperatoren, die mit den Schlüsselwörtern operator und explicit definiert werden. Ein Cast ruft, sofern vorhanden, explizit den entsprechenden Konvertierungsoperator auf; ist kein solcher Operator definiert, tritt bei der Umwandlung ein Compilerfehler bzw. zur Laufzeit ein Fehler auf.

CD (Continuous Delivery)

(siehe „Continuous Delivery“)

CD (Continuous Deployment)

(siehe „Continuous Deployment“)

CI

(siehe „Continuous Integration“)

CIL

(siehe „Common Intermediate Language“)

Class

(siehe „Klasse“)

Class Library

Synonyme:
Klassenbibliothek

Kurz:
Eine Class Library (Klassenbibliothek) ist das Konzept der gemeinsam nutzbaren Programmbibliothek in .NET: Sie fasst nützliche Typen und Methoden in einem Modul zusammen, das von einer oder mehreren Anwendungen aufgerufen werden kann.

Länger:
Klassenbibliotheken werden mithilfe des .NET-Assembly-Dateiformats beschrieben und können als eigenständiges Projekt erstellt und anschließend als Drittanbieterkomponente oder gebündelt mit einer oder mehreren Anwendungen verteilt werden, etwa über ein NuGet-Paket. Microsoft Learn unterscheidet drei Klassenbibliothekstypen: plattformspezifische Klassenbibliotheken mit Zugriff auf alle APIs einer bestimmten Plattform (zum Beispiel .NET Framework unter Windows), portable Klassenbibliotheken mit Zugriff auf eine Schnittmenge von APIs mehrerer Plattformen sowie .NET-Standard-Klassenbibliotheken, die plattformspezifische und portable Konzepte in einem einheitlichen Modell vereinen und dabei auf Zielplattformen zurückgreifen können, die den jeweiligen .NET-Standard-Vertrag erfüllen. In der Praxis wird eine .NET-Klassenbibliothek meist über die .NET-CLI (dotnet new classlib) oder in Visual Studio mit der Projektvorlage „Klassenbibliothek“ angelegt; das Zielframework der Bibliothek bestimmt, von welchen Anwendungen sie referenziert werden kann.

Class Module

(siehe „Klassenmodul“)

Clean Architecture

Synonyme:
—

Kurz:
Clean Architecture ist ein Architekturmuster, das Geschäftslogik in den Mittelpunkt einer Anwendung stellt und Abhängigkeiten so ausrichtet, dass Infrastruktur- und Implementierungsdetails von der Anwendungskernlogik abhängen – nicht umgekehrt. In der .NET-Dokumentation wird sie als eine von mehreren verwandten Bezeichnungen (u. a. Hexagonal Architecture, Ports-and-Adapters, Onion Architecture) für dasselbe Grundprinzip beschrieben.

Länger:
Bei Clean Architecture wird eine Anwendung typischerweise in konzentrischen Kreisen dargestellt, ähnlich einer Zwiebel: Im Zentrum liegt der „Application Core“ mit Domänenmodell und Geschäftsregeln, der Abstraktionen (Schnittstellen) definiert; äußere Schichten wie Infrastruktur (Datenzugriff, externe Dienste) und Präsentation implementieren diese Schnittstellen, hängen also vom Kern ab, statt dass der Kern von ihnen abhängt. Dieses Prinzip beruht auf dem Dependency Inversion Principle aus den SOLID-Prinzipien sowie auf Prinzipien des Domain-Driven Design. Ursprünglich von Robert C. Martin unter dem Namen „Clean Architecture“ mit den Schichten Entities, Use Cases, Interface Adapters und Frameworks & Drivers beschrieben, verwendet die offizielle .NET-Architekturdokumentation eine leicht abweichende, aber im Kern vergleichbare Schichtung für ASP.NET-Core-Anwendungen. Microsoft stellt dazu auch eine Referenzvorlage (u. a. über das GitHub-Repository „ardalis/cleanarchitecture“) bereit.

CLR

(siehe „Common Language Runtime“)

CLS

(siehe „Common Language Specification“)

Common Intermediate Language

Synonyme:
CIL, IL, Intermediate Language, MSIL, Microsoft Intermediate Language

Kurz:
Common Intermediate Language (CIL) ist die CPU-unabhängige, objektorientierte Bytecode-Sprache, in die .NET-Compiler (z. B. für C# oder VB.NET) Quellcode übersetzen und die von der Common Language Runtime zur Laufzeit in nativen Maschinencode kompiliert wird. Sie war ursprünglich unter dem Produktnamen „Microsoft Intermediate Language“ (MSIL) bekannt, bevor sie mit der Standardisierung durch ECMA-335 offiziell in „CIL“ umbenannt wurde.

Länger:
Beim Kompilieren von .NET-Quellcode erzeugt der jeweilige Sprachcompiler zunächst CIL-Code sowie zugehörige Metadaten, die Typinformationen, Signaturen und Referenzen beschreiben; beides wird gemeinsam in einer Portable-Executable(PE)-Datei gespeichert. CIL ist eine stapelbasierte (stack-based) Assemblersprache mit Befehlen zum Laden, Speichern und Aufrufen von Methoden sowie für arithmetische, logische und Kontrollfluss-Operationen. Bevor der Code ausgeführt werden kann, muss die CIL – üblicherweise durch einen Just-in-Time(JIT)-Compiler, alternativ durch Ahead-of-Time-Kompilierung – in CPU-spezifischen Code übersetzt werden. Laut Microsoft ist der funktionale Unterschied zwischen den Begriffen „CIL“ und „MSIL“ gering: CIL ist der im internationalen ECMA/ISO-Standard verwendete Begriff, während MSIL der ursprüngliche Produktname für Microsofts Implementierung war; beide bzw. auch die Kurzform „IL“ werden in der Praxis oft synonym verwendet.

Common Language Runtime

Synonyme:
CLR

Kurz:
Die Common Language Runtime (CLR) ist die Laufzeitumgebung des .NET Framework, die verwalteten Code ausführt und grundlegende Dienste wie Speicherverwaltung, Typsicherheit und sprachübergreifende Interoperabilität bereitstellt. Sie ist Microsofts konkrete Implementierung der in ECMA-335 spezifizierten Common Language Infrastructure (CLI).

Länger:
Compiler und Tools, die für die CLR entwickeln, erzeugen Common Intermediate Language (CIL)-Code samt Metadaten; die CLR übernimmt diesen Code zur Laufzeit, kompiliert ihn üblicherweise per Just-in-Time-Compiler in nativen Maschinencode und führt ihn aus. Code, der auf diese Weise unter Kontrolle der Laufzeit ausgeführt wird, heißt „verwalteter Code“ (Managed Code); Code außerhalb dieser Kontrolle – etwa klassischer C/C++-Code oder COM-Komponenten – wird als „nicht verwalteter Code“ (Unmanaged Code) bezeichnet. Die CLR bietet zusätzlich Dienste wie automatische Garbage Collection, sprachübergreifende Ausnahmebehandlung, Versionierungs- und Bereitstellungsunterstützung sowie Debugging- und Profiling-Funktionen. Historisch bezieht sich der Begriff „CLR“ meist auf die Laufzeit des klassischen .NET Framework, während das moderne, plattformübergreifende .NET (ehemals .NET Core) eine eigene, quelloffene Implementierung namens CoreCLR verwendet, die auf denselben CLI-Grundprinzipien basiert.

Common Language Specification

Synonyme:
CLS

Kurz:
Die Common Language Specification (CLS) ist ein Teil der Common Language Infrastructure (ECMA-335) und definiert eine Teilmenge von Sprachfunktionen, die alle .NET-Sprachen unterstützen müssen, um sprachübergreifende Interoperabilität zu gewährleisten. Komponenten, die diese Regeln in ihrer öffentlichen Schnittstelle einhalten, gelten als „CLS-kompatibel“.

Länger:
Damit Objekte, die in unterschiedlichen .NET-Sprachen (z. B. C#, VB.NET, F#) geschrieben wurden, uneingeschränkt zusammenarbeiten können, dürfen sie nach außen nur Funktionen verwenden, die in allen beteiligten Sprachen vorhanden sind; genau diese gemeinsame Menge an Funktionen legt die CLS fest. Sie ist als Teilmenge des Common Type Systems (CTS) definiert und in Partition I, Klauseln 7 bis 11 des ECMA-335-Standards spezifiziert. Ob eine Komponente CLS-konform ist, lässt sich zur Kompilierzeit über das Attribut CLSCompliantAttribute prüfen und markieren; die Regeln gelten dabei ausschließlich für öffentlich (public/protected) zugängliche Schnittstellen, nicht für interne Implementierungsdetails. Nicht CLS-konform sind beispielsweise vorzeichenlose Ganzzahltypen (uint, ulong) oder Bezeichner, die sich nur durch Groß-/Kleinschreibung unterscheiden – Beschränkungen, die insbesondere beim Entwurf öffentlich nutzbarer Bibliotheken relevant sind.

Common Type System

Synonyme:
CTS

Kurz:
Das Common Type System (CTS) legt fest, wie Typen in der Common Language Runtime deklariert, verwendet und verwaltet werden, und bildet damit die Grundlage für die sprachübergreifende Integration in .NET. Es ist Teil des ECMA-335-Standards (Common Language Infrastructure).

Länger:
Das CTS schafft ein objektorientiertes Modell, das die vollständige Implementierung vieler Programmiersprachen unterstützt, und definiert Regeln, denen Sprachen folgen müssen, damit in unterschiedlichen Sprachen geschriebene Objekte miteinander interagieren können – etwa hinsichtlich Typsicherheit, Sichtbarkeitsregeln, Vererbung, virtuellen Methoden und Objektlebensdauer. Es unterscheidet grundsätzlich zwischen Werttypen (Value Types), die ihre Daten direkt enthalten und typischerweise auf dem Stack oder inline in Strukturen abgelegt werden, und Verweistypen (Reference Types); alle Typen leiten letztlich von System.Object ab. In C# beispielsweise sorgt der Compiler dafür, dass Typinformationen als Metadaten in die Assembly eingebettet werden, welche die CLR zur Laufzeit für zusätzliche Sicherheitsprüfungen nutzt – ein direktes Ergebnis der durch das CTS vorgegebenen einheitlichen Typhierarchie.

Compilation

(siehe „Kompilierung“)

Compiler

Synonyme:
Übersetzer

Kurz:
Ein Compiler (auch Kompilierer oder Übersetzer) ist ein Computerprogramm, das Quellcode einer Programmiersprache in eine Form übersetzt, die von einem Computer ausgeführt werden kann.

Länger:
Laut deutscher Wikipedia stammt das Wort von englisch „compile“ („zusammentragen“, „zusammenstellen“) beziehungsweise lateinisch „compilare“ („aufhäufen“); ein Übersetzer im allgemeinen Sinn akzeptiert ein Programm in einer formalen Quellsprache und erzeugt ein semantisch äquivalentes Programm in einer formalen Zielsprache, wobei Compiler spezielle Übersetzer sind, die Programmcode höherer Programmiersprachen in ausführbare Maschinensprache einer bestimmten Rechnerarchitektur oder in Zwischencode überführen. Die Begriffe „Übersetzer“ und „Compiler“ werden in der Literatur nicht immer streng unterschieden; im Unterschied zum Compiler erzeugt ein Interpreter keinen Maschinencode, sondern führt Anweisungen direkt aus. Im .NET-Umfeld existieren getrennte Compiler für C# (csc, Teil der .NET Compiler Platform „Roslyn“) und Visual Basic (vbc), die Quellcode jeweils in Common Intermediate Language (CIL) übersetzen; als eigenständige Kategorie gilt zudem der Assembler, der Assemblercode in Maschinencode übersetzt und begrifflich meist nicht als Compiler bezeichnet wird.

Condition

(siehe „Bedingung“)

Console

(siehe „Konsole“)

Console App

(siehe „Konsolenanwendung“)

Console Application

(siehe „Konsolenanwendung“)

`const`

(siehe „Konstante“)

Constant

(siehe „Konstante“)

Constructor

(siehe „Konstruktor“)

Continuous Delivery

Synonyme:
CD (Continuous Delivery)

Kurz:
Continuous Delivery (CD, kontinuierliche Auslieferung) ist der Prozess der Automatisierung von Build, Test, Konfiguration und Bereitstellung von einer Build- zu einer Produktionsumgebung, wobei die tatsächliche Freigabe für die Produktion ein bewusster, meist manueller Schritt bleibt.

Länger:
Continuous Delivery baut auf Continuous Integration auf: Die kontinuierliche Integration startet den CD-Prozess, und eine Release-Pipeline überführt jede erfolgreich getestete Version in die nächste Umgebung (z. B. Test-, Staging- und schließlich Produktionsumgebung), wodurch Fehler früh und häufig erkannt werden. Ziel von Continuous Delivery ist, dass Software während ihres gesamten Lebenszyklus in einem auslieferungsfähigen Zustand ist, sodass ein Release jederzeit schnell, risikoarm und reproduzierbar erfolgen kann. Wichtig ist die Abgrenzung zu Continuous Deployment: Beide Konzepte teilen zufällig die Abkürzung "CD", meinen aber unterschiedliche Dinge. Bei Continuous Delivery wird jede Änderung, die alle automatisierten Prüfungen durchlaufen hat, lediglich auslieferungsbereit gemacht bzw. in eine Staging-Umgebung übernommen – die endgültige Bereitstellung in der Produktionsumgebung erfolgt jedoch durch eine explizite, meist manuelle Freigabe (z. B. auf Knopfdruck), nicht automatisch bei jeder Änderung. Dies unterscheidet Continuous Delivery von Continuous Deployment, bei dem dieser letzte Schritt ebenfalls vollautomatisch erfolgt.

Continuous Deployment

Synonyme:
CD (Continuous Deployment)

Kurz:
Continuous Deployment (ebenfalls oft mit CD abgekürzt) bezeichnet die vollautomatische Auslieferung jeder erfolgreich getesteten Codeänderung direkt in die Produktionsumgebung, ohne dass eine manuelle Freigabe erforderlich ist.

Länger:
Continuous Deployment führt den Automatisierungsgedanken von Continuous Integration und Continuous Delivery konsequent zu Ende: Jede Codeänderung, die alle Phasen der Build- und Test-Pipeline erfolgreich durchläuft, wird automatisch und ohne menschlichen Eingriff in der Produktionsumgebung bereitgestellt; lediglich ein fehlgeschlagener Test verhindert eine Veröffentlichung. Dies unterscheidet Continuous Deployment von Continuous Delivery, obwohl beide Konzepte umgangssprachlich dieselbe Abkürzung "CD" teilen: Bei Continuous Delivery bleibt der letzte Schritt – die tatsächliche Bereitstellung in Produktion – eine bewusste, in der Regel manuell ausgelöste Entscheidung, während bei Continuous Deployment jede erfolgreiche Pipeline-Ausführung automatisch zu einem Produktions-Release führt, wodurch Release-Zyklen deutlich häufiger (z. B. mehrmals pro Stunde statt wöchentlich oder monatlich) erfolgen können. Continuous Delivery und Continuous Deployment sind damit fachlich unterschiedliche, wenn auch verwandte Konzepte – trotz der zufällig identischen Abkürzung CD sollten sie klar unterschieden werden.

Continuous Integration

Synonyme:
CI

Kurz:
Continuous Integration (CI, kontinuierliche Integration) ist eine Entwicklungspraxis, bei der Codeänderungen häufig – typischerweise mehrmals täglich – in ein gemeinsames Repository zusammengeführt werden und dabei automatisch gebaut und getestet werden.

Länger:
Bei CI löst ein Commit im Haupt- bzw. Trunk-Branch eines gemeinsamen Repositorys automatisch ein Build-System aus, das den gesamten Branch erstellt, testet und validiert. Dadurch werden Integrationsprobleme sofort erkannt, statt erst Wochen später bei einer manuellen Zusammenführung großer Änderungen zutage zu treten. CI ermutigt Entwicklerteams, ihren Code und ihre Unit-Tests regelmäßig zu teilen, indem sie ihre Änderungen bei jedem abgeschlossenen Arbeitsschritt in das gemeinsame Versionskontroll-Repository einpflegen. In Azure DevOps wird Continuous Integration typischerweise mit Azure Pipelines umgesetzt, die nach einem Zeitplan, bei Codeänderungen oder beidem automatisierte Builds und Tests ausführen; die dabei erzeugten Artefakte können anschließend von CD-Pipelines für automatische Bereitstellungen verwendet werden. CI bildet damit die Grundlage, auf der Continuous Delivery und Continuous Deployment aufbauen.

CoreCLR

Synonyme:
—

Kurz:
CoreCLR ist die Laufzeitumgebung (Ausführungsmodul) von .NET Core bzw. modernem .NET und enthält u. a. den Garbage Collector, den JIT-Compiler (RyuJIT), primitive Datentypen und grundlegende Low-Level-Klassen. Microsoft hat CoreCLR im Februar 2015 als Open-Source-Projekt veröffentlicht.

Länger:
CoreCLR ist das Gegenstück zur klassischen Common Language Runtime (CLR) des .NET Framework, jedoch modular aufgebaut und plattformübergreifend nutzbar (Windows, Linux, macOS). Es übernimmt Aufgaben wie das Laden von IL-Bytecode, die Just-in-Time-Kompilierung in Maschinencode, Garbage Collection, Ausnahmebehandlung, Thread-Verwaltung und Interoperabilität mit nativem Code. Der Quellcode war ursprünglich im eigenständigen Repository dotnet/coreclr auf GitHub verfügbar, wurde inzwischen aber in das zentrale dotnet/runtime-Repository zusammengeführt; das ursprüngliche dotnet/coreclr-Repository wurde archiviert. CoreCLR implementiert die von ECMA-335 spezifizierte Common Language Infrastructure (CLI) und bildet damit die technische Grundlage der heutigen .NET-Plattform.

Cross-Platform Development

(siehe „Plattformübergreifende Entwicklung“)

csc

(siehe „C#-Compiler“)

CSharp

(siehe „C#“)

.csproj

(siehe „Projektdatei“)

CTS

(siehe „Common Type System“)

D

Data Conversion

(siehe „Datenkonvertierung“)

Data Type

(siehe „Datentyp“)

Datenbankmigration

(siehe „Migration (EF Core)“)

Datenkonvertierung

Synonyme:
Data Conversion

Kurz:
Datenkonvertierung bezeichnet in .NET das Umwandeln eines Werts von einem Basisdatentyp in einen anderen, häufig unter Verwendung der statischen Klasse System.Convert. Sie ergänzt die sprachbasierten Mechanismen von Casts und impliziten/expliziten Konvertierungen um Hilfsmethoden für nicht direkt kompatible Typen.

Länger:
Die statische Convert-Klasse aus dem System-Namespace enthält Methoden, die primär zur Unterstützung der Konvertierung in und aus den Basisdatentypen von .NET verwendet werden; unterstützte Basistypen sind unter anderem Boolean, Char, SByte, Byte, Int16, Int32, Int64, UInt16, UInt32, UInt64, Single, Double, Decimal, DateTime und String. Für jeden Basistyp existiert eine Konvertierungsmethode, um ihn in jeden anderen Basistyp umzuwandeln, z. B. Convert.ToInt32(string) oder Convert.ToDouble(object). Im Unterschied zu einem einfachen Cast kann Convert auch zwischen Typen konvertieren, für die kein direkter Cast-Operator existiert (etwa von einer Zeichenfolge in eine Zahl), und wandelt bei fehlschlagender Konvertierung eine passende Ausnahme aus (z. B. FormatException oder OverflowException) statt stillschweigend Daten zu verlieren. Für speziellere Fälle, etwa die Umwandlung zwischen Bytearrays und numerischen Typen, steht ergänzend die Klasse System.BitConverter zur Verfügung. In VB.NET existieren mit Funktionen wie CInt, CDbl oder CStr funktional ähnliche, sprachintegrierte Konvertierungsfunktionen.

Datensatztyp

(siehe „Record“)

Datentyp

Synonyme:
Data Type

Kurz:
Ein Datentyp legt fest, welche Werte eine Variable, ein Feld oder ein Ausdruck annehmen kann und welche Operationen darauf zulässig sind. In .NET/C# bestimmt der Datentyp außerdem, ob es sich um einen Wert- oder Verweistyp handelt.

Länger:
Formal bezeichnet ein Datentyp die Zusammenfassung von Objektmengen (Wertebereich) mit den darauf definierten Operationen; im Kontext von Programmiersprachen ist damit meist die konkrete Zusammenfassung von Werten und Operationen zu einer Einheit gemeint, wie sie durch eine Sprache wie C# bereitgestellt oder benutzerdefiniert wird. C# stellt zahlreiche integrierte Datentypen bereit, etwa int, double, bool, char und string, die jeweils Aliase für .NET-Typen wie System.Int32 oder System.String sind. Jeder Datentyp in C# ist entweder ein Werttyp (z. B. struct, enum) oder ein Verweistyp (z. B. class, interface, array, delegate); diese Unterscheidung bestimmt, wie Variablen Daten speichern und wie Zuweisungen sich auswirken. Neben den integrierten Datentypen können Entwickler eigene Datentypen mittels class, struct, record, enum oder interface definieren.

DbContext

Synonyme:
—

Kurz:
DbContext ist die zentrale Klasse in Entity Framework Core, die eine Sitzung mit der Datenbank repräsentiert und zum Abfragen sowie Speichern von Entitätsinstanzen verwendet wird. Sie kombiniert konzeptionell die Unit-of-Work- und Repository-Entwurfsmuster.

Länger:
Eine DbContext-Instanz ist für die Verwendung innerhalb einer einzelnen Arbeitseinheit (Unit of Work) konzipiert, weshalb ihre Lebensdauer in der Regel sehr kurz ist: Sie beginnt mit der Erstellung der Instanz und endet, wenn diese verworfen (disposed) wird. Ein typischer Ablauf besteht aus dem Erstellen einer DbContext-Instanz, dem Nachverfolgen von Entitätsinstanzen (die durch Abfragen zurückgegeben oder explizit hinzugefügt/angehängt werden), dem Vornehmen von Änderungen an diesen Entitäten sowie dem abschließenden Aufruf von SaveChanges bzw. SaveChangesAsync, wodurch EF Core die erkannten Änderungen in die Datenbank schreibt. In eigenen Anwendungen wird üblicherweise eine von DbContext abgeleitete Klasse definiert, die DbSet<TEntity>-Eigenschaften für die Stammentitäten des Modells enthält und meist über Dependency Injection bereitgestellt wird. Für wiederholte Erstellung und Verwerfung von Kontextinstanzen bietet EF Core zudem Context Pooling (AddDbContextPool) als Performance-Optimierung an.

Debug Configuration

(siehe „Debug-Konfiguration“)

Debug-Konfiguration

Synonyme:
Debug Configuration

Kurz:
Die Debug-Konfiguration ist eine Buildkonfiguration, die ein Programm mit vollständigen symbolischen Debuginformationen und ohne Codeoptimierung kompiliert, um das Debuggen zu unterstützen.

Länger:
In der Debug-Konfiguration erzeugt der Compiler zusätzliche Symboldateien (z. B. .pdb-Dateien), damit Debugger Quellcode und generierte Anweisungen einander zuordnen können; die Optimierung ist deaktiviert, weil sie das Debuggen erschweren würde, da die Beziehung zwischen Quellcode und generierten Anweisungen bei optimiertem Code komplexer ist. In SDK-Style-.NET-Projekten ist Debug üblicherweise die Standard-Buildkonfiguration für dotnet build und dotnet run; sie lässt sich in Visual Studio über die Symbolleiste, den Konfigurations-Manager oder die Projekteigenschaften auswählen, beziehungsweise über die MSBuild-Eigenschaft $(Configuration) und die C#-Compileroption DebugType/-debug steuern. Häufig ist mit der Debug-Konfiguration in der Projektdatei zusätzlich das Präprozessorsymbol DEBUG (neben TRACE) definiert, wodurch mit #if DEBUG bedingt kompilierter Code aktiviert werden kann.

Debugging

Synonyme:
Fehlersuche, Fehlerdiagnose

Kurz:
Debugging bezeichnet das systematische Aufspüren und Beheben von Fehlern in einem Programm, üblicherweise durch Ausführen der Anwendung mit einem angehängten Debugger, etwa dem Visual Studio-Debugger.

Länger:
Im Kontext von Visual Studio bedeutet „die App debuggen“ in der Regel, die Anwendung im Debugmodus mit angehängtem Debugger zu starten, etwa über die Taste F5 bzw. den Menüpunkt „Debuggen > Debuggen starten“. Während einer Debugsitzung kann der Entwickler die Ausführung an bestimmten Stellen anhalten (siehe Breakpoint), den aktuellen Zustand von Variablen und Speicher untersuchen, den Aufrufstapel betrachten und den Code schrittweise durchlaufen (z.B. mit „Step Into“, F11). Debugging-Werkzeuge in Visual Studio umfassen zudem Fenster wie „Haltepunkte“, „Aufrufliste“ und „Lokale Variablen“ sowie die Möglichkeit, den Debugger nachträglich an einen bereits laufenden Prozess anzuhängen. Ziel des Debuggings ist es, die Ursache eines fehlerhaften Verhaltens präzise zu lokalisieren, bevor eine Korrektur im Quellcode vorgenommen wird.

Delegat

(siehe „Delegate“)

Delegate

Synonyme:
Delegat

Kurz:
Ein Delegate ist ein Typ, der Verweise auf Methoden mit einer bestimmten Parameterliste und einem bestimmten Rückgabetyp kapselt – vergleichbar mit einem typsicheren Funktionszeiger.

Länger:
Im Gegensatz zu Funktionszeigern in C oder C++ sind Delegates in .NET objektorientiert, typsicher und geschützt; alle Delegattypen leiten sich von der Klasse System.Delegate ab. Ein Delegate-Objekt wird instanziiert, indem man ihm eine Methode mit kompatibler Signatur zuweist – entweder als benannte Methode, als anonyme Methode oder als Lambda-Ausdruck; über die Delegate-Instanz kann die zugewiesene Methode dann aufgerufen (invoked) werden. Delegates sind Multicast-fähig, d. h. eine Instanz kann Verweise auf mehrere Methoden gleichzeitig halten, die bei einem Aufruf alle in der Reihenfolge ihrer Registrierung ausgeführt werden; sie bilden zudem die technische Grundlage für Ereignisse (Events) in .NET, da ein Event stets einen Delegattyp als Basis benötigt. Häufig genutzte generische, vordefinierte Delegate-Typen sind Action und Func<TResult>. In VB.NET wird der Delegattyp mit dem Schlüsselwort Delegate deklariert (z. B. Delegate Sub oder Delegate Function).

Dependency

Synonyme:
Abhängigkeit

Kurz:
Eine Dependency (Abhängigkeit) ist im Kontext von Dependency Injection ein Objekt, von dem ein anderes Objekt zur Erfüllung seiner Aufgabe benötigt wird. Statt die Abhängigkeit selbst zu erzeugen, erhält die abhängige Klasse sie von außen bereitgestellt.

Länger:
In der .NET-Dokumentation zu Dependency Injection wird eine Abhängigkeit ausdrücklich als „ein Objekt, von dem ein anderes Objekt abhängt“ definiert. Klassisch würde eine Klasse ihre Abhängigkeiten direkt mit dem new-Operator instanziieren, was jedoch zu enger Kopplung führt: Der Code wird an eine konkrete Implementierung gebunden und dadurch schwerer testbar und wartbar. Dependency Injection löst dieses Problem, indem Abhängigkeiten über eine Schnittstelle oder Basisklasse abstrahiert, in einem Dienstcontainer (Service Container) registriert und anschließend – meist über den Konstruktor – in die Klasse „injiziert“ werden, die sie benötigt. In .NET wird der Begriff Service häufig synonym für eine solche registrierte Abhängigkeit verwendet, etwa in Beispielen wie dem IMessageWriter-Dienst.

Dependency Injection

Synonyme:
DI

Kurz:
Dependency Injection (DI) ist ein Softwareentwurfsmuster, mit dem Klassen ihre Abhängigkeiten von außen erhalten, statt sie selbst zu erzeugen. In .NET ist DI ein fest integrierter Bestandteil des Frameworks, mit einem eingebauten Dienstcontainer (IServiceProvider).

Länger:
Dependency Injection ist eine spezielle Ausprägung des Inversion-of-Control-Prinzips (IoC), bei der die Verantwortung für das Erzeugen und Verwalten von Abhängigkeiten von der abhängigen Klasse auf eine externe Komponente verschoben wird. Der typische Ablauf besteht aus drei Schritten: Zunächst wird die Abhängigkeit über eine Schnittstelle oder abstrakte Basisklasse abstrahiert; anschließend wird die konkrete Implementierung in einem Dienstcontainer registriert (in .NET über IServiceCollection, aus der mittels BuildServiceProvider ein IServiceProvider erzeugt wird); schließlich erhält die Klasse ihre Abhängigkeit meist über Konstruktorparameter injiziert („Constructor Injection“). Das Framework übernimmt dabei die Erzeugung und – abhängig von der konfigurierten Lebensdauer (Transient, Scoped, Singleton) – auch die Freigabe der Instanzen. DI verringert die Kopplung zwischen Klassen, erhöht die Testbarkeit (z. B. durch Ersetzen echter Implementierungen durch Test-Doubles) und wird in ASP.NET Core standardmäßig für Dienste wie Logging, Konfiguration oder eigene Anwendungsdienste eingesetzt.

Deployment

Synonyme:
Bereitstellung

Kurz:
Deployment (Bereitstellung) bezeichnet in .NET den Vorgang, eine zuvor veröffentlichte (published) Anwendung auf einem Zielsystem – Server, Gerät, Container oder Cloudumgebung – verfügbar zu machen und dort auszuführen.

Länger:
Dem Deployment geht das sogenannte Publishing voraus: das Kompilieren des Quellcodes, das Erstellen einer ausführbaren oder binären Datei sowie das Zusammenstellen aller Abhängigkeiten und zugehörigen Dateien zur Verteilung. Der Veröffentlichungsprozess bereitet die App für die Verwendung außerhalb der Entwicklungsumgebung vor; die eigentliche Bereitstellung erfolgt anschließend etwa auf einem Server, einer Verteilungsplattform, in einem Container oder in einer Cloudumgebung. .NET-Anwendungen können über die .NET-CLI (dotnet publish) oder Visual Studio veröffentlicht werden. Bei der Wahl der konkreten Bereitstellungsart sind vor allem zwei Hauptmodi relevant: die framework-abhängige Bereitstellung (Framework-Dependent Deployment) und die eigenständige Bereitstellung (Self-Contained Deployment); ergänzend existieren Varianten wie die Einzeldatei-Bereitstellung (Single-file Deployment) und das Trimming zur Reduktion der Bereitstellungsgröße.

Deserialisierung

Synonyme:
Deserialization

Kurz:
Deserialisierung ist der umgekehrte Vorgang zur Serialisierung: Aus einer serialisierten Form (z. B. JSON- oder XML-Datenstrom) wird wieder ein Objekt im Arbeitsspeicher rekonstruiert.

Länger:
Deserialisierung liest die im Datenstrom enthaltenen Werte aus und weist sie den entsprechenden Feldern bzw. Eigenschaften einer neuen Objektinstanz zu, sodass der ursprüngliche Zustand des Objekts wiederherstellt wird. In .NET übernimmt beispielsweise JsonSerializer.Deserialize aus dem Namespace System.Text.Json diese Aufgabe für JSON, während XmlSerializer.Deserialize aus System.Xml.Serialization XML-Datenströme in Objekte umwandelt. Deserialisierung ist ein zentraler Baustein bei der Kommunikation zwischen Systemen, etwa beim Empfang von JSON-Antworten einer Web-API oder beim Laden konfigurationsbasierter Objektgraphen aus Dateien.

Deserialization

(siehe „Deserialisierung“)

Destructor

(siehe „Destruktor“)

Destruktor

Synonyme:
Destructor, Finalizer

Kurz:
Ein Destruktor (offiziell heute als Finalizer bezeichnet) ist eine spezielle Methode einer Klasse, die vom Garbage Collector automatisch aufgerufen wird, um abschließende Aufräumarbeiten vorzunehmen, bevor der Speicher der Instanz freigegeben wird.

Länger:
In C# wird der Destruktor mit einer Tilde vor dem Klassennamen deklariert (z. B. ~MeineKlasse()), enthält keine Modifizierer oder Parameter und kann nicht überladen, vererbt oder explizit aufgerufen werden – die Entscheidung, wann er ausgeführt wird, trifft ausschließlich der Garbage Collector. Historisch wurde dieses Konstrukt „Destruktor“ genannt, seit einigen Versionen der Dokumentation spricht Microsoft bevorzugt von „Finalizer“, da der Ablauf über die von System.Object geerbte Finalize-Methode realisiert wird; der C#-Compiler erlaubt kein direktes Überschreiben von Finalize, sondern nur die Destruktorsyntax mit ~. Destruktoren/Finalizer sind nur mit Klassen möglich, nicht mit Strukturen, und in den meisten Fällen empfiehlt Microsoft, statt eines eigenen Finalizers System.Runtime.InteropServices.SafeHandle zur Verwaltung nicht verwalteter Ressourcen sowie das Dispose-Pattern zu verwenden. In VB.NET wird die entsprechende Funktionalität durch Protected Overrides Sub Finalize() abgebildet.

DI

(siehe „Dependency Injection“)

DI-Container

(siehe „Service Container“)

DLL

Synonyme:
Dynamic Link Library

Kurz:
Eine DLL (Dynamic Link Library, dynamische Programmbibliothek) ist eine unter Windows gebräuchliche Datei mit der Erweiterung .dll, die Programmcode, Daten und Ressourcen enthält und zur Laufzeit von mehreren Programmen gemeinsam genutzt werden kann.

Länger:
DLL-Dateien verwenden dasselbe Dateiformat wie ausführbare EXE-Dateien, nämlich je nach Zielarchitektur das New-Executable-, Linear-Executable- oder Portable-Executable-Format. Ihr Hauptzweck ist es, den von Anwendungen benötigten Speicherplatz auf der Festplatte und im Arbeitsspeicher zu reduzieren: Code und Daten, die mehrere Anwendungen benötigen könnten, werden in einer einzelnen Datei gespeichert und bei Bedarf nur einmal geladen. In .NET bildet die DLL – neben der EXE – eines der beiden physischen Dateiformate, in denen eine Assembly implementiert werden kann; die DLL enthält dann zusätzlich zum eigentlichen Code auch das Assemblymanifest mit Metadaten. Für den Zugriff auf native, nicht-verwaltete DLLs aus verwaltetem .NET-Code wird üblicherweise das DllImport-Attribut verwendet.

dotnet build

Synonyme:
—

Kurz:
dotnet build ist der .NET-CLI-Befehl, der ein Projekt und alle zugehörigen Abhängigkeiten in einen Satz von Binärdateien kompiliert.

Länger:
Der Befehl verwendet intern MSBuild und unterstützt dadurch parallele und inkrementelle Builds; er entspricht funktional weitgehend dotnet msbuild -restore, unterscheidet sich aber in der Standardausführlichkeit der Ausgabe. Die Buildkonfiguration wird über die Option -c|--configuration gesteuert (Standard: Debug), die Zielarchitektur über -a|--arch, das Zielframework über -f|--framework und die Ziellaufzeit über -r|--runtime. Da MSBuild für den Build die Datei project.assets.json benötigt, führt dotnet build implizit eine Wiederherstellung (dotnet restore) aus, sofern nicht --no-restore angegeben wird. Ob ein Projekt eine ausführbare Datei oder eine Bibliothek erzeugt, hängt von der Projekteigenschaft <OutputType> ab (Exe bzw. Library); bei ausführbaren .NET-Core-3.0-Projekten und höher werden Abhängigkeiten zusätzlich in den Ausgabeordner kopiert, sodass das Ergebnis in der Regel direkt lauffähig ist, jedoch nicht mit dotnet publish gleichzusetzen ist, das für die eigentliche Bereitstellung vorgesehen ist.

dotnet publish

Synonyme:
—

Kurz:
dotnet publish ist der .NET-CLI-Befehl, der eine Anwendung und ihre Abhängigkeiten kompiliert und in ein Verzeichnis zur Bereitstellung auf einem Hostsystem veröffentlicht.

Länger:
Der Befehl kompiliert die Anwendung, liest die in der Projektdatei angegebenen Abhängigkeiten und kopiert den resultierenden Satz an Dateien (unter anderem die kompilierte Assembly, eine .deps.json- und eine .runtimeconfig.json-Datei sowie Abhängigkeiten aus dem NuGet-Cache) in ein Ausgabeverzeichnis; laut Microsoft-Dokumentation ist die Ausgabe von dotnet publish die einzige offiziell unterstützte Möglichkeit, eine Anwendung für die Bereitstellung vorzubereiten. Wichtige Optionen sind -c|--configuration (ab .NET 8 standardmäßig Release, wenn das Zielframework net8.0 oder höher ist), -r|--runtime zur Angabe eines Runtime Identifiers, --self-contained/--no-self-contained zur Wahl zwischen eigenständiger und frameworkabhängiger Bereitstellung sowie -o|--output für das Zielverzeichnis. dotnet publish ruft intern MSBuild auf und löst dabei das Ziel Publish aus; MSBuild-Eigenschaften wie PublishSingleFile, PublishTrimmed oder PublishReadyToRun steuern zusätzliche Veröffentlichungsformen (Single-File-Deployment, Trimming, Ahead-of-Time-Kompilierung). Veröffentlichungseinstellungen können zudem in .pubxml-Profildateien unter Properties/PublishProfiles hinterlegt werden.

dotnet run

Synonyme:
—

Kurz:
dotnet run ist der .NET-CLI-Befehl, mit dem Anwendungen direkt aus dem Quellcode ausgeführt werden, ohne dass explizite Kompilierungs- oder Startbefehle nötig sind.

Länger:
Der Befehl bietet eine praktische Möglichkeit zur schnellen iterativen Entwicklung aus der Befehlszeile heraus und hängt intern vom Befehl dotnet build ab; alle Anforderungen für dotnet build gelten daher auch für dotnet run, jedoch werden Argumente wie /property:property=value, die dotnet build berücksichtigt, von dotnet run selbst nicht ausgewertet, sondern nur über --property weitergereicht. Die Ausgabedateien werden standardmäßig nach dem Muster bin/<configuration>/<target> geschrieben. Mit dem Trennzeichen -- lassen sich Argumente für den Befehl selbst von Argumenten trennen, die an die auszuführende Anwendung übergeben werden sollen (z. B. dotnet run -- --help). Da Abhängigkeiten aus dem NuGet-Cache aufgelöst werden, wird dotnet run nicht für den Produktionseinsatz empfohlen; dafür ist dotnet publish vorgesehen. Optionen wie --project, --launch-profile und --no-launch-profile steuern, welches Projekt bzw. welches in launchSettings.json definierte Startprofil verwendet wird.

https://learn.microsoft.com/de-de/dotnet/core/tools/dotnet-run

dotnet test

Synonyme:
—

Kurz:
dotnet test ist der .NET-CLI-Testtreiber, der eine Projektmappe oder ein Projekt erstellt und anschließend die enthaltenen Komponententests ausführt.

Länger:
Der Befehl unterstützt zwei Testläufer: VSTest, den traditionellen und bis einschließlich .NET 9 SDK einzigen Standardtestläufer, sowie ab dem .NET 10 SDK zusätzlich die Microsoft Testing Platform (MTP), die eine schnellere Testausführung und eine flexiblere Auswahl von Testmodulen bietet. Welcher Testläufer verwendet wird, kann über die Datei global.json mit dem Eintrag "test": { "runner": "Microsoft.Testing.Platform" } bzw. "VSTest" festgelegt werden; da VSTest der aktuelle Standardwert ist, kann die Angabe entfallen. Die verfügbaren Befehlszeilenoptionen und das genaue Verhalten unterscheiden sich je nach eingesetztem Testläufer, weshalb die offizielle Dokumentation auf separate Detailseiten zu dotnet test mit VSTest bzw. mit MTP verweist. Wie andere Befehle mit impliziter Wiederherstellung führt dotnet test vor dem eigentlichen Testlauf einen impliziten dotnet restore sowie einen dotnet build der Lösung aus.

https://learn.microsoft.com/de-de/dotnet/core/tools/dotnet-test

dotnet-Befehl

(siehe „.NET CLI“)

dotnet-Kommandozeilenschnittstelle

(siehe „.NET CLI“)

Dynamic Link Library

(siehe „DLL“)

E

EF Core

(siehe „Entity Framework Core“)

Eigenschaft

(siehe „Property“)

Encapsulation

(siehe „Kapselung“)

Entity Framework Core

Synonyme:
EF Core

Kurz:
Entity Framework Core (EF Core) ist eine leichtgewichtige, erweiterbare, plattformübergreifende Open-Source-Version der Entity-Framework-Datenzugriffstechnologie von Microsoft für .NET. Es fungiert als Object-Relational Mapper (O/RM) und ermöglicht .NET-Entwicklern, mit einer Datenbank über .NET-Objekte zu arbeiten, statt direkt SQL zu schreiben.

Länger:
Bei EF Core erfolgt der Datenzugriff über ein Modell, das sich aus Entitätsklassen und einem Kontextobjekt (einer von DbContext abgeleiteten Klasse) zusammensetzt, das eine Sitzung mit der Datenbank darstellt und das Abfragen sowie Speichern von Daten ermöglicht. Anwendungscode formuliert Datenbankzugriffe typischerweise über LINQ-Abfragen gegen DbSet<TEntity>-Eigenschaften des Kontexts; EF Core übersetzt diese Abfragen automatisch in SQL für die jeweilige Datenbank-Engine (z. B. SQL Server, SQLite, PostgreSQL, Azure Cosmos DB). Neben dem Lesen und Schreiben von Daten unterstützt EF Core Änderungsverfolgung (Change Tracking), Schema-Migrationen zur inkrementellen Aktualisierung des Datenbankschemas sowie Konfigurationsmöglichkeiten über Datenanmerkungen oder die Fluent API. EF Core wurde Mitte 2016 zusammen mit .NET Core als vollständige Neuimplementierung des klassischen Entity Framework mit deutlich geringerem Ressourcenbedarf eingeführt und wird von Microsoft aktiv weiterentwickelt.

Enum

(siehe „Enumeration“)

Enumeration

Synonyme:
Enum, Aufzählungstyp

Kurz:
Eine Enumeration (Enum) ist ein Werttyp, der durch einen Satz benannter Konstanten eines zugrunde liegenden ganzzahligen numerischen Typs definiert wird. Sie wird mit dem Schlüsselwort enum deklariert und dient dazu, eine Auswahl aus einer festen Menge sich gegenseitig ausschließender Werte darzustellen.

Länger:
Ein Enumerationstyp ist laut C#-Sprachspezifikation ein eindeutiger Werttyp, der einen Satz benannter Konstanten deklariert; jeder Enumerationstyp hat einen zugrunde liegenden integralen Typ, der standardmäßig int (Int32) ist, sofern kein anderer Typ wie byte, short oder long explizit angegeben wird. Die abstrakte Basisklasse aller Enumerationstypen in .NET ist System.Enum; sie stellt Methoden bereit, um Enum-Werte in ihre Zeichenfolgendarstellung umzuwandeln, aus einer Zeichenfolge zu parsen oder mit Enum.IsDefined zu prüfen, ob ein bestimmter Wert definiert ist. Für jeden Enumerationstyp existieren explizite Konvertierungen zwischen dem Enumerationstyp und seinem zugrunde liegenden Typ sowie Boxing-/Unboxing-Konvertierungen zu bzw. von System.Enum. Enums werden häufig für fest begrenzte Optionsmengen genutzt, etwa Wochentage, HTTP-Statuscodes oder Protokollstufen; mit dem [Flags]-Attribut lassen sich Enum-Werte zudem als kombinierbare Bitflags verwenden. In VB.NET entspricht dem C#-enum die Konstruktion Enum ... End Enum.

Ereignis

(siehe „Event“)

Error Handling

(siehe „Fehlerbehandlung“)

Erweiterungsmethode

(siehe „Extension Method“)

Event

Synonyme:
Ereignis

Kurz:
Ein Event (Ereignis) ist eine Benachrichtigung, mit der ein Objekt anderen interessierten Komponenten mitteilt, dass etwas Bestimmtes eingetreten ist, etwa ein Tastenklick oder der Abschluss einer Operation.

Länger:
Events werden in C# mit dem Schlüsselwort event im Zusammenspiel mit einem Delegattyp deklariert, z. B. public event EventHandler<FileFoundArgs>? FileFound;; andere Komponenten können sich mit dem Operator += für das Ereignis registrieren (abonnieren) und sich mit -= wieder abmelden. Zum Auslösen eines Ereignisses wird üblicherweise eine als protected virtual markierte Methode nach der Namenskonvention On<EventName> (z. B. OnDataReceived) bereitgestellt, die den Delegaten aufruft und dabei ein EventArgs-Objekt (oder eine davon abgeleitete Klasse) als Ereignisdaten übergibt; dies ermöglicht abgeleiteten Klassen, die Auslöselogik zu überschreiben. In VB.NET wird ein Ereignis mit Event eventname(parameterlist) deklariert und mit der Anweisung RaiseEvent eventname(argumentlist) ausgelöst; zusätzlich existiert dort die Möglichkeit, Ereignishandler über Handles-Klauseln bzw. WithEvents-deklarierte Objektvariablen automatisch zu verknüpfen, ein Mechanismus, der in C# kein direktes Gegenstück hat.

Exception

Synonyme:
Ausnahme

Kurz:
Eine Exception (Ausnahme) ist in .NET ein Objekt, das von der Klasse System.Exception erbt und einen Fehler oder ein unerwartetes Ereignis beschreibt, das während der Ausführung eines Programms aufgetreten ist.

Länger:
Wenn ein Fehler auftritt, wird er entweder vom System (z.B. der CLR) oder von der aktuell ausgeführten Anwendung gemeldet, indem eine Exception mittels throw ausgelöst wird; anschließend wird sie von der Anwendung selbst oder vom Standard-Ausnahmehandler behandelt. Die Klasse System.Exception ist die Basisklasse aller Ausnahmen in .NET und stellt zentrale Eigenschaften bereit, u.a. Message (Fehlerbeschreibung), StackTrace (Aufrufstapel zum Zeitpunkt des Auftretens), InnerException (verursachende, tiefer liegende Ausnahme) und HResult. Von Exception leiten sich unter anderem SystemException (vom Laufzeitsystem ausgelöste Fehler wie NullReferenceException oder IndexOutOfRangeException) und benutzerdefinierte Ausnahmeklassen ab; eigene Ausnahmetypen sollten laut Konvention auf „Exception“ enden und mindestens die Standardkonstruktoren implementieren.

Exception Handling

(siehe „Ausnahmebehandlung“)

EXE

Synonyme:
Executable

Kurz:
EXE (von englisch executable, „ausführbar“) ist die Dateinamenserweiterung für ausführbare Dateien unter Betriebssystemen wie DOS, Windows, OS/2, OpenVMS und Symbian.

Länger:
Eine EXE-Datei enthält Maschinencode oder Bytecode, der vom Betriebssystem beziehungsweise – im Fall von .NET – von einem Laufzeitsystem direkt ausgeführt werden kann. Unter Windows nutzen EXE-Dateien dasselbe zugrunde liegende Dateiformat (Portable Executable) wie DLL-Dateien und können ebenso Code, Daten und Ressourcen enthalten. In .NET ist die .exe-Datei neben der .dll-Datei eine der beiden Formen, in denen eine Assembly physisch vorliegen kann: Bei der framework-abhängigen Bereitstellung wird standardmäßig eine plattformspezifische ausführbare Hostdatei erzeugt, die die App startet, wobei diese entweder direkt aufgerufen oder über dotnet <name>.dll gestartet werden kann.

Executable

(siehe „EXE“)

Expression Tree

Synonyme:
Ausdrucksbaum

Kurz:
Ein Expression Tree (Ausdrucksbaum) ist eine baumartige Datenstruktur, die Code repräsentiert, wobei jeder Knoten einen Ausdruck wie einen Methodenaufruf oder eine binäre Operation (z. B. x < y) darstellt.

Länger:
Jeder Knoten in einer Ausdrucksbaumstruktur ist ein Objekt einer von der abstrakten Klasse System.Linq.Expressions.Expression abgeleiteten Klasse; um einen Ausdrucksbaum zu interpretieren, beginnt man üblicherweise am Wurzelknoten, bestimmt dessen konkreten Knotentyp und verarbeitet rekursiv dessen untergeordnete Knoten. Ausdrucksbäume ermöglichen es, Code zur Laufzeit als Datenstruktur zu untersuchen, zu manipulieren oder in eine andere Repräsentation zu übersetzen – ein zentrales Anwendungsbeispiel ist LINQ to SQL bzw. Entity Framework, wo ein als Expression<TDelegate> typisierter Lambda-Ausdruck vom Compiler nicht in ausführbaren IL-Code, sondern in einen traversierbaren Ausdrucksbaum übersetzt wird, den der jeweilige LINQ-Provider anschließend in eine SQL-Abfrage umwandelt. Nicht jeder C#-Ausdruck lässt sich in einen Ausdrucksbaum übersetzen; die Dokumentation listet explizit Einschränkungen auf, welche Sprachkonstrukte (etwa Anweisungs-Lambdas oder bestimmte Muster) in Ausdrucksbaumstrukturen nicht erlaubt sind.

Extensible Markup Language

(siehe „XML“)

Extension Method

Synonyme:
Erweiterungsmethode

Kurz:
Eine Extension Method (Erweiterungsmethode) erlaubt es, einem bestehenden Typ zusätzliche Methoden hinzuzufügen, ohne einen neuen abgeleiteten Typ zu erstellen, den Originaltyp neu zu kompilieren oder anderweitig zu verändern.

Länger:
Erweiterungsmethoden werden als statische Methoden innerhalb einer statischen Klasse definiert, jedoch mit der Syntax einer Instanzmethode aufgerufen; der erste Parameter der Methode erhält den Modifizierer this, gefolgt vom Typ, der erweitert werden soll, und bestimmt so den „Empfängertyp“. Damit eine Erweiterungsmethode nutzbar wird, muss der Namespace, in dem sie definiert ist, im aufrufenden Code explizit per using-Direktive importiert werden; laut deutscher Wikipedia handelt es sich technisch um syntaktischen Zucker, also einen Compilertrick, der die Methode dem erweiterten Typ nur scheinbar zuordnet. Erweiterungsmethoden wurden mit C# 3.0 im Jahr 2007 eingeführt und sind aus LINQ nicht wegzudenken, da Methoden wie Where oder Select als Erweiterungsmethoden auf IEnumerable<T> implementiert sind. Ab C# 14 (.NET 10) können mit dem neuen extension-Block zusätzlich zu Methoden auch Eigenschaften und Operatoren nachträglich zu einem Typ hinzugefügt werden; in VB.NET werden Erweiterungsmethoden analog in einem Module mit dem Attribut <Extension()> definiert.

F

FCL

(siehe „Framework Class Library“)

Fehlerbehandlung

Synonyme:
Error Handling

Kurz:
Fehlerbehandlung ist der allgemeine Oberbegriff für sämtliche Techniken, mit denen ein Programm Fehlerzustände erkennt, abfängt und angemessen darauf reagiert – in .NET wird dies technisch überwiegend durch die Ausnahmebehandlung (Exception Handling) mit try/catch/finally umgesetzt.

Länger:
Historisch wurde Fehlerbehandlung in vielen Sprachen über Rückgabe-Fehlercodes gelöst, bei denen eine Funktion einen Statuswert zurückgab, der Erfolg oder Misserfolg anzeigte. In .NET und modernen objektorientierten Sprachen wie C# und VB.NET wird stattdessen überwiegend das Konzept der „strukturierten Fehlerbehandlung“ über Ausnahmen (Exceptions) verwendet: Tritt ein Fehler auf, wird eine Ausnahme „geworfen“, die von aufrufendem Code „gefangen“ werden kann. Fehlerbehandlung ist somit der übergeordnete, sprachunabhängige Begriff, während Ausnahmebehandlung/Exception Handling die spezifische .NET-Implementierung dieses Konzepts über Exception-Objekte und die Schlüsselwörter try, catch und finally bezeichnet. In VB.NET existierte vor der strukturierten Ausnahmebehandlung zusätzlich die ältere, aus Visual Basic stammende „unstrukturierte“ Fehlerbehandlung mit On Error GoTo.

Fehlerdiagnose

(siehe „Debugging“)

Fehlersuche

(siehe „Debugging“)

Feld

(siehe „Field“)

Field

Synonyme:
Feld

Kurz:
Ein Field (Feld) ist eine Variable eines beliebigen Typs, die direkt in einer Klasse oder Struktur deklariert wird und Daten dieses Typs speichert.

Länger:
Felder sind Member (Mitglieder) ihres enthaltenden Typs und werden – im Unterschied zu lokalen Variablen – auf Klassenebene deklariert; sie können Instanzfelder (pro Objekt eine eigene Kopie) oder mit dem Schlüsselwort static deklarierte statische Felder sein, die für alle Instanzen gemeinsam existieren. Der Zugriff auf ein Feld erfolgt über einen Punkt nach dem Instanznamen, gefolgt vom Feldnamen; Felder werden häufig als private deklariert und über Properties nach außen kontrolliert zugänglich gemacht, um das Prinzip der Kapselung zu wahren. Felder, deren Wert zur Kompilierzeit feststeht und sich nicht ändert, werden stattdessen als Konstanten (const) deklariert. In VB.NET entsprechen Felder den mit Dim, Private, Public oder Shared deklarierten Membervariablen einer Klasse.

Finalizer

(siehe „Destruktor“)

Framework Class Library

Synonyme:
FCL

Kurz:
Die Framework Class Library (FCL) ist die umfassende Klassenbibliothek des .NET Frameworks, der ersten Implementierung der Common Language Infrastructure (CLI); sie stellt eine breite Sammlung wiederverwendbarer Klassen, Schnittstellen und Werttypen für den Aufbau von Desktop-, Web- und Serveranwendungen bereit.

Länger:
So wie die Common Language Runtime (CLR) das virtuelle Ausführungssystem (Virtual Execution System) der CLI implementiert, setzt die FCL die grundlegenden Standardbibliotheken der CLI um; als deren Implementierung schließt die FCL insbesondere auch eine Implementierung der CLI Base Class Library (BCL) mit ein. Die FCL ist in eine Hierarchie von Namespaces gegliedert, wobei sich die am häufigsten verwendete Funktionalität in den Namespaces System.* und Microsoft.* findet; sie deckt neben grundlegenden Datentypen auch Bereiche wie Collections, Netzwerkkommunikation, XML-Verarbeitung sowie – anders als die reine BCL – vollständige Anwendungsframeworks wie ASP.NET, Windows Forms, WPF und ADO.NET ab. Historisch und begrifflich ist die BCL damit eine Teilmenge beziehungsweise ein Kernbestandteil der wesentlich umfassenderen FCL: Während die BCL die plattformunabhängigen Grundtypen für Zeichenfolgen, primitive Datentypen, E/A und ähnliche alltägliche Aufgaben bereitstellt, integriert die FCL zusätzlich die spezialisierten Bibliotheken für konkrete Anwendungsarten. Der Begriff FCL wird ausschließlich im Kontext des klassischen .NET Frameworks verwendet, während in modernem .NET (.NET Core und Nachfolger) meist von „Runtimebibliotheken“ oder weiterhin von der BCL gesprochen wird, ergänzt um Erweiterungen, die als NuGet-Pakete bereitgestellt werden.

Framework-dependent Deployment

Synonyme:
Framework-abhängige Bereitstellung

Kurz:
Die framework-abhängige Bereitstellung (Framework-Dependent Deployment, FDD) erzeugt eine Anwendung, die nur aus dem App-Code und dessen Abhängigkeiten besteht, während die passende .NET-Runtime bereits auf dem Zielsystem installiert sein muss.

Länger:
Bei diesem Standardmodus – er wird automatisch verwendet, wenn über die .NET-CLI oder Visual Studio veröffentlicht wird, sofern nichts anderes angegeben ist – erstellt der Veröffentlichungsprozess einen plattformspezifischen ausführbaren Host zum Ausführen der plattformübergreifenden App, eine kompilierte Binärdatei mit dem App-Code sowie alle App-Abhängigkeiten. Die App kann entweder direkt über die erzeugte ausführbare Datei oder mittels dotnet <PROJECT-FILE>.dll gestartet werden. Vorteile sind eine kleine Bereitstellungsgröße, Plattformübergreifendheit sowie die automatische Weiterleitung auf den neuesten in der Zielumgebung installierten .NET-Sicherheitspatch. Nachteil ist, dass die passende .NET-Runtime-Version im Zielsystem bereits vorhanden sein muss und sich das App-Verhalten durch eine dort installierte neuere Runtime ändern kann. Über die CLI wird dieser Modus mit dotnet publish -c Release [-r <RID>] bzw. explizit mit dem Zusatz --self-contained false erzeugt; er steht im Gegensatz zur eigenständigen Bereitstellung (Self-Contained Deployment).

Function (VB.NET)

Synonyme:
Function-Prozedur

Kurz:
Eine Function-Prozedur ist in VB.NET ein Block von Anweisungen, eingeschlossen von Function und End Function, der eine Aufgabe ausführt und dabei einen Wert an den aufrufenden Code zurückgibt.

Länger:
Die Deklaration folgt der Syntax [Modifiers] Function FunctionName [(ParameterList)] As ReturnType ... End Function. Innerhalb der Prozedur wird der Rückgabewert typischerweise durch Zuweisung an den Funktionsnamen (bzw. per Return-Anweisung) festgelegt; danach kehrt die Ausführung zum Aufrufer zurück und übergibt diesen Wert. Eine Function-Prozedur kann wie eine Sub-Prozedur nur auf Modulebene definiert werden, also innerhalb einer Klasse, Struktur, eines Moduls oder einer Schnittstelle. Der zentrale Unterschied zur Sub-Prozedur besteht also im Rückgabewert; ansonsten ähneln sich Deklaration und Parameterübergabe (ByVal/ByRef) stark. In C# entspricht dies einer Methode mit einem konkreten Rückgabetyp anstelle von void.

Function-Prozedur

(siehe „Function (VB.NET)“)

G

Generics

Synonyme:
Generische Typen, Generizität

Kurz:
Generics führen in .NET das Konzept von Typparametern ein und ermöglichen den Entwurf von Klassen, Strukturen, Schnittstellen und Methoden, die die Festlegung eines konkreten Datentyps bis zur Verwendung im Code aufschieben.

Länger:
Mit einem generischen Typparameter wie T lässt sich eine einzige Klasse oder Methode schreiben, die von anderem Code für beliebige Typen verwendet werden kann, ohne dass Laufzeit-Typumwandlungen (Casts) oder Boxing-Operationen nötig sind; der Compiler prüft die Typsicherheit bereits zur Kompilierzeit. Generische Typparameter werden während der Kompilierung durch die tatsächlichen Typargumente ersetzt; man unterscheidet dabei unter anderem offene generische Typen (kein Typargument angegeben, z. B. Dictionary<TKey, TValue>) und geschlossene, konstruierte generische Typen (alle Typargumente angegeben, z. B. Dictionary<string, object>). Generics werden am häufigsten für Auflistungstypen wie verknüpfte Listen, Hashtabellen, Stapel und Warteschlangen verwendet und existieren in C# auch als generische Delegates und – seltener genutzt – generische Attribute; sie kombinieren Wiederverwendbarkeit, Typsicherheit und Effizienz in einer Weise, die mit nicht generischen Gegenstücken nicht erreichbar ist.

Generische Typen

(siehe „Generics“)

Generizität

(siehe „Generics“)

Geschachtelte Klasse

Synonyme:
Nested Class, Verschachtelte Klasse

Kurz:
Eine geschachtelte Klasse (nested class) ist eine Klasse, die innerhalb einer anderen Klasse, Struktur oder Schnittstelle definiert wird. Sie ist standardmäßig privat und somit nur innerhalb der umschließenden (äußeren) Klasse zugänglich.

Länger:
In C# spricht man allgemeiner von geschachtelten Typen (nested types), da nicht nur Klassen, sondern auch Structs, Interfaces, Enums und Delegates innerhalb eines anderen Typs deklariert werden können. Unabhängig davon, ob der äußere Typ eine Klasse, Schnittstelle oder Struktur ist, sind geschachtelte Typen standardmäßig private; über explizite Zugriffsmodifizierer wie public, protected, internal, protected internal oder private protected lässt sich die Sichtbarkeit anpassen, wobei geschachtelte Klassen einer class alle genannten Modifizierer erlauben. Der geschachtelte (innere) Typ hat Zugriff auf alle Member, die für seinen äußeren (umschließenden) Typ zugänglich sind, einschließlich dessen privater und geschützter Member sowie geerbter geschützter Member; um auf eine Instanz des äußeren Typs zuzugreifen, muss diese explizit z. B. über den Konstruktor an den geschachtelten Typ übergeben werden. Geschachtelte Klassen werden typischerweise eingesetzt, wenn eine Klasse logisch eng mit einer anderen verbunden ist und außerhalb dieses Kontexts keine eigenständige Bedeutung hat, etwa eine Hilfsklasse, die nur intern von einer Auflistungsklasse verwendet wird. Der Zugriff von außen erfolgt über den qualifizierten Namen, z. B. Outer.Inner. VB.NET unterstützt dasselbe Konzept über verschachtelte Class-Deklarationen innerhalb einer Klasse.

get-Accessor

(siehe „Getter“)

Getter

Synonyme:
get-Accessor

Kurz:
Der Getter (get-Accessor) ist der Teil einer Property oder eines Indexers in C#, der ausgeführt wird, wenn der Wert der Property gelesen wird, und den Property-Wert zurückgibt.

Länger:
Das Schlüsselwort get definiert innerhalb einer Property oder eines Indexers eine Zugriffsmethode, die einen Wert vom Typ der Property zurückliefert; der Rumpf eines get-Accessors ähnelt dem einer regulären Methode und muss über return einen Wert liefern (bzw. bei einer Ausdrucks-Property in Kurzform als =>-Ausdruck formuliert werden). Eine Property, die nur einen get-Accessor besitzt, ist schreibgeschützt (read-only). Getter werden häufig zusammen mit einem Setter verwendet, um kontrollierten Lese- und Schreibzugriff auf ein privates Feld zu ermöglichen, wobei beide Accessoren auch unterschiedliche Zugriffsmodifizierer besitzen können. In VB.NET entspricht dies dem Get ... End Get-Block innerhalb einer Property-Deklaration.

Global Using Directive

(siehe „Globale using-Anweisung“)

Globale using-Anweisung

Synonyme:
Global Using Directive

Kurz:
Eine globale using-Anweisung (global using) ist eine seit C# 10 verfügbare Erweiterung der using-Direktive, die den Namespace-Import auf alle Dateien eines Projekts (der gesamten Kompilierung) anwendet, statt nur auf die einzelne Datei, in der sie steht.

Länger:
Ohne das Schlüsselwort global gilt eine using-Direktive nur für die Datei, in der sie deklariert wurde. Mit global using <vollqualifizierter-Namespace>; wird derselbe Import hingegen für sämtliche Quelldateien der Kompilierung (üblicherweise ein Projekt) wirksam, wodurch wiederholte using-Direktiven in jeder einzelnen Datei entfallen. Globale using-Direktiven sind nur auf Kompilierungseinheitsebene zulässig (nicht innerhalb einer Namespace-Deklaration) und müssen in einer Quelldatei vor allen nicht-globalen using-Direktiven stehen; viele Teams sammeln sie in einer eigenen Datei, etwa GlobalUsings.cs. Die Modifizierer static und global lassen sich kombinieren, um auch statische Member projektweit verfügbar zu machen. Ergänzend generiert das .NET SDK bei aktivierter Option <ImplicitUsings>enable</ImplicitUsings> automatisch projektabhängige globale using-Direktiven für die gängigsten Namespaces. Dieses Feature betrifft ausschließlich die using-Direktive zum Namespace-Import, nicht die using-Anweisung zur Ressourcenfreigabe.

H

Haltepunkt

(siehe „Breakpoint“)

I

ICollection

Synonyme:
—

Kurz:
ICollection<T> ist eine generische Schnittstelle in System.Collections.Generic, die IEnumerable<T> um grundlegende Operationen zum Hinzufügen, Entfernen, Prüfen und Zählen von Elementen erweitert. Sie ist die Basisschnittstelle für spezialisiertere Auflistungsschnittstellen wie IList<T> und IDictionary<TKey,TValue>.

Länger:
Die Schnittstelle ICollection<T> definiert neben der von IEnumerable<T> geerbten Aufzählbarkeit zusätzliche Member wie die Eigenschaft Count, die Eigenschaft IsReadOnly sowie die Methoden Add, Clear, Contains, CopyTo und Remove. Sie repräsentiert damit eine einfache, veränderbare Sammlung von Elementen eines Typs T, ohne jedoch eine bestimmte Reihenfolge oder einen indexbasierten Zugriff vorauszusetzen – dafür sind die abgeleiteten Schnittstellen IList<T> (indexbasierter Zugriff) und IDictionary<TKey,TValue> (Schlüssel-Wert-Zugriff) zuständig. Konkrete Klassen wie List<T>, Dictionary<TKey,TValue> oder HashSet<T> implementieren ICollection<T> direkt oder indirekt. Laut den Framework Design Guidelines von Microsoft sollten neue Auflistungstypen mindestens IEnumerable<T> implementieren und, wo sinnvoll, zusätzlich ICollection<T> oder IList<T>, um eine breitere Verwendbarkeit im .NET-Ökosystem sicherzustellen.

IDependency

Synonyme:
—

Kurz:
„IDependency“ ist kein Standardtyp der .NET-Klassenbibliothek und kein offizielles Framework-Konstrukt, sondern ein in Lehrbeispielen und Tutorials zu Dependency Injection gelegentlich verwendeter, frei gewählter Schnittstellenname. Er folgt lediglich der allgemeinen C#-Namenskonvention, Schnittstellennamen mit dem Präfix „I“ zu versehen (hier kombiniert mit dem Substantiv „Dependency“, um exemplarisch eine injizierte Abhängigkeit zu benennen).

Länger:
Es lässt sich keine offizielle, spezifische Quelle für „IDependency“ als benannten, standardisierten Typ in .NET, C#, VB.NET oder in Microsofts Dependency-Injection-Dokumentation belegen; die dortigen Beispiele verwenden meist andere Bezeichnungen wie IMessageWriter, IMyDep oder IWorkerQueue. Der Name ist somit korrekt als reines Anwendungsbeispiel der allgemeinen C#-Namenskonvention für Schnittstellen einzuordnen: Laut den offiziellen Bezeichnerregeln und den Framework Design Guidelines von Microsoft beginnen Schnittstellennamen in C# stets mit einem großen „I“, gefolgt von einem Substantiv, einer Nominalphrase oder einem Adjektiv in Pascal-Schreibweise (Beispiele der Guidelines sind IComponent, ICustomAttributeProvider oder IPersistable). Im Kontext von Dependency Injection wird dieses Präfix-Muster besonders häufig genutzt, um Abhängigkeiten hinter einer Abstraktion zu verstecken – ein Interface wie „IDependency“ würde in einem Lehrbeispiel exemplarisch für „die Schnittstelle, hinter der eine konkrete Abhängigkeit registriert wird“ stehen, ist aber weder Teil der Base Class Library noch ein feststehender Begriff der offiziellen Dokumentation. Wer in eigenem Code eine Schnittstelle für eine injizierte Abhängigkeit benennt, sollte daher, den Guidelines folgend, einen aussagekräftigeren, auf die konkrete Aufgabe bezogenen Namen wählen (z. B. ILogger, IRepository<T>) statt des generischen Platzhalters „IDependency“.

IDictionary

Synonyme:
—

Kurz:
IDictionary<TKey, TValue> ist die generische Basisschnittstelle für Sammlungen von Schlüssel-Wert-Paaren in System.Collections.Generic. Sie ermöglicht den Zugriff auf Werte über einen eindeutigen Schlüssel.

Länger:
Jedes Element einer IDictionary<TKey, TValue>-Implementierung ist ein KeyValuePair<TKey, TValue>. Die Schnittstelle erweitert ICollection<KeyValuePair<TKey, TValue>> und damit auch IEnumerable<KeyValuePair<TKey, TValue>>, definiert aber zusätzlich einen Indexer über den Schlüssel sowie Member wie Keys, Values, Add(TKey, TValue), ContainsKey und TryGetValue. Die konkrete Klasse Dictionary<TKey,TValue> ist die gebräuchlichste Implementierung und bietet im Durchschnitt eine sehr effiziente Suche über eine Hash-basierte interne Struktur. Da Schlüssel eindeutig sein müssen, löst das erneute Hinzufügen eines bereits vorhandenen Schlüssels über Add eine ArgumentException aus; für einen sicheren Zugriff ohne Ausnahme empfiehlt sich TryGetValue. IDictionary<TKey,TValue> wird häufig als Abstraktion verwendet, wenn eine Methode nur Lese- und Schreibzugriffe auf Schlüssel-Wert-Daten benötigt, ohne an eine bestimmte Implementierung gebunden zu sein.

IDisposable

Synonyme:
—

Kurz:
IDisposable ist eine .NET-Schnittstelle aus dem Namespace System, die einen einheitlichen Mechanismus zum deterministischen Freigeben nicht verwalteter (und optional verwalteter) Ressourcen definiert.

Länger:
IDisposable deklariert eine einzige Methode, Dispose(), die anwendungsdefinierte Aufgaben zum Freigeben, Freisetzen oder Zurücksetzen nicht verwalteter Ressourcen ausführt. Eine Klasse kündigt durch die Implementierung von IDisposable an, dass ihre Instanzen knappe Ressourcen (z. B. Datei-Handles, Netzwerkverbindungen, Datenbankverbindungen) reservieren, die nicht allein durch den Garbage Collector zeitnah freigegeben würden. Im empfohlenen Implementierungsmuster ruft die öffentliche, nicht virtuelle Dispose()-Methode intern Dispose(disposing: true) auf und anschließend GC.SuppressFinalize(this), um das Objekt aus der Finalisierungswarteschlange zu entfernen; ein optionaler Finalizer ruft im Fehlerfall Dispose(disposing: false) auf und gibt dabei ausschließlich nicht verwaltete Ressourcen frei. In C# und VB.NET wird IDisposable typischerweise zusammen mit der using-Anweisung bzw. using-Deklaration verwendet, damit Dispose() garantiert und deterministisch aufgerufen wird, sobald das Objekt seinen Gültigkeitsbereich verlässt – auch wenn im Code eine Ausnahme auftritt. Zahlreiche .NET-Basisklassentypen implementieren IDisposable, u. a. System.IO.Stream, System.Data.Common.DbConnection, System.Net.Http.HttpResponseMessage und System.Threading.CancellationTokenSource.

IEnumerable

Synonyme:
—

Kurz:
IEnumerable<T> ist die grundlegende generische Schnittstelle im Namespace System.Collections.Generic, die eine einfache Iteration über eine Sammlung von Elementen eines bestimmten Typs ermöglicht. Sie stellt einzig die Methode GetEnumerator() bereit und bildet die Basis fast aller .NET-Auflistungstypen.

Länger:
IEnumerable<T> erweitert die nicht generische Schnittstelle IEnumerable und definiert einen Vertrag für Typen, deren Elemente sich mit foreach (C#) bzw. For Each…Next (VB.NET) durchlaufen lassen. Implementierende Klassen müssen lediglich GetEnumerator() bereitstellen, das einen IEnumerator<T> zurückgibt; dieser kapselt die eigentliche Iterationslogik über MoveNext() und Current. IEnumerable<T> ist die Basisschnittstelle für spezialisiertere Schnittstellen wie ICollection<T>, IList<T> und IDictionary<TKey,TValue> sowie für praktisch alle LINQ-Operatoren („LINQ to Objects“), da diese als Erweiterungsmethoden auf IEnumerable<T> definiert sind. Ein wichtiger Unterschied besteht zu IQueryable<T>: Während IEnumerable<T> für die Iteration bereits im Speicher befindlicher Daten steht, wird IQueryable<T> für Abfragen gegen entfernte Datenquellen (z. B. über Entity Framework) verwendet, wobei LINQ-Ausdrücke in Ausdrucksbäume statt in direkte Delegataufrufe übersetzt werden. Da IEnumerable<T> nur Lesezugriff bietet, sind Sammlungen, die zusätzlich verändert werden sollen, in der Regel über ICollection<T> oder IList<T> zu implementieren, welche IEnumerable<T> erweitern.

IL

(siehe „Common Intermediate Language“)

IList

Synonyme:
—

Kurz:
IList<T> ist eine generische Schnittstelle in System.Collections.Generic, die eine Sammlung von Objekten darstellt, auf die über einen numerischen Index einzeln zugegriffen werden kann. Sie erweitert ICollection<T> und damit auch IEnumerable<T>.

Länger:
IList<T> ist die Basisschnittstelle aller generischen, indexbasierten Listen in .NET. Zusätzlich zu den von ICollection<T> geerbten Mitgliedern definiert sie einen Indexer (this[int index]) sowie die Methoden IndexOf, Insert und RemoveAt, wodurch positionsbasiertes Einfügen, Auslesen und Entfernen von Elementen möglich wird. Die generische Klasse List<T> ist die am häufigsten verwendete konkrete Implementierung dieser Schnittstelle und nutzt intern ein dynamisch wachsendes Array. IList<T> wird typischerweise als Parameter- oder Rückgabetyp verwendet, wenn eine Methode auf geordnete, indexierte Daten zugreifen oder diese verändern muss, aber nicht an eine konkrete Implementierung wie List<T> oder ein Array gebunden sein soll.

Implizit typisierte lokale Variable

(siehe „var“)

Imports

(siehe „Namespace-Import“)

Imports (VB.NET)

(siehe „Namespace-Import“)

`in` (Parametermodifizierer)

Synonyme:
—

Kurz:
in ist ein C#-Parametermodifizierer, mit dem ein Argument per Verweis anstatt per Wert übergeben wird, wobei die Methode dem Parameter keinen neuen Wert zuweisen darf – der Parameter ist also schreibgeschützt.

Länger:
Bei einem mit in deklarierten Parameter muss das Argument vor dem Methodenaufruf initialisiert sein, und die Methode kann ihm keinen neuen Wert zuweisen. Der Compiler kann für das Argument eine temporäre Variable erzeugen und einen schreibgeschützten Verweis darauf an die Methode übergeben; dies geschieht insbesondere, wenn das Argument implizit konvertiert werden muss oder selbst kein Variablenausdruck, sondern etwa ein Literal oder ein Rückgabewert eines Property-Getters ist. in wird vor allem eingesetzt, um bei großen Wertetypen (Structs) die Kosten einer Kopie zu vermeiden, ohne dabei Schreibzugriff auf das Original zu gewähren – die Methode signalisiert dadurch, dass sie den Zustand des übergebenen Arguments nicht verändert. Am Aufrufort ist die explizite Angabe des in-Modifizierers optional; wird stattdessen ref angegeben, gibt der Compiler eine Warnung aus. in unterscheidet sich von ref dadurch, dass Letzterer Lese- und Schreibzugriff erlaubt, und von out dadurch, dass bei out keine vorherige Initialisierung nötig, aber eine Zuweisung in der Methode zwingend ist.

Inheritance

(siehe „Vererbung“)

Interface

Synonyme:
Schnittstelle

Kurz:
Ein Interface (Schnittstelle) definiert einen Vertrag aus Methoden, Eigenschaften, Ereignissen und Indexern, den jede implementierende Klasse, jeder Struct oder jeder Record erfüllen muss. Anders als bei Klassen kann eine Klasse beliebig viele Interfaces implementieren, was Mehrfachvererbung von Verhalten in C# ermöglicht.

Länger:
In C# wird ein Interface mit dem Schlüsselwort interface deklariert; traditionell enthält es selbst keine Implementierung, sondern nur Signaturen der Member, die implementierende Typen bereitstellen müssen. Seit C# 8 können Interfaces jedoch auch Standardimplementierungen für Member definieren, und seit C# 11 sind zusätzlich static abstract- bzw. static virtual-Member möglich. Ein Interface kann keine Instanzdaten wie Felder deklarieren, wohl aber statische Konstruktoren, Felder, Konstanten oder Operatoren enthalten. Da C# keine Mehrfachvererbung von Klassen zulässt, ist die Implementierung mehrerer Interfaces das zentrale Mittel, um einer Klasse Verhalten aus mehreren Quellen hinzuzufügen; außerdem müssen Interfaces genutzt werden, um Vererbung für Structs zu simulieren, da diese nicht von anderen Structs oder Klassen erben können. Namenskonventionen sehen üblicherweise ein vorangestelltes „I“ vor (z. B. IDisposable), was allerdings eine Konvention und keine Sprachregel ist. In VB.NET wird ein Interface mit Interface ... End Interface deklariert und mit Implements in einer Klasse umgesetzt. Interfaces ähneln abstrakten Klassen, sind jedoch rein „vertraglicher“ Natur und erlauben – von Default-Implementierungen abgesehen – keine eigenen Methodenkörper.

Intermediate Language

(siehe „Common Intermediate Language“)

Interpolated String

(siehe „Interpolierte Zeichenfolge“)

Interpolierte Zeichenfolge

Synonyme:
String Interpolation, Interpolated String

Kurz:
Eine interpolierte Zeichenfolge ist ein Zeichenfolgenliteral, das mit dem Zeichen $ eingeleitet wird und in geschweiften Klammern eingebettete Ausdrücke (Interpolationsausdrücke) enthalten kann, deren Werte zur Laufzeit in die resultierende Zeichenfolge eingesetzt werden.

Länger:
In C# wird ein Zeichenfolgenliteral durch das Voranstellen des $-Symbols (ohne Leerzeichen vor dem Anführungszeichen) zu einer interpolierten Zeichenfolge; innerhalb der geschweiften Klammern { } kann ein beliebiger gültiger C#-Ausdruck stehen, der einen Wert zurückgibt, optional gefolgt von einer Formatangabe nach einem Doppelpunkt (z. B. {Preis:C2}). Interpolierte Zeichenfolgen unterstützen dieselben Formatierungsfunktionen wie die zusammengesetzte Zeichenfolgenformatierung (String.Format), sind jedoch deutlich lesbarer, da der einzusetzende Ausdruck direkt im Text erscheint statt in einer separaten Argumentliste. Das Feature wurde mit C# 6 eingeführt; C# 11 erweiterte es unter anderem um Zeilenumbrüche innerhalb interpolierter Zeichenfolgen und die Kombination mit Raw String Literals. VB.NET unterstützt ab Version 14 dieselbe Funktionalität mit identischer $"..."-Syntax und äquivalenter Semantik ({ausdruck[,breite][:formatstring]}); auch dort wird der Ausdruck intern letztlich über String.Format aufgelöst.

Inversion of Control

Synonyme:
IoC

Kurz:
Inversion of Control (IoC) ist ein allgemeines Entwurfsprinzip, bei dem der Kontrollfluss über die Erzeugung und Verwaltung von Objekten von der Anwendung an ein übergeordnetes Framework oder einen Container abgegeben wird. Dependency Injection ist die in .NET am häufigsten verwendete konkrete Umsetzung dieses Prinzips.

Länger:
Während in klassischer prozeduraler Programmierung der eigene Code aktiv Bibliotheken aufruft, kehrt IoC diesen Fluss um: Ein generisches Framework ruft den anwendungsspezifischen Code auf bzw. übernimmt die Verantwortung für Aufgaben wie Objekterzeugung und Lebenszyklusverwaltung. In .NET wird Dependency Injection explizit als „eine spezialisierte Version des Inversion-of-Control-Musters“ beschrieben, bei der konkret die Beschaffung benötigter Abhängigkeiten invertiert wird: Nicht die Klasse selbst beschafft sich ihre Abhängigkeiten, sondern eine andere Komponente (der DI-Container) injiziert sie zur Laufzeit. IoC ist damit der übergeordnete Grundsatz, DI eine seiner gebräuchlichsten Ausprägungen; weitere Erscheinungsformen von IoC sind etwa Event-Handling oder Template-Methoden-Muster, bei denen ebenfalls ein Framework die Kontrolle über Ablaufsteuerung übernimmt.

IoC

(siehe „Inversion of Control“)

Iterator

Synonyme:
—

Kurz:
Ein Iterator ist eine Methode, ein Operator oder ein get-Accessor, der eine benutzerdefinierte Iteration über eine Auflistung durchführt und deren Elemente einzeln über die yield return-Anweisung zurückgibt.

Länger:
Wenn eine yield return-Anweisung erreicht wird, merkt sich die Laufzeit die aktuelle Position im Code; beim nächsten Aufruf der Iteratorfunktion wird die Ausführung genau an dieser Stelle fortgesetzt, was eine verzögerte (lazy) Auswertung der Sequenz ermöglicht. Der Rückgabetyp einer Iteratormethode ist typischerweise IEnumerable, IEnumerable<T>, IEnumerator oder IEnumerator<T>; der Compiler generiert intern eine Zustandsmaschine, die das Interface implementiert, sodass die Methode ohne explizite Implementierung von IEnumerator in einer foreach-Schleife durchlaufen werden kann. Iteratoren werden verwendet, um Container wie Listen oder Arrays zu durchlaufen, ohne die interne Struktur der Auflistung offenzulegen, und sind ein zentrales Sprachfeature seit C# 2.0.

J

JavaScript Object Notation

(siehe „JSON“)

JIT

(siehe „Just-in-Time-Kompilierung“)

JIT-Compiler

(siehe „Just-in-Time-Kompilierung“)

JSON

Synonyme:
JavaScript Object Notation

Kurz:
JSON (JavaScript Object Notation) ist ein kompaktes, textbasiertes Datenformat zum Austausch strukturierter Daten zwischen Anwendungen, unabhängig von der verwendeten Programmiersprache.

Länger:
JSON stellt Daten als geordnete Liste von Werten (Arrays) oder als ungeordnete Liste von Schlüssel-Wert-Paaren (Objekte) dar; ein JSON-Objekt beginnt mit { und endet mit }, seine Eigenschaften bestehen jeweils aus einem Schlüssel und einem durch Doppelpunkt getrennten Wert. JSON wurde ursprünglich 2001 von Douglas Crockford spezifiziert und ist heute durch RFC 8259 sowie den ECMA-Standard ECMA-404 normiert. In .NET wird JSON hauptsächlich über den Namespace System.Text.Json verarbeitet, der mit der Klasse JsonSerializer Methoden zum Serialisieren von Objekten in JSON-Text und zum Deserialisieren von JSON-Text in Objekte bereitstellt; alternativ ist auch die verbreitete Drittanbieter-Bibliothek Newtonsoft.Json gebräuchlich. JSON konkurriert dabei mit XML als Format für den Datenaustausch, ist jedoch in der Regel kompakter und einfacher zu lesen.

Just-in-Time-Kompilierung

Synonyme:
JIT, JIT-Compiler

Kurz:
Just-in-Time-Kompilierung (JIT) bezeichnet die Übersetzung von Programmcode zur Laufzeit in Maschinencode, anstatt vollständig vor der Ausführung (Ahead-of-Time) zu kompilieren. In .NET übersetzt der JIT-Compiler der Common Language Runtime den Common-Intermediate-Language(CIL)-Code eines Assemblys bei Bedarf – üblicherweise beim ersten Aufruf einer Methode – in nativen, CPU-spezifischen Code.

Länger:
Beim „verwalteten Ausführungsprozess“ von .NET übersetzt zunächst ein Sprachcompiler (z. B. für C#) den Quellcode in CIL samt Metadaten; erst zur Laufzeit konvertiert der JIT-Compiler diesen CIL-Code auf Abruf in nativen Code, sobald der entsprechende Assembly-Inhalt geladen und ausgeführt wird. Während dieser Kompilierung durchläuft der Code eine Verifikation, die prüft, ob er als typsicher eingestuft werden kann. Die konkrete JIT-Implementierung von CoreCLR trägt den Codenamen „RyuJIT“ und stellt den Kompilierungsdienst für die .NET-Laufzeit bereit; alternativ kann Code auch interpretiert werden, etwa in bestimmten WebAssembly-Szenarien. Gegenüber der Ahead-of-Time-Kompilierung (z. B. Native AOT) bietet JIT den Vorteil kurzer Build-Deploy-Debug-Zyklen und unterstützt Funktionen wie „Edit and Continue“, hat jedoch einen gewissen Overhead bei Programmstart und Speicherbedarf, da Übersetzung und Laufzeit gleichzeitig stattfinden.

K

Kapselung

Synonyme:
Encapsulation

Kurz:
Kapselung ist das Verbergen des internen Zustands und der Funktionalität eines Objekts, sodass der Zugriff von außen nur über eine öffentlich definierte Menge von Methoden und Eigenschaften erfolgt. Sie gilt oft als erste Säule der objektorientierten Programmierung.

Länger:
In C# und VB.NET wird Kapselung primär über Zugriffsmodifizierer wie public, private, protected, internal, protected internal und private protected realisiert, mit denen eine Klasse oder Struktur festlegt, wie zugänglich jedes ihrer Mitglieder für Code außerhalb der Klasse ist. Mitglieder, die nicht für externen Code (den sogenannten Clientcode) bestimmt sind, werden verborgen, um das Potenzial für Programmierfehler oder böswillige Zugriffe zu reduzieren; der Standardzugriffsmodifizierer für Klassenmitglieder ist private. In der deutschsprachigen Informatik wird der Begriff häufig auch als Datenkapselung bezeichnet und geht auf das Prinzip des Information Hiding von David Parnas zurück: Der direkte Zugriff auf interne Datenstrukturen wird unterbunden und stattdessen über definierte Schnittstellen, etwa Eigenschaften (Properties) mit get/set-Zugriffsmethoden, ermöglicht. Praktisch bedeutet dies beispielsweise, dass ein privates Feld einer Klasse nur über eine öffentliche Property mit Validierungslogik verändert werden kann, wodurch die Klasse die Kontrolle über ihren eigenen, konsistenten Zustand behält.

Klasse

Synonyme:
Class

Kurz:
Eine Klasse ist ein Referenztyp, der als Bauplan festlegt, welche Daten (Felder, Eigenschaften) und welches Verhalten (Methoden, Ereignisse) ein Objekt dieses Typs besitzt. Aus einer Klasse werden mittels des new-Operators konkrete Objekte (Instanzen) erzeugt.

Länger:
In C# wird eine Klasse mit dem Schlüsselwort class gefolgt von einem eindeutigen Bezeichner deklariert; der Klassenkörper enthält Felder, Eigenschaften, Methoden und Ereignisse, zusammengefasst als Klassenmember bezeichnet. Da Klassen Referenztypen sind, enthält eine Variable eines Klassenobjekts lediglich einen Verweis auf die Adresse des Objekts im verwalteten Heap; wird diese Variable einer anderen Variablen desselben Typs zugewiesen, verweisen beide auf dasselbe Objekt. Obwohl die Begriffe „Klasse“ und „Objekt“ manchmal synonym verwendet werden, sind sie unterschiedliche Dinge: Eine Klasse definiert einen Typ, ist aber selbst kein Objekt, während ein Objekt eine konkrete Instanz einer Klasse darstellt. Klassen unterstützen zentrale objektorientierte Konzepte wie Vererbung, Kapselung über Zugriffsmodifizierer und Polymorphismus über virtuelle Methoden. In VB.NET wird eine Klasse analog mit dem Schlüsselwort Class ... End Class definiert; beide Sprachen erlauben zusätzlich abstrakte Klassen (abstract/MustInherit) und versiegelte Klassen (sealed/NotInheritable), die die Möglichkeit der Vererbung einschränken.

Klassenbibliothek

(siehe „Class Library“)

Klassenmitglied

(siehe „Member“)

Klassenmodul

Synonyme:
Class Module

Kurz:
Ein Klassenmodul (englisch Class Module, Dateiendung .cls) ist ein Konzept aus VB6 und VBA (Visual Basic for Applications), in dem eine benutzerdefinierte Klasse mit eigenen Eigenschaften und Methoden definiert wird. Es ist historisch der erste Schritt dieser Sprachen in Richtung objektorientierter Programmierung und darf nicht unreflektiert mit VB.NET-Konstrukten gleichgesetzt werden.

Länger:
In VB6 und VBA wird Code in „Modulen“ organisiert, wobei zwischen Standardmodulen (.bas-Dateien) und Klassenmodulen (.cls-Dateien) unterschieden wird: Standardmodule enthalten globale Prozeduren und Variablen, die projektweit ohne Instanziierung verfügbar sind, während ein Klassenmodul eine Klasse repräsentiert, aus der über Dim ... As New Klassenname konkrete Objektinstanzen mit eigenen, voneinander unabhängigen Datenkopien erzeugt werden. Klassenmodule können anders als Standardmodule mehrfach instanziiert werden, kennen ein Initialize- und ein Terminate-Ereignis und ermöglichen Verkapselung von Eigenschaften und Methoden pro Objekt.

Wichtig ist die korrekte Abgrenzung zu VB.NET: VB.NET besitzt kein Sprachelement, das „Klassenmodul“ heißt. Stattdessen kennt VB.NET zum einen die reguläre Class, die dem VB6/VBA-Klassenmodul am nächsten kommt (objektorientierte Definition mit Instanziierung, Vererbung, Schnittstellen), und zum anderen das eigenständige Konstrukt Module (siehe Eintrag „Module“), das inhaltlich eher dem VB6/VBA-Standardmodul (.bas) bzw. einer C#-static class entspricht und ausdrücklich nicht instanziierbar ist. Eine Gleichsetzung von „Klassenmodul“ mit VB.NET-Module wäre daher fachlich falsch; korrekt ist vielmehr, dass das VB6/VBA-Klassenmodul konzeptionell in der VB.NET-Class fortlebt, während der Name „Modul“ in VB.NET für ein anderes, nicht objektorientiertes Konstrukt reserviert wurde. Diese Unterscheidung wird in einschlägiger Literatur zur Migration von VB6/VBA nach VB.NET ausdrücklich hervorgehoben.

Kompilierung

Synonyme:
Compilation

Kurz:
Kompilierung (auch Umwandlung, englisch Compilation) bezeichnet die Übersetzung von Quellcode einer Programmiersprache durch einen Compiler in eine direkter oder unmittelbarer ausführbare Form, etwa Maschinencode oder Zwischencode.

Länger:
Laut deutscher Wikipedia ist ein Compiler ein Computerprogramm, das Quellcode einer bestimmten Programmiersprache in eine Form übersetzt, die von einem Computer direkt oder zumindest unmittelbarer ausgeführt werden kann; das Ergebnis dieser Übersetzung, der Kompilierung, ist ein mehr oder weniger direkt ausführbares Programm. Die Rückübersetzung von Maschinensprache in Quelltext heißt Dekompilierung. Im .NET-Kontext übersetzen die Compiler für C# (csc, moderner Teil der Roslyn-Plattform) und Visual Basic (vbc) Quellcode in Common Intermediate Language (CIL/IL), die zur Laufzeit von der Common Language Runtime (CLR) weiterverarbeitet, typischerweise per Just-in-Time-Kompilierung in Maschinencode übersetzt wird. Ausgelöst wird die Kompilierung eines .NET-Projekts in der Praxis meist über MSBuild bzw. die CLI-Befehle dotnet build, dotnet run oder dotnet publish, die den passenden Sprachcompiler im Hintergrund aufrufen.

Konsole

Synonyme:
Console

Kurz:
Die Console-Klasse im Namespace System repräsentiert die Standard-Eingabe-, Ausgabe- und Fehlerdatenströme einer Konsolenanwendung und stellt Methoden zum Lesen von und Schreiben in die Konsole bereit.

Länger:
System.Console ist eine NotInheritable- bzw. sealed-Klasse, die grundlegende Unterstützung für Anwendungen bietet, die Zeichen von der Konsole lesen und Zeichen auf die Konsole schreiben. Daten, die von der Konsole gelesen werden, stammen aus dem Standardeingabestrom, während in die Konsole geschriebene Daten in den Standardausgabestrom bzw. bei Fehlermeldungen in den Standardfehlerausgabestrom fließen; die Eigenschaften Console.In, Console.Out und Console.Error stellen entsprechende TextReader- bzw. TextWriter-Objekte bereit. Zu den am häufigsten verwendeten Methoden zählen Console.WriteLine zum Schreiben einer Zeile inklusive Zeilenumbruch sowie Console.ReadLine zum Einlesen einer Zeile Benutzereingabe. Die Klasse wird sowohl in C#- als auch in VB.NET-Programmen identisch verwendet, da sie Teil der gemeinsamen .NET-Klassenbibliothek (BCL) ist.

Konsolenanwendung

Synonyme:
Console Application, Console App

Kurz:
Eine Konsolenanwendung ist ein Anwendungstyp in .NET, der über eine textbasierte Kommandozeilenoberfläche (Konsole) mit Eingabe- und Ausgabeströmen kommuniziert, statt eine grafische Benutzeroberfläche bereitzustellen.

Länger:
Konsolenanwendungen lesen Eingaben typischerweise über die Standardeingabe (etwa über Console.ReadLine) und schreiben Ausgaben über die Standardausgabe (etwa über Console.WriteLine), unter Verwendung der System.Console-Klasse. In Visual Studio wird eine neue Konsolenanwendung über die Projektvorlage „Konsolen-App“ erstellt, wahlweise für C#, F# oder Visual Basic; mit der .NET-CLI erfolgt die Erstellung über den Befehl dotnet new console, das Starten über dotnet run und die Veröffentlichung über dotnet publish. Ein typisches minimales C#-Beispiel enthält eine Main-Methode, während das VB.NET-Äquivalent traditionell eine Sub Main-Prozedur innerhalb eines Module verwendet. Konsolenanwendungen dienen häufig als Einstiegspunkt für Tutorials, Kommandozeilenwerkzeuge und einfache Batch- bzw. Automatisierungsprogramme, da sie ohne UI-Framework auf allen von .NET unterstützten Plattformen lauffähig sind.

Konstante

Synonyme:
Constant, const

Kurz:
Eine Konstante ist ein unveränderlicher Wert, der bereits zur Kompilierzeit bekannt ist und sich während der gesamten Lebensdauer des Programms nicht ändert. In C# werden Konstanten mit dem Modifizierer const deklariert, in VB.NET mit der Const-Anweisung.

Länger:
Konstanten müssen bei ihrer Deklaration initialisiert werden; der Initialisierer muss ein konstanter Ausdruck sein, der vollständig zur Kompilierzeit ausgewertet werden kann. Nur die integrierten C#-Typen dürfen als const deklariert werden – benutzerdefinierte Typen wie Klassen, Strukturen und Arrays können nicht const sein; Referenztyp-Konstanten außer string können nur mit dem Wert null initialisiert werden. Für Felder oder Objekte, die zur Laufzeit einmal initialisiert werden sollen (z. B. im Konstruktor) und danach unveränderlich bleiben, wird stattdessen der readonly-Modifizierer verwendet. Der Compiler ersetzt beim Kompilieren jedes Auftreten eines konstanten Bezeichners direkt durch den literalen Wert im erzeugten IL-Code; da einer Konstante zur Laufzeit keine Speicheradresse zugeordnet ist, können const-Felder nicht per Referenz übergeben werden und nicht als l-Wert (Zuweisungsziel) in einem Ausdruck auftreten. Der Zugriff auf Konstanten erfolgt wie bei statischen Feldern, jedoch ohne das Schlüsselwort static. In VB.NET deklariert die Const-Anweisung eine oder mehrere Konstanten auf Modul- oder Prozedurebene.

Konstruktor

Synonyme:
Constructor

Kurz:
Ein Konstruktor ist eine spezielle Methode, die von der Laufzeit beim Erstellen einer Instanz einer Klasse oder Struktur aufgerufen wird und typischerweise die Datenelemente des neuen Objekts initialisiert.

Länger:
Ein Konstruktor trägt denselben Namen wie sein Typ, besitzt keinen Rückgabetyp und kann einen Zugriffsmodifizierer sowie eine Parameterliste haben; eine Klasse oder Struktur kann mehrere überladene Konstruktoren mit unterschiedlichen Parametern definieren. Ein Konstruktor ohne Parameter heißt parameterloser Konstruktor (auch Standardkonstruktor); stellt eine Klasse keinen expliziten Instanzkonstruktor bereit, generiert der C#-Compiler automatisch einen parameterlosen Konstruktor. Mit den Schlüsselwörtern base bzw. this kann ein Konstruktor den Konstruktor der Basisklasse oder einen anderen Konstruktor derselben Klasse aufrufen; seit C# 12 gibt es zusätzlich primäre Konstruktoren, deren Parameter direkt in der Typdeklaration angegeben werden. Neben Instanzkonstruktoren existieren statische Konstruktoren, die parameterlos sind und automatisch vor dem ersten Zugriff auf statische Member ausgeführt werden, um statische Felder zu initialisieren. In VB.NET wird der Instanzkonstruktor als Sub New implementiert.

L

Lambda Expression

(siehe „Lambda-Ausdruck“)

Lambda-Ausdruck

Synonyme:
Lambda Expression

Kurz:
Ein Lambda-Ausdruck ist eine anonyme Funktion, die mit dem Lambda-Operator => geschrieben wird und zur Erstellung von Delegaten oder Ausdrucksbaumstrukturen (Expression Trees) dient.

Länger:
Ein Lambda-Ausdruck besteht aus Eingabeparametern auf der linken Seite des Operators => und entweder einem einzelnen Ausdruck (Ausdrucks-Lambda, Form (Parameter) => Ausdruck) oder einem in geschweiften Klammern eingeschlossenen Anweisungsblock (Anweisungs-Lambda, Form (Parameter) => { Anweisungen }) auf der rechten Seite. Lambda-Ausdrücke sind besonders für das Schreiben von LINQ-Abfrageausdrücken hilfreich, da sie kompakt Filter-, Projektions- oder Vergleichslogik direkt an Methoden wie Where oder Select übergeben können; sie erfassen zudem Variablen aus dem umgebenden Gültigkeitsbereich (Closures). Anders als anonyme Methoden können Lambda-Ausdrücke vom Compiler sowohl in eine Delegat-Instanz als auch – wenn der Zieltyp Expression<TDelegate> lautet – in eine Ausdrucksbaumstruktur übersetzt werden, was etwa von Entity Framework zur Übersetzung von Abfragen in SQL genutzt wird. Seit C# 9 können Lambda-Ausdrücke außerdem mit dem Modifizierer static versehen werden, um das Erfassen von Zustand aus dem umschließenden Bereich zu verhindern.

Language-Integrated Query

Synonyme:
LINQ

Kurz:
Language-Integrated Query (LINQ) ist eine Menge von Sprach- und Bibliothekserweiterungen für C# und VB.NET, mit denen Abfragen auf Datenquellen wie Auflistungen, XML oder Datenbanken direkt in der Programmiersprache formuliert werden können. LINQ ermöglicht deklarativen, ausdrucksstarken Code anstelle manueller Schleifen.

Länger:
LINQ integriert Abfragefähigkeiten unmittelbar in C# und VB.NET, sodass Entwickler Abfragen entweder in Query-Syntax (ähnlich SQL, z. B. from … where … select …) oder in Methodensyntax (Erweiterungsmethoden wie Where, Select, OrderBy auf IEnumerable<T>) schreiben können. Eine LINQ-Abfrage besteht aus drei Schritten: dem Abrufen der Datenquelle, der Definition der Abfrage und deren Ausführung – wobei viele LINQ-Operatoren erst bei der Iteration (z. B. durch foreach oder ToList()) tatsächlich ausgewertet werden (verzögerte Ausführung). „LINQ to Objects“ bezeichnet die Verwendung von LINQ direkt auf IEnumerable<T>-Sammlungen wie List<T> oder Arrays; daneben existieren Varianten wie LINQ to XML oder, über IQueryable<T>, LINQ to Entities (Entity Framework), bei dem Abfragen in Ausdrucksbäume übersetzt und z. B. in SQL umgewandelt werden. Der Compiler übersetzt IEnumerable<T>-Abfragen zu Delegataufrufen, IQueryable<T>-Abfragen dagegen zu Ausdrucksbäumen, die von einem Abfrageanbieter interpretiert werden.

Laufzeitumgebung

Synonyme:
Runtime

Kurz:
Eine Laufzeitumgebung (englisch runtime environment) beschreibt die zur Laufzeit von Computerprogrammen verfügbaren und festgelegten Voraussetzungen eines Laufzeitsystems. Im .NET-Kontext ist damit meist die Common Language Runtime bzw. – bei modernem .NET – CoreCLR gemeint, welche verwalteten Code ausführt.

Länger:
Die .NET-Laufzeitumgebung ist das Bindeglied zwischen der Zielmaschine und einer .NET-Anwendung: Sobald eine Anwendung startet, wird sie automatisch initialisiert und übernimmt danach zentrale Aufgaben wie das Laden und Verwalten von Intermediate-Language-Code, Speicherverwaltung samt Garbage Collection, Thread-Management, Sicherheitsprüfungen sowie Typ- und Codeverifikation über das Common Type System. Bei klassischen .NET-Framework-Anwendungen heißt diese Laufzeit „Common Language Runtime“ (CLR); moderne .NET-Anwendungen (ehemals .NET Core) verwenden die quelloffene, plattformübergreifende Implementierung CoreCLR. Zu unterscheiden ist die Laufzeitumgebung, die zum Ausführen bereits kompilierter Anwendungen ausreicht, vom umfangreicheren .NET SDK, das zusätzlich Compiler und Entwicklungswerkzeuge enthält; für Produktionsserver wird häufig nur die passende Laufzeitumgebung installiert.

LINQ

(siehe „Language-Integrated Query“)

Literal

Synonyme:
—

Kurz:
Ein Literal ist ein konstanter, unveränderlicher Wert, der direkt im Quellcode angegeben wird, etwa eine Zahl, ein Zeichen, eine Zeichenfolge oder ein boolescher Wert. Literale sind die einfachsten C#-Ausdrücke und haben stets einen impliziten Typ.

Länger:
Literale repräsentieren feste Werte, die direkt in den Quellcode geschrieben werden, statt zur Laufzeit berechnet zu werden – Beispiele sind 42 (ein int-Literal), 3.14 (ein double-Literal), 'A' (ein char-Literal), "Hallo" (ein string-Literal) oder true/false (boolesche Literale). Jedes Literal hat implizit einen zugeordneten Datentyp, der sich aus seiner Schreibweise ergibt; durch Suffixe lässt sich dieser bei numerischen Literalen anpassen, etwa L für long, f für float, d für double oder m für decimal. C# unterstützt außerdem spezielle Literalformen wie wortgetreue Zeichenfolgenliterale mit vorangestelltem @-Zeichen (@"C:\Pfad"), rohe Zeichenfolgenliterale ("""...""") sowie das null-Literal für Referenztypen. Im Rahmen der C#-Sprachspezifikation zählen Literalausdrücke zu den einfachsten primären Ausdrücken, aus denen komplexere Ausdrücke zusammengesetzt werden. Ein Literalwert wird typischerweise verwendet, um eine Variable zu initialisieren oder einer Konstante einen festen Wert zuzuweisen.

Logging

Synonyme:
Protokollierung

Kurz:
Logging (Protokollierung) bezeichnet das systematische Aufzeichnen von Ereignissen, Zuständen und Diagnoseinformationen einer Anwendung während ihrer Ausführung, um das Anwendungsverhalten zu überwachen und Probleme zu diagnostizieren.

Länger:
.NET unterstützt leistungsstarke, strukturierte Protokollierung über die ILogger-API. Zum Erzeugen von Protokollen wird typischerweise ein ILogger<TCategoryName>-Objekt per Dependency Injection bezogen; die ILoggerFactory verwaltet dabei die Konfiguration, die festlegt, wohin Protokollmeldungen gesendet werden. Über die ILoggingBuilder-API lässt sich Logging im Code konfigurieren, etwa beim direkten Erstellen einer ILoggerFactory, bei Verwendung von Dependency Injection ohne Host oder über hostspezifische APIs wie WebApplicationBuilder.Logging. Für Anwendungen, die einen Host verwenden, wird die Protokollierungskonfiguration üblicherweise im Abschnitt "Logging" der appsettings.{Environment}.json-Dateien festgelegt. Neben grundlegenden, integrierten Protokollierungsanbietern (z. B. Konsole, Debug) stehen zahlreiche Drittanbieter-Provider zur Verfügung; die älteren APIs System.Diagnostics.Trace und System.Diagnostics.Debug gelten als Vorläufer der heutigen ILogger-Infrastruktur, die für die meisten Fälle die empfohlene Standardwahl ist.

M

Managed Code

Synonyme:
Verwalteter Code

Kurz:
Managed Code (verwalteter Code) ist Code, dessen Ausführung von einer Laufzeitumgebung – der Common Language Runtime (CLR) – verwaltet wird, unabhängig davon, ob es sich um .NET Framework, .NET Core/.NET oder Mono handelt. Die CLR kompiliert den Code in Maschinencode und übernimmt dabei zusätzliche Dienste wie automatische Speicherverwaltung und Typsicherheit.

Länger:
Wird Quellcode in einer .NET-Sprache wie C#, VB.NET oder F# kompiliert, entsteht zunächst Common Intermediate Language (CIL)-Code; dieser wird zur Laufzeit von der CLR – meist per Just-in-Time-Kompilierung – in nativen Code übersetzt und ausgeführt. Während dieser Ausführung stellt die Laufzeit Dienste wie automatische Garbage Collection, Sicherheitsgrenzen, Ausnahmebehandlung und Typüberprüfung bereit, um die der Entwickler sich bei rein nativer Programmierung selbst kümmern müsste. Der Gegenbegriff ist „Unmanaged Code“ (nicht verwalteter Code), etwa klassisches C/C++, das direkt vom Betriebssystem geladen wird, ohne dass eine Laufzeit die Ressourcenverwaltung übernimmt. Managed und Unmanaged Code können über Interoperabilitätsmechanismen wie P/Invoke oder COM-Interop miteinander kommunizieren, wobei beim Überschreiten dieser Grenze besondere Sorgfalt bezüglich Sicherheit und Speicherverwaltung erforderlich ist.

Member

Synonyme:
Mitglied, Klassenmitglied

Kurz:
Ein Member (Mitglied) ist ein allgemeiner Oberbegriff für jedes Element, das eine Klasse oder Struktur enthalten kann, etwa Felder, Eigenschaften, Methoden, Ereignisse, Konstruktoren oder Finalizer.

Länger:
Die Member einer Klasse umfassen sowohl alle in der Klasse selbst deklarierten Elemente als auch alle geerbten Member der Basisklassen in der Vererbungshierarchie (mit Ausnahme von Konstruktoren und Finalizern, die nicht vererbt werden); private Member einer Basisklasse werden zwar geerbt, sind aber von abgeleiteten Klassen aus nicht zugänglich. Zu den Membertypen zählen laut Microsoft-Dokumentation unter anderem Felder, Konstanten, Eigenschaften, Methoden, Ereignisse, überladene Operatoren, Indexer, Konstruktoren und Finalizer; nach der C#-Sprachspezifikation werden Member zusätzlich in Datenmember (Konstanten, Felder) und Funktionsmember (Methoden, Eigenschaften, Ereignisse, Indexer, Operatoren, Konstruktoren, Finalizer) sowie in statische Member und Instanzmember unterschieden. Der zusammenfassende Begriff „Klassenmember“ wird in der Microsoft-Dokumentation oft synonym zu „Member“ verwendet.

Method

(siehe „Methode“)

Methode

Synonyme:
Method

Kurz:
Eine Methode ist ein benannter Codeblock innerhalb einer Klasse oder Struktur, der eine Reihe von Anweisungen enthält und über seinen Namen sowie eine Parameterliste aufgerufen wird.

Länger:
In C# wird jede ausgeführte Anweisung im Kontext einer Methode ausgeführt; die Main-Methode ist typischerweise der Einstiegspunkt einer Konsolenanwendung und wird von der Common Language Runtime (CLR) beim Start des Programms aufgerufen. Eine Methode wird durch Rückgabewert (oder void, falls keiner vorhanden ist), Namen und optionale Parameter definiert; der Aufruf einer Instanzmethode erfolgt über den Objektnamen, gefolgt von einem Punkt, dem Methodennamen und runden Klammern mit den Argumenten, während statische Methoden über den Typnamen aufgerufen werden. Methoden können überladen werden (mehrere Methoden gleichen Namens mit unterschiedlicher Parameterliste), und C# unterstützt zusätzlich lokale Funktionen, die innerhalb einer anderen Methode deklariert werden. In VB.NET entspricht der Methode meist eine Sub- (ohne Rückgabewert) oder Function-Prozedur (mit Rückgabewert).

Microsoft Intermediate Language

(siehe „Common Intermediate Language“)

Middleware

Synonyme:
—

Kurz:
Middleware bezeichnet in ASP.NET Core Softwarekomponenten, die zu einer Anwendungspipeline zusammengesetzt werden, um HTTP-Anforderungen und -Antworten zu verarbeiten. Jede Middleware-Komponente kann Arbeit vor und nach dem Aufruf der nächsten Komponente in der Pipeline ausführen oder die Pipeline vorzeitig beenden.

Länger:
Die ASP.NET-Core-Anforderungspipeline besteht aus einer Sequenz von Anforderungsdelegaten (Request Delegates), die nacheinander aufgerufen werden. Middleware wird über die Erweiterungsmethoden Use, Map und Run konfiguriert; sie kann entweder als anonyme Inline-Methode oder als eigenständige, wiederverwendbare Klasse definiert werden, die üblicherweise über eine Erweiterungsmethode auf IApplicationBuilder verfügbar gemacht wird. Eine benutzerdefinierte Middleware-Klasse benötigt typischerweise einen öffentlichen Konstruktor mit einem RequestDelegate-Parameter sowie eine öffentliche Invoke- oder InvokeAsync-Methode, die einen HttpContext entgegennimmt. Middleware, die die Pipeline nicht an die nächste Komponente weitergibt, wird als „Terminal Middleware“ bezeichnet, da sie die weitere Verarbeitung durch nachfolgende Middleware verhindert. ASP.NET Core liefert eine Reihe integrierter Middleware-Komponenten (z. B. für Routing, Authentifizierung, Statische Dateien, Ausnahmebehandlung), erlaubt aber ebenso das Schreiben eigener Middleware, etwa für Logging oder benutzerdefinierte Header-Verarbeitung. Middleware kann ihre Abhängigkeiten über Dependency Injection im Konstruktor beziehen.

Migration (EF Core)

Synonyme:
Datenbankmigration

Kurz:
Migrationen sind ein Feature von EF Core, mit dem das Datenbankschema inkrementell aktualisiert werden kann, um es mit dem Datenmodell der Anwendung synchron zu halten, während vorhandene Daten in der Datenbank erhalten bleiben.

Länger:
Wenn eine Änderung am Datenmodell vorgenommen wird, nutzt der Entwickler die EF-Core-Tools, um eine entsprechende Migration hinzuzufügen, z. B. mit dem Befehl dotnet ef migrations add <Name> (bzw. in der Visual-Studio-Package-Manager-Console Add-Migration <Name>). EF Core vergleicht dabei das aktuelle Modell mit einer Momentaufnahme (Snapshot) des vorherigen Modells, ermittelt die Unterschiede und generiert Migrationsquelldateien, die wie normale Quelldateien in der Versionskontrolle verwaltet werden können; dabei entstehen typischerweise eine Hauptdatei mit den Vorgängen für Up (Anwenden) und Down (Rückgängigmachen), eine zugehörige Designer-Datei und eine aktualisierte Modell-Snapshot-Datei. Eine erzeugte Migration wird anschließend mit dotnet ef database update (bzw. Update-Database) auf eine Datenbank angewendet; EF Core protokolliert alle angewendeten Migrationen in einer speziellen Verlaufstabelle (z. B. __EFMigrationsHistory), sodass jederzeit nachvollziehbar ist, welche Migrationen bereits ausgeführt wurden. Migrationen können auch programmgesteuert über context.Database.MigrateAsync() angewendet oder zu ausführbaren Migrationsbündeln zusammengefasst werden.

Mitglied

(siehe „Member“)

Model-View-Controller

Synonyme:
MVC

Kurz:
Model-View-Controller (MVC) ist ein Architekturmuster, das eine Anwendung in die drei Komponentengruppen Modell (Daten), Ansicht (Darstellung) und Controller (Steuerungslogik) unterteilt. In .NET wird es insbesondere durch das Framework ASP.NET Core MVC zum Erstellen von Webanwendungen und APIs umgesetzt.

Länger:
Das Modell repräsentiert die Daten und die Geschäftslogik einer Anwendung, die Ansicht (View) ist für die Darstellung dieser Daten gegenüber dem Benutzer zuständig, und der Controller nimmt Benutzereingaben entgegen, steuert den Ablauf und aktualisiert Modell und Ansicht entsprechend. Diese Trennung der Belange (Separation of Concerns) erleichtert Testbarkeit, Wartbarkeit und parallele Entwicklung der einzelnen Schichten. ASP.NET Core MVC ist ein leichtgewichtiges, quelloffenes und gut testbares Präsentationsframework, das Controller-Klassen mit Aktionsmethoden (Actions) bereitstellt, die Anfragen über Routing empfangen, Daten aus Modellen zusammenstellen und Razor-Views zur Darstellung von HTML zurückgeben. MVC in .NET unterscheidet sich von Ansätzen wie Razor Pages, die stärker seiten- statt controllerorientiert arbeiten, verfolgt aber dasselbe grundlegende Trennungsprinzip. Historisch stammt das MVC-Muster ursprünglich aus dem Smalltalk-Umfeld der späten 1970er Jahre und wurde seither in zahlreichen UI- und Web-Frameworks unterschiedlicher Sprachen adaptiert.

Model-View-ViewModel

Synonyme:
MVVM

Kurz:
Model-View-ViewModel (MVVM) ist ein Entwurfsmuster und eine Variante von MVC, das die Geschäfts- und Präsentationslogik einer Anwendung klar von der Benutzeroberfläche trennt. Es besteht aus den drei Komponenten Model, View und ViewModel und wird typischerweise mit Datenbindung realisiert.

Länger:
Im MVVM-Muster kapselt das Model die Geschäftslogik und die Daten der Anwendung, die View kapselt die Benutzeroberfläche samt UI-Logik, und das ViewModel bildet die Präsentationslogik und den Zustand ab: Es tauscht Informationen mit dem Model aus und stellt der View über Eigenschaften und Befehle (Commands) Daten und Interaktionsmöglichkeiten bereit. Die Kopplung zwischen View und ViewModel erfolgt über einen Datenbindungsmechanismus statt über direkten Code-Zugriff, wodurch die View weitgehend austauschbar bleibt und wenig bis kein Code-Behind benötigt. MVVM ist die Standardimplementierung für UI-Plattformen wie die Windows Presentation Foundation (WPF) und .NET MAUI und wird in .NET häufig zusammen mit Dependency Injection kombiniert, etwa über das CommunityToolkit.Mvvm-Paket, um Dienste in ViewModels zu injizieren. In Bezug auf WPF/XAML bedeutet MVVM konkret, dass die View aus deklarativem XAML-Markup besteht, das über Bindungen an Eigenschaften des ViewModels gekoppelt ist, während die eigentliche Logik in C# oder VB.NET implementiert wird.

Modul (VB.NET)

(siehe „Module“)

Module

Synonyme:
Modul (VB.NET)

Kurz:
Die Module-Anweisung deklariert in VB.NET einen Modulnamen und definiert einen Container für Variablen, Eigenschaften, Ereignisse und Prozeduren, der – anders als eine Klasse – nicht instanziiert werden kann.

Länger:
Ein VB.NET-Modul (Syntax: [accessmodifier] Module name ... End Module) ist ein eigener Referenztyp, der nur auf Namespace-Ebene deklariert werden darf, also nicht innerhalb einer Klasse, Struktur oder eines anderen Moduls. Alle Member eines Moduls sind implizit Shared; ein Modul kann nicht instanziiert, nicht vererbt werden und implementiert keine Schnittstellen. Damit dient es primär zur Organisation von Hilfsfunktionen, Erweiterungsmethoden und globalen, projektweit gültigen Daten, auf die ohne vorherige Instanziierung über den Modulnamen zugegriffen werden kann. Der nächste C#-Verwandte ist die static class; funktional sind Module und statische Klassen auf IL-Ebene weitgehend gleichwertig, syntaktisch dürfen Module jedoch nicht verschachtelt werden, während statische Klassen dies können. Wichtig: Ein VB.NET-Module ist nicht mit dem historischen VB6/VBA-„Klassenmodul“ zu verwechseln (siehe den Eintrag „Klassenmodul“) – das VB6/VBA-Standardmodul (.bas-Datei) ist der eigentliche begriffliche Vorgänger des VB.NET-Module, während das VB6/VBA-Klassenmodul (.cls-Datei) dem heutigen VB.NET-Class-Konstrukt entspricht.

MSBuild

Synonyme:
—

Kurz:
MSBuild, auch Microsoft Build Engine genannt, ist die von Microsoft entwickelte Build-Plattform, mit der die meisten Visual-Studio-Projekte, einschließlich .NET- und C++-Projekten, erstellt werden.

Länger:
MSBuild interpretiert und verarbeitet den Text von XML-basierten Projektdateien (Evaluation) und führt anschließend die darin definierten Ziele (Targets) und Aufgaben (Tasks) aus (Execution), um Compiler und andere Werkzeuge aufzurufen. Neben reinem Kompilieren bietet MSBuild flexible Konfigurations- und Anpassungsmöglichkeiten sowie eine Infrastruktur zur Erzeugung unterschiedlichster Ausgabeartefakte, nicht nur kompilierter Binärdateien. Der vollständige Buildprozess besteht aus dem initialen Start (Verarbeitung der Befehlszeilenoptionen), der Auswertung (Interpretation der Projektdatei) und der Ausführung (Ausführen der Ziele und Aufgaben). Der .NET-CLI-Befehl dotnet build ruft MSBuild im Hintergrund auf und ist in seiner Standardausführung mit dotnet msbuild -restore vergleichbar. MSBuild-Eigenschaften wie Configuration oder Platform werden häufig genutzt, um Buildkonfigurationen wie Debug und Release zu steuern.

MSIL

(siehe „Common Intermediate Language“)

Musterabgleich

(siehe „Pattern Matching“)

MustInherit

Synonyme:
—

Kurz:
MustInherit ist ein VB.NET-Modifizierer für Klassen, der angibt, dass eine Klasse nur als Basisklasse dienen kann und nicht direkt instanziiert werden darf; die Entsprechung in C# ist der Modifizierer abstract auf Klassenebene.

Länger:
Eine mit MustInherit deklarierte Klasse – auch als abstrakte Klasse bezeichnet – definiert Funktionalität, die allen von ihr abgeleiteten Klassen gemeinsam ist, sodass abgeleitete Klassen diese gemeinsamen Elemente nicht neu definieren müssen. Reicht die gemeinsame Funktionalität nicht aus, um ein direkt verwendbares Objekt zu erzeugen, kann jede abgeleitete Klasse die fehlende Funktionalität selbst ergänzen; in diesem Fall stellt MustInherit sicher, dass Objekte ausschließlich aus den abgeleiteten Klassen erzeugt werden können. MustInherit kann nur bei einer Class-Anweisung angegeben werden und darf nicht zusammen mit NotInheritable in derselben Deklaration verwendet werden. Methoden oder Eigenschaften ohne Implementierung, die von abgeleiteten Klassen überschrieben werden müssen, werden in einer MustInherit-Klasse mit dem Modifizierer MustOverride gekennzeichnet. Das .NET Framework definiert selbst mehrere MustInherit-Klassen, darunter Array, Enum und ValueType. In C# entspricht MustInherit dem Klassenmodifizierer abstract, wobei die zugehörigen abstrakten Methoden dort mit abstract statt MustOverride markiert werden.

MVC

(siehe „Model-View-Controller“)

MVVM

(siehe „Model-View-ViewModel“)

N

Namensraum

(siehe „Namespace“)

`nameof`

Synonyme:
—

Kurz:
Der nameof-Operator erzeugt den textuellen Namen eines Symbols – etwa einer Variablen, eines Typs, eines Members oder eines Namespaces – als Zeichenfolgenkonstante zur Kompilierzeit.

Länger:
Ein nameof-Ausdruck wird bereits zur Kompilierzeit ausgewertet und hat zur Laufzeit keine Auswirkung bzw. keine zusätzlichen Kosten; ist der Operand ein Typ oder ein Namespace, ist der erzeugte Name nicht vollqualifiziert, sondern entspricht nur dem letzten Bezeichner im Operanden. nameof wird typischerweise verwendet, um Zeichenfolgen, die auf Codesymbole verweisen, robust gegenüber Umbenennungen (Refactoring) zu machen, etwa beim Werfen einer ArgumentNullException mit dem Parameternamen, bei der Implementierung von INotifyPropertyChanged oder in Log-Ausgaben, in denen bislang der Name als fest codierte Zeichenfolge angegeben werden musste. Der Operator wurde mit C# 6 eingeführt und ist ein reiner Compilerkonstrukt ohne Laufzeitrepräsentation.

Namespace

Synonyme:
Namensraum

Kurz:
Ein Namespace (Namensraum) gruppiert verwandte Typen zusammen und verhindert Namenskonflikte zwischen ihnen; jeder .NET-Typ gehört zu einem Namespace.

Länger:
Eine Namespace-Deklaration weist Typen einer benannten Gruppe zu und organisiert sie in einer hierarchischen Struktur; die Hierarchieebenen werden dabei durch den .-Operator ausgedrückt, wie in System.Collections.Generic. Namespaces dienen zugleich als „interne“ Organisation eines Programms und als „externe“ Darstellung der Programmelemente gegenüber anderen Programmen. In C# gibt es zwei Syntaxformen: die block-scoped Syntax (mit geschweiften Klammern, geeignet wenn mehrere Namespaces in einer Datei deklariert werden) und die seit C# 10 verfügbare file-scoped Syntax (mit Semikolon, ohne zusätzliche Klammern, wenn alle Typen der Datei zum selben Namespace gehören). Mit einer using-Direktive (in C#) bzw. einer Imports-Anweisung (in VB.NET) können die in einem Namespace enthaltenen Typen unter ihrem einfachen Namen verwendet werden, ohne den vollqualifizierten Namespace-Pfad angeben zu müssen.

Namespace-Import

Synonyme:
Imports (VB.NET), using-Direktive (C#)

Kurz:
Ein Namespace-Import ermöglicht es, Typen aus einem Namespace unter ihrem einfachen Namen zu verwenden, ohne den vollqualifizierten Namespace-Pfad anzugeben; in C# geschieht dies über die using-Direktive, in VB.NET über die Imports-Anweisung.

Länger:
In C# importiert die using-Direktive in ihrer Grundform alle Typen aus einem angegebenen Namespace in die aktuelle Datei, z. B. using System.Text;. Zusätzlich existieren die Modifizierer static (importiert die statischen Member und geschachtelten Typen eines einzelnen Typs, sodass diese ohne Angabe des Typnamens verwendbar sind) und global (wendet die Direktive projektweit an, siehe „Globale using-Anweisung“); außerdem lässt sich über eine using-Alias-Direktive ein alternativer Name für einen Namespace oder Typ definieren. In VB.NET übernimmt die Imports-Anweisung dieselbe Rolle: Sie erlaubt den Verweis auf Typnamen ohne Qualifizierung durch einen Namespace, in der Form Imports [aliasname =] namespace bzw. Imports [aliasname =] namespace.element. Wichtig ist die begriffliche Abgrenzung zur using-Anweisung bzw. using-Deklaration in C#, die eine völlig andere Bedeutung hat: Diese dient nicht dem Import von Namespaces, sondern der deterministischen Freigabe von IDisposable-Objekten (siehe die separaten Einträge „using-Anweisung (Statement)“ und „Using-Deklaration“).

Native AOT

Synonyme:
—

Kurz:
Native AOT ist ein Bereitstellungsmodell von modernem .NET, bei dem eine Anwendung bereits zur Veröffentlichungszeit vollständig in nativen Maschinencode kompiliert wird, statt zur Laufzeit einen Just-in-Time-Compiler zu verwenden. Das Ergebnis ist eine eigenständige, ausführbare Datei mit schnellerer Startzeit und kleinerem Speicherbedarf, die ohne installierte .NET-Laufzeit lauffähig ist.

Länger:
Native AOT wird über die Projekteinstellung <PublishAot>true</PublishAot> aktiviert und mit dotnet publish -r <RID> für eine bestimmte Laufzeitkennung (Runtime Identifier), etwa „win-x64“ oder „linux-arm64“, veröffentlicht. Da der resultierende Code keinen Just-in-Time-Compiler zur Laufzeit benötigt, eignet sich Native AOT besonders für Umgebungen, in denen JIT-Kompilierung nicht erlaubt oder Startzeit kritisch ist, etwa Cloud-Funktionen oder Microservices. Erstmals in .NET 7 (2022) verfügbar – zunächst nur für Konsolenanwendungen –, wurde die Unterstützung mit .NET 8 auf Hintergrunddienste, gRPC-Dienste und eingeschränkt auch Minimal-Web-APIs erweitert. Native AOT bringt jedoch Einschränkungen mit sich: Laufzeitcodegenerierung (z. B. Reflection Emit), dynamisches Nachladen von Assemblies, COM- und WinRT-Zugriffe sowie C++/CLI werden nicht unterstützt, und Windows Forms bzw. WPF können bislang nicht als Native AOT veröffentlicht werden. Native AOT ist von „ReadyToRun“ (R2R) zu unterscheiden, einer anderen AOT-Technik, die zusätzlich zum vorkompilierten nativen Code weiterhin IL-Code enthält und primär die Startzeit verbessert, ohne den JIT vollständig zu ersetzen.

Nested Class

(siehe „Geschachtelte Klasse“)

.NET

Synonyme:
—

Kurz:
.NET ist eine kostenlose, plattformübergreifende Open-Source-Entwicklerplattform von Microsoft zum Erstellen unterschiedlichster Anwendungstypen (Web, Mobile, Desktop, Cloud, IoT, Spiele u. a.). Seit .NET 5 (November 2020) bezeichnet der Name „.NET“ die moderne, aus .NET Core hervorgegangene, vereinheitlichte Implementierung – nicht mehr das ältere, Windows-only ".NET Framework".

Länger:
.NET besteht aus mehreren Bestandteilen: einer Laufzeitumgebung (Common Language Runtime bzw. bei modernem .NET CoreCLR), Klassenbibliotheken sowie Compilern und Werkzeugen (im .NET SDK gebündelt), mit denen Programme in Sprachen wie C#, F# oder Visual Basic entwickelt werden. Historisch gab es mehrere Implementierungen von .NET: das ursprüngliche, Windows-only .NET Framework (ab 2002), das plattformübergreifende, quelloffene .NET Core (ab 2016) sowie Mono/Xamarin. Mit .NET 5 im November 2020 hat Microsoft diese Implementierungen zu einer einzigen Plattform vereinheitlicht und den Namenszusatz „Core“ fallen gelassen; seither erscheint jährlich im November eine neue Hauptversion, wobei geradzahlige Versionen (z. B. .NET 6, 8, 10) als Long-Term-Support-Releases (LTS) mit drei Jahren Support gelten. .NET läuft unter Windows, Linux und macOS, ist auf GitHub als Open Source verfügbar und wird u. a. für ASP.NET Core, Entity Framework Core, Blazor, Windows Forms, WPF und MAUI verwendet.

.NET CLI

Synonyme:
dotnet-Befehl, dotnet-Kommandozeilenschnittstelle

Kurz:
Die .NET-Befehlszeilenschnittstelle (.NET CLI) ist eine plattformübergreifende Toolchain zum Entwickeln, Erstellen, Ausführen und Veröffentlichen von .NET-Anwendungen und wird über den dotnet-Befehl aufgerufen. Sie ist Bestandteil des .NET SDK.

Länger:
Nach der Installation des .NET SDK kann die .NET CLI in einem Terminal über den generischen dotnet-Treiber genutzt werden, etwa mit Befehlen wie dotnet new (Projektvorlage erstellen), dotnet build (kompilieren), dotnet run (ausführen) oder dotnet publish (veröffentlichen). Der dotnet-Befehl hat dabei zwei grundlegende Funktionen: Er stellt SDK-Befehle für die Arbeit mit .NET-Projekten bereit, und er dient als generischer Treiber zum Starten von .NET-Anwendungen bzw. installierten .NET-Tools. Die CLI ist Editor-unabhängig und funktioniert identisch unter Windows, Linux und macOS, wodurch sie sich für Automatisierung, CI/CD-Pipelines und den Einsatz ohne integrierte Entwicklungsumgebung eignet.

.NET Core

Synonyme:
—

Kurz:
.NET Core war Microsofts plattformübergreifende, quelloffene Neuentwicklung von .NET, die erstmals am 27. Juni 2016 als Version 1.0 erschien und unter Windows, Linux und macOS lief. Mit der Version .NET 5 (November 2020) wurde .NET Core in „.NET“ umbenannt und mit .NET Framework, Mono und Xamarin zu einer gemeinsamen Plattform vereinheitlicht.

Länger:
.NET Core entstand als Antwort auf den Bedarf an einer modularen, plattformunabhängigen und Cloud-tauglichen Alternative zum Windows-only .NET Framework; Version 1.0 wurde am 27. Juni 2016 veröffentlicht. Wichtige spätere Versionen waren .NET Core 2.0 (2017), 2.1 LTS (2018), 3.0 (2019) und 3.1 LTS (Dezember 2019) – letztere brachte u. a. Unterstützung für Windows-Desktopanwendungen (WPF, Windows Forms) unter Windows sowie erste Ahead-of-Time-Kompilierungsfunktionen. Anstatt eine Version 4.0 zu veröffentlichen (was mit der Versionsnummerierung des .NET Framework kollidiert hätte), sprang Microsoft direkt zu „.NET 5“ und ließ dabei den Namenszusatz „Core“ fallen; seitdem wird die Plattform schlicht „.NET“ genannt und nicht mehr als eigenständiges „.NET Core“ weitergeführt. .NET Core basierte technisch auf der CoreCLR-Laufzeit und CoreFX-Bibliotheken, die die Grundlage für das heutige, vereinheitlichte .NET bilden.

.NET Framework

Synonyme:
—

Kurz:
Das .NET Framework ist Microsofts ursprüngliche, Windows-only-Softwareentwicklungsplattform zur Erstellung und Ausführung von Windows-Anwendungen und Webdiensten; die erste Version erschien am 13. Februar 2002. Es besteht im Kern aus der Common Language Runtime (CLR) und der .NET Framework-Klassenbibliothek.

Länger:
Das .NET Framework wurde am 13. Februar 2002 mit Version 1.0 veröffentlicht und über die Jahre bis Version 4.8 (April 2019) bzw. 4.8.1 (August 2022) weiterentwickelt; 4.8 gilt als letzte große Version, da Microsoft neue Funktionen seither ausschließlich in das plattformübergreifende, quelloffene Nachfolgeprojekt .NET Core bzw. spätere .NET-Versionen einbringt. Anders als moderne .NET-Versionen läuft das .NET Framework nur unter Windows und wird bei bestehenden Windows-Betriebssystemen als Komponente mitgeliefert bzw. weiterhin mit Sicherheitsupdates versorgt, erhält jedoch keine neuen Features mehr. Die CLR verwaltet Speicher, Threads, Codeausführung, Sicherheitsüberprüfungen sowie Kompilierung, und darauf aufbauend stellt die Klassenbibliothek Basisfunktionalität für Anwendungen wie Windows Forms, WPF oder ASP.NET (Non-Core) bereit.

.NET Runtime

Synonyme:
—

Kurz:
Die .NET Runtime ist die Laufzeitumgebung, die kompilierte .NET-Anwendungen tatsächlich ausführt; sie enthält u. a. die Common Language Runtime (bzw. CoreCLR), Basisbibliotheken und den Just-in-Time-Compiler. Im Gegensatz zum .NET SDK enthält sie keine Entwicklungswerkzeuge wie Compiler oder die vollständige CLI.

Länger:
Auf Windows, Linux und macOS existieren mehrere spezialisierte .NET-Runtimes: die grundlegende „.NET Runtime“ für Konsolenanwendungen, die „ASP.NET Core Runtime“ für Webanwendungen sowie – nur unter Windows – die „.NET Desktop Runtime“ für WPF- und Windows-Forms-Anwendungen. Alle drei Runtimes sind im .NET SDK enthalten, sodass Entwickler beim Installieren des SDK automatisch auch die passenden Runtimes erhalten; wer eine Anwendung nur ausführen, nicht aber entwickeln möchte, kann sich auf die Installation der jeweils benötigten Runtime beschränken, was Installationsgröße und Angriffsfläche reduziert. Zur Laufzeit übernimmt die Runtime u. a. das Laden von Assemblies, die Speicherverwaltung samt automatischer Garbage Collection, Typsicherheit sowie – sofern kein Native-AOT-Kompilat vorliegt – die Just-in-Time-Kompilierung des Intermediate-Language-Codes in nativen Maschinencode.

.NET SDK

Synonyme:
—

Kurz:
Das .NET SDK (Software Development Kit) ist eine Sammlung von Bibliotheken und Werkzeugen, die Entwickler zum Erstellen von .NET-Anwendungen und -Bibliotheken benötigen. Es enthält u. a. die .NET-CLI, die .NET-Runtime und -Bibliotheken sowie den dotnet-Treiber.

Länger:
Das .NET SDK umfasst alles, was zum Entwickeln, Kompilieren, Testen und Veröffentlichen von .NET-Anwendungen erforderlich ist: Compiler für C#, F# und Visual Basic, MSBuild, Projektvorlagen, die .NET-Befehlszeilenschnittstelle (CLI) sowie mindestens eine passende .NET-Runtime. Auf Entwicklungsrechnern wird üblicherweise das SDK installiert, da es zusätzlich zur reinen Ausführung von Anwendungen auch das Erstellen neuer Projekte, das Kompilieren und das Veröffentlichen ermöglicht; auf Produktions- oder Server-Systemen reicht dagegen meist die kleinere Laufzeitumgebung (.NET Runtime) aus, um bereits kompilierte Anwendungen auszuführen. Die Versionsnummer des .NET SDK folgt nicht direkt der semantischen Versionierung der zugehörigen Runtime: Die ersten beiden Stellen entsprechen der Runtime-Version, mit der das SDK ausgeliefert wurde, während die dritte Stelle SDK-eigene Minor- und Patch-Versionen codiert.

.NET Standard

Synonyme:
—

Kurz:
.NET Standard ist eine formale Spezifikation von .NET-APIs, die in allen .NET-Implementierungen (u. a. .NET Framework, .NET Core/.NET, Mono, Xamarin) verfügbar sein müssen, um Code zwischen ihnen portabel zu halten. Seit der Vereinheitlichung durch .NET 5 (2020) werden keine neuen .NET-Standard-Versionen mehr veröffentlicht; die letzte Version ist 2.1.

Länger:
.NET Standard wurde eingeführt, um das Problem zu lösen, dass Klassenbibliotheken vor der Vereinheitlichung nur für eine bestimmte .NET-Implementierung (z. B. nur .NET Framework oder nur .NET Core) kompiliert werden konnten; eine Bibliothek, die eine bestimmte .NET-Standard-Version referenziert, kann auf jeder Implementierung ausgeführt werden, die diese Version (oder höher) unterstützt. Die Versionen reichten von 1.0 bis 2.1; .NET Standard 2.0 wird u. a. von .NET Framework 4.6.1+ und .NET Core 2.0+ unterstützt, während .NET Standard 2.1 vom .NET Framework nicht mehr unterstützt wird, da für 4.8 keine neue CLR-Version mehr entwickelt wurde. Mit .NET 5 im November 2020 hat Microsoft die einzelnen Implementierungen (Core, Framework, Mono/Xamarin) zu einer Plattform mit einem einheitlichen Ziel-Framework (z. B. net5.0, net6.0) zusammengeführt, wodurch .NET Standard als plattformübergreifende Kompatibilitätsschicht für neue Bibliotheken größtenteils überflüssig wurde; für Bibliotheken, die weiterhin auch klassisches .NET Framework unterstützen müssen, wird jedoch nach wie vor häufig netstandard2.0 als Zielframework verwendet.

New

Synonyme:
new-Operator

Kurz:
new ist in C# ein Schlüsselwort, das primär als Operator zum Erzeugen einer neuen Instanz eines Typs und zum Aufrufen ihres Konstruktors verwendet wird; daneben dient es als Modifizierer zum Ausblenden vererbter Member und als generische Typeinschränkung.

Länger:
Als Operator erzeugt new eine neue Instanz eines Typs, indem der passende Konstruktor des angegebenen Typs mit den in Klammern übergebenen Argumenten aufgerufen wird; bei Werttypen ohne explizit definierten Konstruktor initialisiert new die Instanz mit ihren Standardwerten (z.B. new int() entspricht 0). Ist keine Instanz erzeugbar, etwa wegen unzureichenden Arbeitsspeichers, löst new eine OutOfMemoryException aus; der Operator selbst kann nicht überladen werden. Als Modifizierer vor einer Memberdeklaration blendet new explizit ein von einer Basisklasse geerbtes Member aus, sodass die abgeleitete Version anstelle der Basisklassenversion verwendet wird – ohne den new-Modifizierer erzeugt ein solches Ausblenden lediglich eine Compiler-Warnung. Als generische Einschränkung (where T : new()) gibt new an, dass ein als Typargument verwendeter Typ einen öffentlichen, parameterlosen Konstruktor besitzen muss, damit eine generische Methode oder Klasse per new T() eine Instanz davon erzeugen kann.

`new`-Operator

(siehe „New“)

Nicht verwalteter Code

(siehe „Unmanaged Code“)

Non-nullable Reference Types

(siehe „Nullable Reference Types“)

Nothing

Synonyme:
—

Kurz:
Nothing ist ein Schlüsselwort in Visual Basic, das den Standardwert eines Datentyps darstellt – bei Referenztypen den null-Verweis, bei nicht nullbaren Werttypen den jeweiligen Standardwert des Typs; es ist damit weitgehend das VB.NET-Äquivalent zu null in C#.

Länger:
Wird Nothing einer Variablen eines Referenztyps zugewiesen, wird die Variable auf einen null-Verweis gesetzt und ist keinem Objekt mehr zugeordnet – dies entspricht direkt der Zuweisung von null in C#. Bei nicht nullbaren Werttypen unterscheidet sich Nothing jedoch von null in C#: Weist man einer Variable eines solchen Typs Nothing zu, wird sie nicht ungültig, sondern auf den Standardwert für den deklarierten Typ gesetzt (z.B. 0 für Integer); C# erlaubt null bei nicht nullbaren Werttypen dagegen überhaupt nicht ohne Nullable<T>. Bei einer nullbaren Variable setzt die Zuweisung von Nothing den Wert auf null. Um zu prüfen, ob eine Referenz- oder nullbare Variable null ist, verwendet man in VB.NET die Operatoren Is Nothing bzw. IsNot Nothing statt eines Vergleichs mit = oder <>. Für Zeichenfolgen in Visual Basic ist Nothing außerdem äquivalent zur leeren Zeichenfolge.

NotInheritable

Synonyme:
—

Kurz:
NotInheritable ist ein VB.NET-Modifizierer, der angibt, dass eine Klasse nicht als Basisklasse verwendet werden darf; eine solche Klasse wird auch als „sealed“ (versiegelt) bezeichnet. Er entspricht dem C#-Schlüsselwort sealed.

Länger:
Wird eine Klasse mit NotInheritable deklariert (z. B. Public NotInheritable Class Klassenname), verhindert dies, dass andere Entwickler von dieser Klasse ableiten. Standardmäßig sind in VB.NET alle Klassen vererbbar, sofern sie nicht ausdrücklich mit NotInheritable markiert werden. Microsoft empfiehlt die Verwendung von NotInheritable, wenn keine Notwendigkeit besteht, abgeleitete Klassen zu erstellen, etwa bei Klassen, die ausschließlich Shared-Methoden und -Eigenschaften enthalten, oder um versehentliche Vererbung zu verhindern. Ein bekanntes Beispiel aus der .NET-Standardbibliothek ist die als NotInheritable deklarierte Klasse System.Console. Das entsprechende C#-Schlüsselwort ist sealed.

NuGet

Synonyme:
—

Kurz:
NuGet ist der von Microsoft unterstützte Paketmanager für .NET (einschließlich .NET Core), mit dem Entwickler nützliche .NET-Bibliotheken erstellen, freigeben und in eigenen Projekten verwenden können.

Länger:
NuGet definiert, wie Pakete für .NET erstellt, gehostet und verarbeitet werden, und stellt dafür die entsprechenden Werkzeuge bereit, darunter die .NET-CLI, die nuget.exe-CLI, die Paket-Manager-Konsole und die Paket-Manager-Benutzeroberfläche in Visual Studio. Als öffentlicher Host stellt NuGet unter nuget.org ein zentrales Repository mit weit über 100.000 eindeutigen Paketen bereit, das täglich von Millionen von .NET-Entwicklern genutzt wird; daneben lassen sich Pakete auch privat hosten, etwa in Azure DevOps, einem privaten Netzwerk oder auf einem lokalen Dateisystem. Eine zentrale Aufgabe von NuGet ist die Verwaltung des Abhängigkeitsdiagramms eines Projekts: Entwickler müssen sich nur um die direkt verwendeten Pakete kümmern, während NuGet transitive Abhängigkeiten auflöst und bei mehreren Verweisen auf unterschiedliche Versionen desselben Pakets eine passende Version bestimmt. Die Liste der von einem Projekt verwendeten Pakete wird entweder im neueren PackageReference-Format direkt in der Projektdatei oder im älteren packages.config-Format als separate XML-Datei verwaltet; aus dieser Liste lassen sich referenzierte Pakete jederzeit wiederherstellen (dotnet restore, nuget restore), ohne dass Paketbinärdateien selbst in der Versionsverwaltung liegen müssen.

NuGet Package

(siehe „NuGet-Paket“)

NuGet-Paket

Synonyme:
NuGet Package

Kurz:
Ein NuGet-Paket ist eine einzelne ZIP-Datei mit der Dateierweiterung .nupkg, die kompilierten Code – etwa DLLs –, weitere zugehörige Dateien sowie ein beschreibendes Manifest mit Metadaten wie der Versionsnummer enthält.

Länger:
Ein NuGet-Paket stellt eine teilbare Codeeinheit dar: Paketersteller erzeugen ein Paket und veröffentlichen es auf einem öffentlichen oder privaten Host, etwa nuget.org, während Paketverbraucher es dort suchen, herunterladen und in ihre Projekte einbinden, wonach die enthaltenen APIs im Projektcode verwendet werden können. Ein NuGet-Paket kann Assemblys für ein oder mehrere Zielframeworks (Target Frameworks) enthalten; ist es speziell für .NET Standard erstellt, reicht in der Regel eine einzelne Assembly für alle nutzenden Projekte aus, andernfalls werden separate Assemblys je Zielframework in dasselbe Paket aufgenommen und beim Installieren nur die tatsächlich benötigten extrahiert. Beim Hinzufügen eines Pakets zu einem .NET- oder .NET-Core-Projekt wird ein <PackageReference>-Element in der Projektdatei (.csproj/.vbproj) angelegt; NuGet verwaltet daraufhin Version und Abhängigkeiten des Pakets und kann es bei Bedarf aktualisieren oder deinstallieren.

Nullable Reference Types

Synonyme:
Non-nullable Reference Types, Nullierbare Referenztypen

Kurz:
Nullable Reference Types sind eine seit C# 8.0 verfügbare Compiler-Funktion, die das Risiko einer NullReferenceException verringert, indem Entwickler explizit kennzeichnen, welche Referenztyp-Variablen null enthalten dürfen und welche nicht. Es handelt sich ausschließlich um ein Kompilierzeit-Feature, das statische Warnungen erzeugt.

Länger:
In einem aktivierten Nullable-Kontext gilt: Eine Variable eines nicht-nullbaren Referenztyps T muss mit einem Nicht-Null-Wert initialisiert werden, und es darf ihr nie ein möglicherweise-null-Wert zugewiesen werden; eine Variable eines nullbaren Referenztyps T? kann hingegen mit null initialisiert werden, muss aber vor dem Dereferenzieren auf null geprüft werden. „Dereferenzieren“ bedeutet, den Wert zu verwenden, auf den die Variable verweist, etwa durch Methodenaufruf, Eigenschaftszugriff oder Indexzugriff; das Dereferenzieren von null löst zur Laufzeit eine Ausnahme aus. Der Compiler führt eine statische Flussanalyse durch, um den Nullzustand (null-state) einer Variable – not-null oder maybe-null – zu verfolgen und bei riskanten Dereferenzierungen Warnungen auszugeben; das Laufzeitverhalten des Programms bleibt dabei unverändert. Der Nullable-Kontext lässt sich projektweit über das Element <Nullable>enable</Nullable> in der Projektdatei oder dateiweise über die Präprozessor-Direktive #nullable enable aktivieren. Der Null-vergebende Operator ! kann verwendet werden, um dem Compiler explizit mitzuteilen, dass ein Ausdruck trotz möglicher Nullbarkeit als nicht-null behandelt werden soll.

Nullierbare Referenztypen

(siehe „Nullable Reference Types“)

O

Object

(siehe „Objekt“)

Object-Oriented Programming

(siehe „Objektorientierte Programmierung“)

Object-Relational Mapper

Synonyme:
ORM

Kurz:
Ein Object-Relational Mapper (ORM, deutsch objektrelationale Abbildung) ist eine Software bzw. Technik, die Daten zwischen dem Typsystem einer objektorientierten Programmiersprache und einer relationalen Datenbank konvertiert und damit eine "virtuelle" objektorientierte Sicht auf relationale Daten schafft.

Länger:
Ein ORM-Werkzeug bildet Klassen einer Anwendung auf Tabellen einer relationalen Datenbank ab, Attribute der Klassen auf Spalten der Tabellen und Beziehungen zwischen Objekten (z. B. 1:n- oder m:n-Beziehungen) auf Fremdschlüsselbeziehungen in der Datenbank. Dadurch können Entwicklerinnen und Entwickler mit Objekten der Programmiersprache arbeiten, ohne SQL-Abfragen manuell schreiben zu müssen; das ORM-Framework generiert und führt die notwendigen SQL-Anweisungen im Hintergrund aus. In der .NET-Welt ist Entity Framework Core das von Microsoft bereitgestellte ORM, das per Definition Entwicklern erlaubt, mit einer Datenbank über .NET-Objekte statt über direkte SQL-Befehle zu arbeiten. Object-Relational Mapping löst das sogenannte Impedanzproblem (impedance mismatch) zwischen der objektorientierten Denkweise der Anwendungslogik und dem tabellarischen, relationalen Modell der Datenbank.

Objekt

Synonyme:
Object

Kurz:
Ein Objekt ist eine konkrete Instanz einer Klasse oder Struktur – im Grunde ein Speicherblock, der gemäß dem durch die Klasse definierten „Bauplan“ zugeordnet und konfiguriert wird. Ein Programm kann beliebig viele Objekte derselben Klasse erzeugen.

Länger:
In C# werden Objekte (Instanzen) mithilfe des new-Operators erstellt, etwa mit Customer object1 = new();. Da Klassen Referenztypen sind, enthält eine Variable, die auf ein Klassenobjekt verweist, lediglich einen Verweis auf die Adresse des Objekts im verwalteten Heap und nicht die eigentlichen Objektdaten selbst; weist man diese Variable einer zweiten Variablen desselben Typs zu, verweisen beide Variablen auf dasselbe Objekt im Speicher. Objekte werden über eine benannte Variable oder in Arrays bzw. Auflistungen referenziert und über sogenannten Clientcode angesprochen, der ihre öffentlichen Methoden aufruft und auf ihre öffentlichen Eigenschaften zugreift. In einer objektorientierten Sprache wie C# oder VB.NET besteht ein typisches Programm aus einer Vielzahl solcher Objekte, die zur Laufzeit dynamisch miteinander interagieren, ihre Daten (Zustand) verändern und Methoden aufeinander aufrufen. In VB.NET erfolgt die Objekterstellung analog mit dem Schlüsselwort New, z. B. Dim c As New Customer().

Objektorientierte Programmierung

Synonyme:
OOP, Object-Oriented Programming

Kurz:
Objektorientierte Programmierung (OOP) ist ein Programmierparadigma, das Code in Form von Klassen organisiert, die Daten und zugehöriges Verhalten in Objekten bündeln. C# ist eine objektorientierte Programmiersprache, deren vier Grundprinzipien Abstraktion, Kapselung, Vererbung und Polymorphismus sind.

Länger:
Bei der objektorientierten Programmierung modelliert man reale oder fachliche Entitäten als Klassen, die deren relevante Attribute und Verhaltensweisen zusammenfassen; aus diesen Klassen werden zur Laufzeit Objekte (Instanzen) erzeugt, die im Programm interagieren. Die vier Grundprinzipien lauten laut Microsoft-Dokumentation: Abstraktion (Modellieren der relevanten Attribute und Interaktionen einer Entität), Kapselung (Verbergen des internen Zustands und Zugriff nur über eine öffentliche Schnittstelle), Vererbung (Möglichkeit, neue Abstraktionen auf Basis bestehender zu erstellen) und Polymorphismus (Fähigkeit, geerbte Eigenschaften oder Methoden über mehrere Abstraktionen hinweg unterschiedlich zu implementieren). C# unterstützt OOP nativ über Sprachkonstrukte wie class, interface, abstract, virtual und override; auch VB.NET ist als objektorientierte Sprache konzipiert und bietet mit Class, Interface, MustInherit, Overridable und Overrides äquivalente Mechanismen. Alternative bzw. ergänzende Paradigmen in .NET sind unter anderem die funktionale Programmierung, die in C# etwa über LINQ und Lambda-Ausdrücke unterstützt wird, doch die grundlegende Typorganisation in .NET basiert traditionell auf dem objektorientierten Modell mit Klassen, Structs und Interfaces.

OOP

(siehe „Objektorientierte Programmierung“)

Operator

Synonyme:
—

Kurz:
Ein Operator ist ein Symbol oder Schlüsselwort, dem in einem Ausdruck ein oder mehrere Operanden als Eingabe übergeben werden und das einen Ergebniswert liefert.

Länger:
Operatoren mit einem Operanden – etwa der Inkrementoperator ++ oder new – werden unäre Operatoren genannt, Operatoren mit zwei Operanden wie die arithmetischen Operatoren +, -, *, / heißen binäre Operatoren, und der bedingte Operator ?: ist mit drei Operanden der einzige ternäre Operator in C#. Benutzerdefinierte Typen können viele vordefinierte Operatoren mittels Operatorüberladung (operator-Schlüsselwort) mit eigener Bedeutung versehen, etwa um das Verhalten von +, == oder Vergleichsoperatoren für eine eigene Klasse zu definieren; überladbare Operatoren müssen dabei häufig paarweise überladen werden (z. B. == zusammen mit !=, < zusammen mit >), und seit C# 14 können zusätzlich zusammengesetzte Zuweisungsoperatoren wie += direkt überladen werden. Nicht überladbar sind unter anderem der Zuweisungsoperator =, die bedingten logischen Operatoren && und ||, sowie new, is, typeof und sizeof. Operatormethoden müssen als public static deklariert werden und den Namen operator gefolgt vom jeweiligen Symbol tragen.

Option Explicit

Synonyme:
—

Kurz:
Option Explicit ist eine VB.NET-Anweisung, die die explizite Deklaration aller Variablen in einer Datei erzwingt. Ohne diese Deklaration führt die Verwendung eines nicht deklarierten Variablennamens zu einem Kompilierfehler.

Länger:
Die Anweisung wird in der Form Option Explicit On bzw. Option Explicit Off an den Anfang einer Quellcodedatei gestellt, noch vor allen anderen Anweisungen. Ist sie On (Standardeinstellung in VB.NET), müssen alle Variablen mittels Dim, ReDim, Private, Public o. Ä. deklariert werden, bevor sie verwendet werden dürfen; Tippfehler bei Variablennamen werden so bereits beim Kompilieren erkannt. Ist die Option Off, erlaubt der Compiler implizite Variablendeklarationen, wobei die betreffenden Variablen automatisch den Typ Object erhalten. Der Compiler-Schalter -optionexplicit sowie die Projekteinstellungen unter „Kompilieren“ in Visual Studio erlauben eine projektweite Konfiguration. Das Konzept existiert in ähnlicher Form auch in VBA und dem klassischen VB6, wo es ebenfalls die versehentliche Verwendung undeklarierter Variablen verhindert.

Option Strict

Synonyme:
—

Kurz:
Option Strict ist eine VB.NET-Anweisung, die implizite, verengende (narrowing) Typkonvertierungen sowie spätes Binden (Late Binding) verbietet und so eine strengere Typprüfung zur Kompilierzeit erzwingt.

Länger:
Mit Option Strict On unterbindet der Compiler implizite Konvertierungen, bei denen Daten verloren gehen könnten (z. B. von Double nach Integer), sowie den Zugriff auf Objekte über Late Binding und undeklarierte Variablen – Letzteres, weil Option Strict On implizit auch Option Explicit On voraussetzt. Solche Konvertierungen bzw. Zugriffe müssen dann explizit über Konvertierungsfunktionen wie CInt, CStr oder CType bzw. über Reflektion erfolgen. Ist die Option Off (Standardeinstellung, sofern nicht projektweit anders konfiguriert), lässt der Compiler implizite Konvertierungen und spätes Binden zu, was zwar flexibler, aber fehleranfälliger ist, da Typfehler erst zur Laufzeit auffallen. In Visual Studio lässt sich der Standardwert für neue Projekte unter „Extras → Optionen → Projekte und Projektmappen → VB-Standardwerte“ festlegen, projektspezifisch über die Compiler-Registerkarte der Projekteigenschaften.

ORM

(siehe „Object-Relational Mapper“)

Overload

(siehe „Überladen“)

Overloading

(siehe „Überladen“)

Overridable

Synonyme:
—

Kurz:
Overridable ist ein VB.NET-Modifizierer, der angibt, dass eine Eigenschaft oder Prozedur in einer abgeleiteten Klasse von einer gleichnamigen Eigenschaft bzw. Prozedur überschrieben werden darf; er entspricht dem C#-Schlüsselwort virtual.

Länger:
Der Modifizierer wird in der Basisklasse an der zu überschreibenden Deklaration angebracht (z. B. Public Overridable Sub Methodenname() ... End Sub) und erlaubt es einer abgeleiteten Klasse, mittels des Modifizierers Overrides eine eigene Implementierung bereitzustellen. Ohne explizite Angabe von Overridable oder NotOverridable hängt das Standardverhalten davon ab, ob das Element selbst schon eine Basisklassenmethode überschreibt: Ist dies der Fall, ist der Standard Overridable, andernfalls NotOverridable. Overridable kann nur in Deklarationsanweisungen für Eigenschaften oder Prozeduren (Function, Property, Sub) verwendet werden. Das Gegenstück NotOverridable verhindert das Überschreiben ausdrücklich.

Override

(siehe „Überschreiben“)

Overrides

Synonyme:
—

Kurz:
Overrides ist ein VB.NET-Modifizierer, der angibt, dass eine Eigenschaft oder Prozedur eine gleichnamige, von einer Basisklasse geerbte, als Overridable markierte Eigenschaft bzw. Prozedur überschreibt; er entspricht dem C#-Schlüsselwort override.

Länger:
Overrides wird in der abgeleiteten Klasse bei der Methode angegeben, die die Basisimplementierung ersetzen soll (z. B. Public Overrides Sub Methodenname() ... End Sub). Voraussetzung ist, dass die entsprechende Basisklassenmethode als Overridable (oder MustOverride) deklariert wurde; Methoden, die mit NotOverridable markiert sind, dürfen nicht überschrieben werden. Overrides kann nur in Eigenschafts- oder Prozedurdeklarationen verwendet werden, etwa in Function- oder Property-Anweisungen. Innerhalb der überschreibenden Methode kann über das Schlüsselwort MyBase weiterhin auf die Implementierung der Basisklasse zugegriffen werden. Fehlt sowohl Shadows als auch Overrides bei einer gleichnamigen Deklaration in einer abgeleiteten Klasse, wird laut VB.NET-Regeln standardmäßig Shadows angenommen, was ein wichtiger Unterschied zur reinen Überschreibung ist.

Overriding

(siehe „Überschreiben“)

P

Package Source

Synonyme:
Paketquelle

Kurz:
Eine Paketquelle (Package Source) ist der Ort beziehungsweise Dienst – etwa nuget.org, ein privater Feed oder ein lokales Dateisystem –, von dem NuGet Paketmetadaten abruft und aus dem Pakete installiert, aktualisiert oder wiederhergestellt werden.

Länger:
In Visual Studio lassen sich Paketquellen über den Paketquellenselektor im NuGet-Paket-Manager-Fenster sowie über die Optionen unter „NuGet Paket-Manager > Paketquellen“ verwalten: Neue Quellen werden mit Name und URL bzw. Pfad hinzugefügt, bestehende Quellen können bearbeitet, deaktiviert oder entfernt werden. Welche Metadaten – etwa Downloadzahlen, Autor oder Besitzerprofil – zu einem Paket angezeigt werden, hängt von der jeweils ausgewählten Paketquelle ab, da der Paketbesitz durch die Quelle definiert wird; Visual Studio verwendet dabei das Paket der Quelle, die als erste auf eine Anforderung antwortet, unabhängig von der Reihenfolge der konfigurierten Quellen. Konfiguriert werden Paketquellen technisch über NuGet.Config-Dateien auf Projekt-, Benutzer- oder Computerebene; mittels Package Source Mapping lässt sich zusätzlich festlegen, welche Paket-IDs oder -muster aus welcher konkreten Quelle bezogen werden dürfen, was insbesondere bei der Kombination öffentlicher und privater Feeds die Sicherheit erhöht.

Paketquelle

(siehe „Package Source“)

Parallel Programming

Synonyme:
Parallele Programmierung

Kurz:
Parallel Programming (parallele Programmierung) bezeichnet in .NET die gleichzeitige Ausführung mehrerer unabhängiger Berechnungen auf mehreren Threads oder Prozessorkernen, unterstützt vor allem durch die Task Parallel Library (TPL) mit der Klasse System.Threading.Tasks.Parallel.

Länger:
Visual Studio und .NET erweitern die Unterstützung für parallele Programmierung durch eine Laufzeitumgebung, Klassenbibliothekstypen und Diagnosewerkzeuge. Zentrales Element ist die Task Parallel Library (TPL), die parallele Versionen klassischer Schleifenkonstrukte über die statische Klasse Parallel bereitstellt, u.a. Parallel.For und Parallel.ForEach als datenparallele Ersatzkonstrukte für gewöhnliche for- bzw. foreach-Schleifen, sowie Parallel.Invoke zum gleichzeitigen Aufruf mehrerer Aktionen. Diese Konstrukte partitionieren die zu verarbeitende Datenquelle automatisch und verteilen die Arbeit basierend auf der Systemumgebung auf mehrere Threads; ergänzend ermöglicht Parallel LINQ (PLINQ) parallele Abfragen auf Datenquellen. Während sich asynchrone Programmierung primär auf die nicht blockierende Bewältigung von Wartezeiten (z.B. bei E/A-Operationen) konzentriert, zielt parallele Programmierung auf die tatsächliche gleichzeitige Ausführung rechenintensiver, unabhängiger Arbeitseinheiten ab, wobei beide Konzepte in .NET auf denselben zugrunde liegenden Task-Objekten und dem Threadpool aufbauen.

Parallele Programmierung

(siehe „Parallel Programming“)

Parameter

Synonyme:
—

Kurz:
Ein Parameter ist eine in der Signatur einer Methode, eines Konstruktors oder Delegaten deklarierte Variable, über die beim Aufruf konkrete Werte (Argumente) in den Methodenkörper übergeben werden.

Länger:
Parameter werden in der Methodendefinition innerhalb runder Klammern angegeben, durch Kommas getrennt, jeweils mit Datentyp und Name; leere Klammern bedeuten, dass die Methode keine Parameter benötigt. Ruft aufrufender Code die Methode auf, so übergibt er für jeden Parameter einen konkreten Wert, der als Argument bezeichnet wird – die Argumente müssen mit dem jeweiligen Parametertyp kompatibel sein, ihr Bezeichner im aufrufenden Code muss aber nicht mit dem Parameternamen übereinstimmen. C# unterscheidet unter anderem Wertparameter (Standardverhalten, Übergabe einer Kopie), Referenzparameter (ref, in, out), optionale Parameter mit Standardwert sowie Parameterfelder (params) für eine variable Anzahl von Argumenten. Zusätzlich lassen sich Argumente positionsbasiert oder als benannte Argumente (Named Arguments) übergeben. In VB.NET wird die Übergabeart pro Parameter explizit mit ByVal oder ByRef festgelegt.

`partial`

(siehe „Partielle Klasse“)

Partial Class

(siehe „Partielle Klasse“)

Partielle Klasse

Synonyme:
partial, Partial Class

Kurz:
Eine partielle Klasse ist eine Klasse, deren Definition mithilfe des Schlüsselworts partial auf zwei oder mehr Quelldateien aufgeteilt ist; beim Kompilieren werden alle Teile zu einem einzigen Typ zusammengeführt.

Länger:
Um eine Klassendefinition aufzuteilen, wird jeder Teil mit dem Modifizierer partial versehen; in der Praxis wird jede partielle Klasse üblicherweise in einer eigenen Datei definiert, was die Verwaltung und Erweiterung der Klasse über die Zeit erleichtert – ein typischer Anwendungsfall ist die Trennung von durch einen Designer generiertem Code und manuell geschriebenem Code. Alle Teile eines partiellen Typs müssen das Schlüsselwort partial tragen, zur Kompilierzeit verfügbar sein und dieselbe Zugriffsebene (z.B. public oder private) verwenden; der partial-Modifizierer darf nur unmittelbar vor class, struct, interface oder – ab C# 13 auch bei Properties und Indexern – vor dem jeweiligen Elementtyp stehen. Neben partiellen Typen gibt es partielle Member (partial methods): Ein Teil des Typs enthält nur die Signatur, ein anderer Teil die Implementierung; ohne implementierenden Teil entfernt der Compiler die Signatur beim Kompilieren, sofern die Methode void zurückgibt, keine Zugriffsmodifizierer besitzt und keine out-Parameter hat. In VB.NET existiert das äquivalente Konzept mit dem Schlüsselwort Partial, z.B. Partial Class.

Pattern Matching

Synonyme:
Musterabgleich

Kurz:
Pattern Matching (Musterabgleich) ist ein Verfahren, mit dem ein Ausdruck getestet wird, ob er bestimmte Merkmale (ein „Muster“) aufweist, wobei das Ergebnis bestimmt, welche Aktion das Programm ausführt.

Länger:
Der C#-Musterabgleich bietet eine präzise Syntax, um Ausdrücke mithilfe des is-Operators, einer switch-Anweisung oder eines switch-Ausdrucks zu testen und bei Übereinstimmung eine Aktion auszuführen; C# unterstützt dabei zahlreiche Musterarten, darunter Deklarationsmuster (prüft den Laufzeittyp und weist das Ergebnis einer Variablen zu), Typmuster, konstante Muster, relationale Muster, logische Muster (kombinierbar mit and, or, not), Eigenschaftsmuster, Positionsmuster (Dekonstruktion), das var-Muster, das Discard-Muster (_) sowie Listenmuster. Ein Muster gilt laut C#-Sprachspezifikation als auf einen Typ T anwendbar, wenn T zu den Typen gehört, deren Werte das Muster erfassen kann. Pattern Matching wurde ab C# 7.0 sukzessive eingeführt und in nachfolgenden Versionen (u. a. C# 8, 9 und 11) erheblich erweitert, etwa um Eigenschafts- und Listenmuster, und erlaubt einen deutlich kompakteren, ausdrucksstärkeren Programmierstil als klassische if-else-Ketten oder einfache switch-Anweisungen.

Plattformübergreifende Entwicklung

Synonyme:
Cross-Platform Development

Kurz:
Plattformübergreifende Entwicklung bezeichnet das Erstellen von Anwendungen, die auf mehreren Betriebssystemen bzw. Geräteplattformen (z. B. Windows, Linux, macOS, Android, iOS) lauffähig sind, häufig auf Basis einer gemeinsamen Codebasis.

Länger:
.NET wird von Microsoft explizit als „freie, plattformübergreifende Open-Source-Entwicklerplattform“ beschrieben, mit der Anwendungen für Web, Mobilgeräte, Desktop, Spiele und IoT entwickelt werden können; entsprechende Apps laufen unter Windows, Linux und macOS. Für die plattformübergreifende Entwicklung nativer mobiler und Desktop-Apps mit einer gemeinsamen Codebasis in C# und XAML stellt Microsoft zusätzlich das Framework .NET Multi-platform App UI (.NET MAUI) bereit, mit dem Anwendungen für Android, iOS, Mac Catalyst und Windows erstellt werden können. In Visual Studio wird die entsprechende Funktionalität unter anderem über die Workload „.NET Core plattformübergreifende Entwicklung“ bzw. die „.NET Multi-Platform App UI-Entwicklungsoption“ installiert. Zu unterscheiden ist dieses allgemeine Konzept von einzelnen konkreten plattformübergreifenden Frameworks wie .NET MAUI, das eine von mehreren möglichen Umsetzungen darstellt.

Polymorphie

Synonyme:
Polymorphismus, Polymorphism

Kurz:
Polymorphie (griechisch für „Vielgestaltigkeit“) bezeichnet die Fähigkeit, Objekte einer abgeleiteten Klasse an Stellen zu verwenden, an denen ein Objekt der Basisklasse erwartet wird, sowie die Möglichkeit, geerbtes Verhalten in abgeleiteten Klassen unterschiedlich zu implementieren. Sie gilt oft als dritte Säule der objektorientierten Programmierung nach Kapselung und Vererbung.

Länger:
Polymorphie in C# umfasst zwei unterschiedliche Aspekte: Erstens können zur Laufzeit Objekte einer abgeleiteten Klasse überall dort eingesetzt werden, wo ein Objekt der Basisklasse erwartet wird, etwa als Methodenparameter oder in Auflistungen und Arrays; dabei stimmt der deklarierte Typ des Objekts nicht mehr zwangsläufig mit dessen Laufzeittyp überein. Zweitens können Basisklassen virtuelle Methoden (virtual) definieren und implementieren, die von abgeleiteten Klassen mit override überschrieben werden, sodass sie eine eigene Implementierung bereitstellen; ruft der Clientcode zur Laufzeit die Methode auf, ermittelt die Common Language Runtime (CLR) den tatsächlichen Laufzeittyp des Objekts und führt die überschriebene Version aus – dieses Verhalten wird auch als Laufzeitpolymorphie oder dynamische Polymorphie bezeichnet. Daneben existiert die statische bzw. Kompilierzeit-Polymorphie, die sich durch Methodenüberladung (mehrere Methoden gleichen Namens mit unterschiedlicher Signatur) realisieren lässt. Alternativ zur klassenbasierten (vererbungsbasierten) Polymorphie kann Polymorphie in C# auch schnittstellenbasiert über interface-Implementierungen erreicht werden, ohne dass eine gemeinsame Klassenvererbung nötig ist. In VB.NET entsprechen den Schlüsselwörtern virtual und override die Modifizierer Overridable und Overrides.

Polymorphism

(siehe „Polymorphie“)

Polymorphismus

(siehe „Polymorphie“)

Private

Synonyme:
—

Kurz:
private ist der restriktivste Zugriffsmodifizierer in C#: Ein als private deklariertes Member ist nur innerhalb der Klasse oder Struktur zugänglich, in der es deklariert wurde.

Länger:
Das Schlüsselwort private ist ein Member-Zugriffsmodifizierer und Teil des zusammengesetzten Modifizierers private protected. Code außerhalb der deklarierenden Klasse oder Struktur kann nicht auf ein privates Member zugreifen; ein Verweis darauf von außen führt zu einem Kompilierzeitfehler. Geschachtelte Typen innerhalb desselben Klassenkörpers dürfen jedoch auf die privaten Member ihres umschließenden Typs zugreifen. Wird bei der Deklaration eines Klassenmembers gar kein Zugriffsmodifizierer angegeben, ist private in vielen Fällen der Standardwert (z.B. für Felder und Methoden). private wird typischerweise verwendet, um interne Implementierungsdetails – etwa Hilfsfelder, die als Backing Store für eine Property dienen – vor der Außenwelt zu verbergen und damit die Kapselung der Klasse zu gewährleisten. Das Gegenstück mit dem größten Zugriffsumfang ist public.

Project File

(siehe „Projektdatei“)

Projektdatei

Synonyme:
.csproj, .vbproj, Project File

Kurz:
Eine Projektdatei ist eine XML-Datei im MSBuild-Format, die alle Informationen und Anweisungen enthält, die MSBuild zum Erstellen eines .NET-Projekts benötigt; für C# lautet die Dateierweiterung .csproj, für Visual Basic .vbproj.

Länger:
Die Projektdatei beschreibt unter anderem den Projektinhalt, Plattformanforderungen, Versionsinformationen sowie die auszuführenden Build-Aufgaben; ihr Stammelement ist Project. Moderne .NET-Projekte verwenden das sogenannte SDK-Style-Format, erkennbar am Sdk-Attribut des Project-Elements, etwa <Project Sdk="Microsoft.NET.Sdk">; ein Projekt-SDK besteht aus einer Reihe von MSBuild-Zielen und zugehörigen Tasks, mit denen Code kompiliert, paketiert und veröffentlicht wird. Gegenüber dem älteren, ausführlichen Projektdateiformat sind SDK-Style-Projektdateien deutlich kompakter, da Standardwerte für Dateieinschlüsse (z. B. alle .cs-Dateien über Globbing) implizit vom SDK bereitgestellt werden und nicht mehr explizit aufgeführt werden müssen. Zielframework(s) werden über die Elemente TargetFramework bzw. TargetFrameworks, Ausgabetyp über OutputType und Laufzeitbezeichner über RuntimeIdentifier/RuntimeIdentifiers in der Projektdatei festgelegt; verfügbare Projekt-SDKs sind unter anderem Microsoft.NET.Sdk, Microsoft.NET.Sdk.Web und Microsoft.NET.Sdk.Worker.

Property

Synonyme:
Eigenschaft

Kurz:
Eine Property (Eigenschaft) ist ein Klassenmember, der einen flexiblen Mechanismus zum Lesen, Schreiben oder Berechnen des Werts eines zugrunde liegenden Datenfelds bietet und dabei nach außen wie ein Feld erscheint.

Länger:
Properties erscheinen als öffentliche Datenmember, werden intern aber als spezielle Methoden implementiert, die Accessoren genannt werden: ein get-Accessor zum Lesen und ein set- oder (seit C# 9) init-Accessor zum Schreiben des Werts. Eine Property ohne set-Accessor ist nur lesbar, eine ohne get-Accessor nur schreibbar; besitzt sie beide, ist sie les- und schreibbar. Properties erlauben es, Validierung, verzögerte Auswertung oder andere Logik beim Zugriff einzubauen, während der Aufrufer weiterhin die einfache Feldsyntax verwendet; seit C# 13/14 kann zudem das Schlüsselwort field verwendet werden, um innerhalb eines Accessors auf das vom Compiler synthetisierte Sicherungsfeld zuzugreifen. In VB.NET werden Properties mit Property ... Get ... End Get / Set ... End Set ... End Property deklariert, was funktional den get/set-Blöcken in C# entspricht.

Protected

Synonyme:
—

Kurz:
protected ist ein Zugriffsmodifizierer, der ein Member auf die deklarierende Klasse und alle davon abgeleiteten Klassen beschränkt, unabhängig davon, in welcher Assembly sich die abgeleitete Klasse befindet.

Länger:
Das Schlüsselwort protected ist ein Member-Zugriffsmodifizierer und außerdem Bestandteil der zusammengesetzten Modifizierer protected internal und private protected. Auf ein protected deklariertes Member kann innerhalb der eigenen Klasse sowie über Instanzen abgeleiteter Klassen zugegriffen werden – ein von einer Basisklasse geerbtes protected-Member ist in einer abgeleiteten Klasse allerdings nur zugreifbar, wenn der Zugriff über den Typ der abgeleiteten Klasse erfolgt. Im Unterschied zu private protected erlaubt protected den Zugriff durch abgeleitete Klassen in einer beliebigen Assembly, nicht nur in derselben. Structs können keine protected-Member besitzen, da Structs nicht vererbt werden können. protected wird typischerweise verwendet, um Funktionalität bereitzustellen, die zwar für abgeleitete Klassen nutzbar sein soll, aber vor Code außerhalb der Klassenhierarchie verborgen bleiben muss.

Protokollierung

(siehe „Logging“)

Public

Synonyme:
—

Kurz:
public ist der am wenigsten restriktive Zugriffsmodifizierer in C#: Auf ein als public deklariertes Typ oder Member kann Code in jeder beliebigen Assembly ohne Einschränkung zugreifen.

Länger:
Das Schlüsselwort public ist ein Zugriffsmodifizierer für Typen und Typmember. Öffentlicher Zugriff bedeutet, dass keine Einschränkungen für den Zugriff auf das Member bestehen; die Zugriffsebene einer öffentlichen Klasse wird dabei jedoch stets durch die Zugriffsebene des umschließenden Typs begrenzt – ein public-Member einer internal-Klasse ist von außerhalb der Assembly weiterhin nicht sichtbar. public wird für alle Elemente einer API verwendet, die von außerhalb der eigenen Klasse, des eigenen Structs oder der eigenen Assembly verwendbar sein sollen, etwa Klassen, Methoden, Eigenschaften oder Konstruktoren einer Bibliothek. Im Gegensatz dazu beschränken private, protected und internal die Sichtbarkeit stufenweise stärker. In VB.NET existiert das äquivalente Schlüsselwort Public.

R

readonly

Synonyme:
ReadOnly (VB.NET)

Kurz:
readonly ist ein C#-Modifizierer, der ein Feld schreibgeschützt macht: Eine Zuweisung ist nur bei der Deklaration selbst oder im Konstruktor der deklarierenden Klasse möglich; das VB.NET-Äquivalent ist der Modifizierer ReadOnly.

Länger:
Bei einer Felddeklaration gibt readonly in C# an, dass dem Feld nur im Rahmen der Deklaration oder in einem Konstruktor derselben Klasse ein Wert zugewiesen werden darf – dabei kann ein readonly-Feld innerhalb der Felddeklaration und des Konstruktors mehrfach neu zugewiesen werden, nach Abschluss des Konstruktors ist jedoch keine weitere Zuweisung mehr möglich. Der Modifizierer wird außerdem in vier weiteren Kontexten verwendet: bei readonly struct-Typdefinitionen, um die Unveränderlichkeit des gesamten Strukturtyps zu kennzeichnen; bei Instanzmember-Deklarationen innerhalb eines Strukturtyps, um anzugeben, dass das Member den Zustand der Struktur nicht verändert; bei ref readonly-Rückgabewerten von Methoden, um Schreibzugriffe auf die zurückgegebene Referenz zu verhindern; sowie als Teil des Parametermodifizierers ref readonly. readonly unterscheidet sich von const dadurch, dass ein readonly-Feld erst zur Laufzeit im Konstruktor initialisiert werden kann und somit je nach verwendetem Konstruktor unterschiedliche Werte annehmen kann, während ein const-Feld ein reiner Kompilierzeitwert ist. In VB.NET erfüllt der Modifizierer ReadOnly eine vergleichbare Funktion für Variablen und Eigenschaften: Er kann nur auf Modulebene (Klasse, Struktur oder Modul) verwendet werden, und eine ReadOnly-Eigenschaft besitzt effektiv nur einen Get-Zugriff, ohne dass Code außerhalb der Klasse den Wert setzen kann.

ReadOnly (VB.NET)

(siehe „readonly“)

Record

Synonyme:
Datensatztyp

Kurz:
Ein Record in C# ist eine Klasse oder Struktur mit besonderer, vom Compiler erzeugter Syntax und Verhalten für den Umgang mit Datenmodellen, insbesondere wertbasierter Gleichheit. Der record-Modifizierer wird auf class oder struct angewendet, wobei record/record class einen Referenztyp und record struct einen Werttyp erzeugt.

Länger:
Der record-Modifizierer weist den Compiler an, zusätzliche Member zu synthetisieren, die für Typen nützlich sind, deren primäre Rolle das Speichern von Daten ist; dazu zählen eine Überladung von ToString() sowie Member zur Unterstützung der Wertgleichheit. Bei Records bedeutet Wertgleichheit, dass zwei Instanzen eines Datensatztyps als gleich gelten, wenn ihr Typ übereinstimmt und alle Eigenschafts- bzw. Feldwerte gleich sind; bei gewöhnlichen Klassen bedeutet Gleichheit standardmäßig hingegen Referenzgleichheit. Records unterstützen zudem with-Ausdrücke für nichtdestruktive Mutation, bei denen eine Kopie einer Instanz mit geänderten Eigenschaftswerten erzeugt wird. Schreibt man nur record, ist dies gleichbedeutend mit record class und erzeugt einen Referenztyp; record struct erzeugt hingegen einen Werttyp mit ähnlicher Funktionalität. Record-Klassen unterstützen Vererbungshierarchien, Record-Structs hingegen nicht. Records wurden mit C# 9.0 eingeführt und eignen sich besonders für unveränderliche (immutable) Datenmodelle, etwa DTOs oder Werteobjekte.

Reference Type

Synonyme:
Referenztyp

Kurz:
Ein Reference Type (Referenz- bzw. Verweistyp) ist eine Kategorie von C#-Typen, bei der eine Variable nicht die Daten selbst, sondern einen Verweis auf ein Objekt im verwalteten Heap speichert. Klassen, Schnittstellen, Arrays, Delegates und string sind Referenztypen.

Länger:
Bei Referenztypen speichert die Variable eine Referenz auf ihre eigentlichen Daten, die als Objekt bezeichnet werden; zwei Variablen können somit auf dasselbe Objekt verweisen, sodass eine Operation über eine Variable auch über die andere sichtbar ist. Ein Verweistyp ist laut C#-Sprachspezifikation ein Klassentyp, ein Schnittstellentyp, ein Arraytyp, ein Delegattyp oder der dynamic-Typ; für jeden nicht nullbaren Referenztyp existiert außerdem ein korrespondierender nullbarer Referenztyp, gekennzeichnet durch ein angehängtes ?. Der spezielle Wert null ist mit allen Referenztypen kompatibel und bedeutet das Fehlen einer Instanz. Eine Besonderheit ist der string-Typ: Obwohl er ein Referenztyp ist, verhält er sich aufgrund seiner Unveränderlichkeit (Immutability) im alltäglichen Gebrauch oft wie ein Werttyp. Referenztypen werden üblicherweise auf dem Heap angelegt, während die Referenz selbst z. B. auf dem Stack liegen kann.

Referenztyp

(siehe „Reference Type“)

Reflection

Synonyme:
Reflektion

Kurz:
Reflection (Reflektion) bezeichnet in .NET die Fähigkeit, zur Laufzeit Informationen über geladene Assemblys und die darin definierten Typen (Klassen, Schnittstellen, Strukturen, Enumerationen) abzurufen sowie Typinstanzen dynamisch zu erstellen und zu manipulieren.

Länger:
Die Klassen im Namespace System.Reflection ermöglichen zusammen mit System.Type, zur Laufzeit Typinformationen eines Objekts abzufragen, Typinstanzen zu erstellen und an vorhandene Objekte zu binden, Methoden aufzurufen sowie Felder und Eigenschaften eines Typs zu lesen oder zu schreiben. Die .NET-Metadaten sind hierarchisch strukturiert: Eine Assembly enthält Module, Module enthalten Typen, und Typen enthalten Member; entsprechend stellt Reflection eigene Klassen wie Assembly, Module, ConstructorInfo, MethodInfo, FieldInfo, PropertyInfo, EventInfo und ParameterInfo bereit, mit denen sich Namen, Zugriffsmodifizierer und weitere Implementierungsdetails der jeweiligen Codeentität abfragen lassen. Eine spezialisierte Erweiterung ist System.Reflection.Emit, mit der Typen zur Laufzeit dynamisch erzeugt werden können. Typische Anwendungsfälle von Reflection sind Typbrowser, Compiler für andere Sprachen (zum Aufbau von Symboltabellen) sowie die Serialisierung, bei der die Klassen im Namespace System.Runtime.Serialization Reflection nutzen, um auf Daten zuzugreifen und zu bestimmen, welche Felder erhalten bleiben sollen.

Reflektion

(siehe „Reflection“)

Release Configuration

(siehe „Release-Konfiguration“)

Release-Konfiguration

Synonyme:
Release Configuration

Kurz:
Die Release-Konfiguration ist eine Buildkonfiguration, die ein Programm vollständig optimiert und ohne symbolische Debuginformationen für die endgültige Auslieferung bzw. Bereitstellung erstellt.

Länger:
Im Gegensatz zur Debug-Konfiguration verfügt die Release-Version eines Programms über keine symbolischen Debuginformationen und ist vollständig optimiert; für verwaltetes und C++-Code können Debuginformationen abhängig von den gewählten Compileroptionen dennoch in .pdb-Dateien generiert werden, etwa um eine bereits ausgelieferte Release-Version später debuggen zu können. Beim .NET-CLI-Befehl dotnet build muss die Release-Konfiguration explizit über --configuration Release angefordert werden, während dotnet publish sie ab dem .NET-8-SDK für Projekte mit Zielframework net8.0 oder höher standardmäßig verwendet. In der Projektdatei lassen sich release-spezifische Einstellungen über bedingte PropertyGroup-Elemente mit Condition="'$(Configuration)' == 'Release'" festlegen, etwa um Optimize auf true zu setzen, DebugType auf pdbonly oder none zu reduzieren oder das Präprozessorsymbol DEBUG zu entfernen.

Repository Pattern

Synonyme:
Repository-Muster

Kurz:
Das Repository Pattern ist ein aus dem Domain-Driven Design stammendes Entwurfsmuster, das Persistenzbelange (z. B. Datenbankzugriff) hinter einer Abstraktion vom Domänenmodell einer Anwendung trennt. Es zentralisiert den Datenzugriff und erleichtert dadurch Wartbarkeit und Testbarkeit.

Länger:
Beim Repository Pattern werden eine oder mehrere Persistenzabstraktionen – üblicherweise Schnittstellen – im Domänenmodell definiert; deren konkrete Implementierungen liegen als persistenzspezifische Adapter (z. B. auf Basis von Entity Framework) in einer separaten Infrastrukturschicht. Microsofts Leitfaden zu Microservices und DDD-Mustern empfiehlt, für jede Aggregatwurzel genau eine Repository-Klasse zu erstellen, und zeigt beispielhaft eine generische Basisschnittstelle wie IRepository<T> where T : IAggregateRoot. Der zentrale Nutzen liegt darin, dass die Geschäftslogik nicht direkt von einer konkreten Datenzugriffstechnologie abhängt, sondern nur von der Repository-Abstraktion – wodurch sich die zugrunde liegende Datenquelle austauschen lässt und Unit-Tests ohne echte Datenbank möglich werden. In der Praxis wird das Repository Pattern häufig zusammen mit dem Unit-of-Work-Muster kombiniert, das mehrere Repository-Operationen als eine zusammenhängende Transaktion behandelt.

Repository-Muster

(siehe „Repository Pattern“)

REST-API

Synonyme:
RESTful API

Kurz:
Eine REST-API (Representational State Transfer) ist eine Web-API, die HTTP-Vorgänge (Methoden wie GET, POST, PUT, DELETE) verwendet, um auf Ressourcen zuzugreifen, sie zu erstellen, zu aktualisieren oder zu löschen, wobei jede Ressource durch einen eindeutigen URI identifiziert wird.

Länger:
Eine RESTful-Web-API-Implementierung nutzt die architektonischen Prinzipien von Representational State Transfer (REST), um eine zustandslose, lose gekoppelte Schnittstelle zwischen einem Client und einem Dienst zu erreichen; sie unterstützt das Standard-HTTP-Protokoll, um Operationen auf Ressourcen auszuführen und Repräsentationen dieser Ressourcen einschließlich Hypermedia-Links und HTTP-Statuscodes zurückzugeben. In ASP.NET Core können REST-APIs sowohl über Controller (von ControllerBase abgeleitete Klassen mit dem Attribut [ApiController]) als auch über sogenannte Minimal APIs implementiert werden, wobei über app.MapGet, app.MapPost usw. Endpunkte registriert werden. REST-APIs werden häufig mit Werkzeugen wie Swagger/OpenAPI dokumentiert, um Clients eine maschinenlesbare Beschreibung der verfügbaren Endpunkte bereitzustellen. Die Begriffe "REST-API" und "RESTful API" werden in der Praxis meist synonym verwendet.

RESTful API

(siehe „REST-API“)

Return Value

(siehe „Rückgabewert“)

RID

(siehe „Runtime Identifier“)

Roslyn

(siehe „C#-Compiler“)

Rückgabewert

Synonyme:
Return Value

Kurz:
Der Rückgabewert ist der Wert, den eine Methode oder Funktion beim Beenden ihrer Ausführung mittels der return-Anweisung an den aufrufenden Code zurückgibt.

Länger:
Die return-Anweisung beendet die Ausführung der Funktion, in der sie steht, und gibt die Kontrolle sowie – sofern vorhanden – das Ergebnis der Funktion an den Aufrufer zurück. Berechnet ein Funktionsmember keinen Wert (Rückgabetyp void), wird return ohne Ausdruck verwendet, um die Methode vorzeitig zu verlassen; berechnet die Methode einen Wert, folgt auf return ein Ausdruck, dessen Wert implizit in den deklarierten Rückgabetyp der Methode konvertierbar sein muss. Steht die return-Anweisung innerhalb eines try-Blocks, wird ein zugehöriger finally-Block noch ausgeführt, bevor die Kontrolle tatsächlich an den Aufrufer zurückgegeben wird. Neben der Rückgabe nach Wert unterstützt C# auch die Rückgabe nach Verweis (ref return): Eine Methode, die einen Verweis auf eine Variable zurückgibt, muss das Schlüsselwort ref sowohl vor dem Rückgabetyp als auch vor jeder zurückgegebenen Instanz in den return-Anweisungen verwenden. Bei asynchronen Methoden mit Rückgabetyp Task oder ValueTask wird return ebenfalls ohne Ausdruck verwendet.

Rückruffunktion

(siehe „Callback“)

Runtime

(siehe „Laufzeitumgebung“)

Runtime Identifier

Synonyme:
RID

Kurz:
Ein Runtime Identifier (RID) ist ein Bezeichner, der eine Zielplattform (Betriebssystem, Version, Architektur) identifiziert, unter der eine .NET-Anwendung ausgeführt wird, und wird von .NET-Paketen genutzt, um plattformspezifische Ressourcen in NuGet-Paketen darzustellen.

Länger:
RIDs, die konkrete Betriebssysteme darstellen, folgen in der Regel dem Muster [os].[version]-[architecture]-[additional qualifiers], wobei die Betriebssystemversion keine reine Marketingversion sein soll; gängige Beispiele sind win-x64, win-arm64, linux-x64, linux-arm64, linux-musl-x64 (etwa für Alpine Linux), osx-x64 und osx-arm64. Eine einzelne RID lässt sich in der Projektdatei über das Element <RuntimeIdentifier> festlegen, mehrere RIDs als durch Semikolon getrennte Liste über <RuntimeIdentifiers>; alternativ kann die RID bei .NET-CLI-Befehlen wie dotnet build, dotnet publish oder dotnet run über die Option -r|--runtime übergeben werden. Für native Abhängigkeiten bestimmt die RID, auf welchen Plattformen ein Paket wiederhergestellt werden kann; über ein sogenanntes RID-Diagramm (definiert in PortableRuntimeIdentifierGraph.json im Repository dotnet/runtime) werden kompatible RIDs aufeinander abgebildet, sodass NuGet bei fehlender exakter Übereinstimmung auf kompatible, allgemeinere RIDs zurückgreifen kann. Seit .NET 8 empfiehlt Microsoft ausdrücklich die Verwendung nicht versions- und nicht distributionsspezifischer, sogenannter portabler RIDs.

S

Schnittstelle

(siehe „Interface“)

Self-contained Deployment

Synonyme:
Eigenständige Bereitstellung

Kurz:
Die eigenständige Bereitstellung (Self-Contained Deployment, SCD) erzeugt eine plattformspezifische ausführbare Anwendung, die zusätzlich zum App-Code und dessen Abhängigkeiten auch die benötigte .NET-Runtime enthält.

Länger:
Da die .NET-Runtime mit der App bereitgestellt wird, muss auf dem Zielsystem keine .NET-Runtime vorinstalliert sein; native, systemeigene Abhängigkeiten von .NET sind davon jedoch ausgenommen und müssen weiterhin vorhanden sein. Die Zielplattform wird über einen Runtime Identifier (RID) angegeben, sodass für jede Zielplattform eine eigene Veröffentlichung erfolgen muss. Vorteile sind die volle Kontrolle über die mitgelieferte .NET-Version und die Unabhängigkeit von einer vorinstallierten Runtime; Nachteile sind eine deutlich größere Bereitstellungsgröße, da Runtime und Abhängigkeiten enthalten sind, sowie ein aufwendigeres Aktualisieren der .NET-Version, da hierfür stets eine neue App-Version veröffentlicht werden muss – anders als bei der framework-abhängigen Bereitstellung erfolgt keine automatische Weiterleitung auf neuere Sicherheitspatches. Über die CLI wird dieser Modus mit dotnet publish -c Release -r <RID> --self-contained true erzeugt. Die Gesamtgröße lässt sich unter anderem durch Trimming und den invarianten Globalisierungsmodus reduzieren.

Serialisierung

Synonyme:
Serialization

Kurz:
Serialisierung ist der Prozess, den Zustand eines Objekts (die Werte seiner Eigenschaften) in eine Form umzuwandeln, die gespeichert oder übertragen werden kann.

Länger:
Bei der Serialisierung wird ein Objekt in einen Datenstrom (z. B. eine Byte-Folge, einen JSON-Text oder ein XML-Dokument) überführt, damit es persistiert, über ein Netzwerk übertragen oder anderweitig weitergegeben werden kann. Die serialisierte Form enthält üblicherweise nur die Werte der öffentlichen (bei manchen Verfahren auch privaten) Felder bzw. Eigenschaften, nicht jedoch die zugeordneten Methoden eines Objekts. .NET bietet mehrere Serialisierungsmechanismen: Die XML-Serialisierung über XmlSerializer (Namespace System.Xml.Serialization) serialisiert nur öffentliche Felder und Eigenschaften in ein XML-Dokument, während die JSON-Serialisierung über System.Text.Json bzw. den historisch verbreiteten Drittanbieter Newtonsoft.Json Objekte in JSON-Text umwandelt. Das Gegenstück zur Serialisierung ist die Deserialisierung, die aus dem Datenstrom wieder ein Objekt rekonstruiert.

Serialization

(siehe „Serialisierung“)

Service Container

Synonyme:
DI-Container

Kurz:
Ein Service Container (auch DI-Container) ist die Komponente, die im Rahmen von Dependency Injection registrierte Abhängigkeiten (Dienste) verwaltet, ihre Lebensdauer steuert und sie bei Bedarf erzeugt bzw. bereitstellt. In .NET wird der eingebaute Service Container über die Schnittstelle IServiceProvider repräsentiert.

Länger:
In .NET werden Dienste zunächst über die Schnittstelle IServiceCollection registriert – etwa mit Erweiterungsmethoden wie AddSingleton, AddScoped oder AddTransient, die jeweils einen Diensttyp mit einer konkreten Implementierung verknüpfen. Nach Abschluss der Registrierung wird mittels BuildServiceProvider (bzw. automatisch beim Start einer ASP.NET-Core- oder generischen Host-Anwendung) ein IServiceProvider-Objekt erzeugt: der eigentliche Service Container. Dieser ist verantwortlich für die Auflösung angeforderter Dienste, das rekursive Erzeugen benötigter Abhängigkeiten über Konstruktor-Injektion sowie die automatische Freigabe (Dispose) von Instanzen gemäß ihrer konfigurierten Lebensdauer (Transient, Scoped, Singleton). Neben dem in .NET integrierten Container existieren zahlreiche Drittanbieter-DI-Container wie Autofac, Castle Windsor oder Unity, die zusätzliche Funktionen wie erweiterte Zyklenerkennung oder alternative Registrierungsmodelle bieten.

set-Accessor

(siehe „Setter“)

Setter

Synonyme:
set-Accessor

Kurz:
Der Setter (set-Accessor) ist der Teil einer Property oder eines Indexers in C#, der ausgeführt wird, wenn der Property ein neuer Wert zugewiesen wird.

Länger:
Das Schlüsselwort set definiert eine Zugriffsmethode, deren Rückgabetyp implizit void ist und die einen impliziten Parameter namens value verwendet, welcher den zuzuweisenden Wert enthält; dieser Wert kann im Setter-Rumpf validiert oder verarbeitet werden, bevor er im zugrunde liegenden Feld gespeichert wird. Eine Property, die nur einen set-Accessor besitzt, ist reine Schreib-Property (write-only); besitzt sie zusätzlich einen get-Accessor, ist sie les- und schreibbar. Seit C# 9 existiert als Alternative zum set-Accessor der init-Accessor, der eine Zuweisung nur während der Objektinitialisierung erlaubt und dieselbe Syntax wie set verwendet. In VB.NET entspricht dies dem Set(value As ...) ... End Set-Block innerhalb einer Property-Deklaration.

Shared

Synonyme:
—

Kurz:
Shared ist ein VB.NET-Modifizierer, der angibt, dass ein Klassen- oder Strukturmitglied der Klasse bzw. Struktur als Ganzem zugeordnet ist und nicht einer bestimmten Instanz; er entspricht dem C#-Schlüsselwort static.

Länger:
Ein mit Shared deklariertes Feld, eine Eigenschaft, Methode oder ein Ereignis existiert nur einmal pro Typ und wird von allen Instanzen gemeinsam genutzt: Ändert eine Instanz den Wert eines Shared-Felds, sehen alle anderen Instanzen denselben aktualisierten Wert. Der Zugriff erfolgt üblicherweise über den Klassen- bzw. Strukturnamen und nicht über eine Instanzvariable. Shared kann in Dim-, Event-, Function-, Operator-, Property- und Sub-Anweisungen verwendet werden, jedoch nicht gemeinsam mit Overrides, Overridable, NotOverridable, MustOverride oder Static in derselben Deklaration. Zu unterscheiden ist Shared vom VB.NET-Schlüsselwort Static, das ausschließlich für lokale Variablen innerhalb einer Prozedur gilt und dafür sorgt, dass deren Wert über mehrere Prozeduraufrufe hinweg erhalten bleibt – ein feiner, aber wichtiger begrifflicher Unterschied zum C#-static, das beide Konzepte in einem Schlüsselwort vereint.

Single-file Deployment

Synonyme:
Einzeldatei-Bereitstellung

Kurz:
Die Einzeldatei-Bereitstellung (Single-file Deployment) bündelt alle von der Anwendung abhängigen Dateien in eine einzige Binärdatei, um Verteilung und Bereitstellung als eine einzelne Datei zu ermöglichen.

Länger:
Dieses Bereitstellungsmodell steht sowohl für die framework-abhängige als auch für die eigenständige Bereitstellung zur Verfügung; im eigenständigen Fall fällt die Einzeldatei deutlich größer aus, da sie Runtime und Frameworkbibliotheken enthält. Zur Aktivierung wird <PublishSingleFile>true</PublishSingleFile> in die Projektdatei eingetragen, anschließend erfolgt die Veröffentlichung mit dotnet publish -r <RID> für einen bestimmten Runtime Identifier – in Visual Studio wird dazu im Veröffentlichungsprofil die Option „Einzelne Datei erstellen“ aktiviert. Die Einzeldatei-Bereitstellung lässt sich mit weiteren Publish-Optionen wie ReadyToRun und Trimming kombinieren, um die Gesamtgröße zusätzlich zu reduzieren.

.sln

(siehe „Solution-Datei“)

SOLID

(siehe „SOLID-Prinzipien“)

SOLID-Prinzipien

Synonyme:
SOLID

Kurz:
SOLID ist ein Akronym für fünf grundlegende Prinzipien des objektorientierten Softwaredesigns, die von Robert C. Martin geprägt wurden: Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation und Dependency Inversion. Sie zielen auf wartbaren, erweiterbaren und lose gekoppelten Code ab.

Länger:
Das Single-Responsibility-Prinzip besagt, dass eine Klasse nur einen einzigen Grund zur Änderung haben sollte. Das Open/Closed-Prinzip fordert, dass Software-Einheiten für Erweiterungen offen, für Modifikationen aber geschlossen sein sollen. Das Liskov-Substitutionsprinzip verlangt, dass Instanzen abgeleiteter Klassen anstelle von Instanzen ihrer Basisklasse verwendet werden können, ohne bestehendes Verhalten zu brechen. Das Interface-Segregation-Prinzip empfiehlt viele kleine, spezifische Schnittstellen anstelle einer großen, universellen Schnittstelle. Das Dependency-Inversion-Prinzip schließlich fordert, dass Module höherer Ebenen nicht von Modulen niedrigerer Ebenen abhängen sollen, sondern beide von Abstraktionen – dieses Prinzip bildet zugleich die konzeptionelle Grundlage für Dependency Injection und Clean-Architecture-Ansätze. In der .NET-Architekturdokumentation werden die SOLID-Prinzipien insbesondere im Kontext von Microservices und Domain-Driven Design als zentrale Techniken zur Entkopplung von Anwendungsschichten hervorgehoben.

Solution File

(siehe „Solution-Datei“)

Solution-Datei

Synonyme:
.sln, Solution File

Kurz:
Eine Solution-Datei (Projektmappendatei, Dateierweiterung .sln) ist eine textbasierte, gemeinsam genutzte Datei, die in Visual Studio zum Organisieren mehrerer zusammengehöriger Projekte in einer Projektmappe (Solution) verwendet wird.

Länger:
Eine Projektmappe (Solution) ist eine Struktur zum Organisieren von Projekten in Visual Studio; sie verwaltet Statusinformationen in zwei Dateitypen, der textbasierten, gemeinsam genutzten .sln-Datei und einer binären, benutzerspezifischen .suo-Datei für Optionen. Die .sln-Datei enthält textbasierte Informationen, mit denen die Entwicklungsumgebung die zugehörigen Projekte (z. B. .csproj- oder .vbproj-Dateien) findet und lädt, sowie Verweise auf die verwendeten VSPackages; zusätzlich kann sie projektmappenweite Build-Konfigurationen abbilden, die festlegen, welche Projekte in welcher Konfiguration (etwa Debug oder Release) erstellt werden. Neben der klassischen .sln-Datei existiert inzwischen auch das neuere, MSBuild-basierte .slnx-Format als Alternative. Der .NET-CLI-Befehl dotnet build kann sowohl auf eine einzelne Projektdatei als auch auf eine Solution-Datei angewendet werden; wird kein Argument angegeben, durchsucht MSBuild das aktuelle Verzeichnis automatisch nach einer passenden Projekt- oder Projektmappendatei.

Stack Trace

Synonyme:
Stapelverfolgung, Aufrufstapel-Protokoll

Kurz:
Ein Stack Trace (Stapelverfolgung) ist eine geordnete Auflistung der Methodenaufrufe (Stapelframes), die zu einem bestimmten Punkt im Programm – meist dem Auftreten einer Ausnahme – geführt haben, und wird in .NET durch die Klasse System.Diagnostics.StackTrace bzw. die Eigenschaft Exception.StackTrace bereitgestellt.

Länger:
Die StackTrace-Klasse aus dem Namespace System.Diagnostics stellt eine sortierte Sammlung von einem oder mehreren Stapelframes dar und wird häufig zur Diagnose verwendet, um den Ausführungspfad nachzuvollziehen, der zu einem Fehler geführt hat. Praktisch begegnet der Stack Trace Entwicklern meist über die Eigenschaft StackTrace eines Exception-Objekts: Diese liefert eine Zeichenfolge, die die unmittelbaren Frames des Aufrufstapels zum Zeitpunkt des Auslösens der Ausnahme beschreibt, und ist damit ein zentrales Hilfsmittel beim Debugging, da sie zeigt, welche Methode welche andere Methode aufgerufen hat. Ist noch keine Ausnahme ausgelöst worden bzw. der Stapel noch nicht abgewickelt, liefert die Eigenschaft den Wert null.

Stapelverfolgung

(siehe „Stack Trace“)

Static Class

(siehe „Statische Klasse“)

Static Member

(siehe „Statisches Mitglied“)

Statische Klasse

Synonyme:
Static Class

Kurz:
Eine statische Klasse ist eine Klasse, die nicht instanziiert werden kann und ausschließlich statische Member enthält, auf die über den Klassennamen selbst zugegriffen wird. Sie dient häufig als praktischer Container für Hilfsmethoden, die nur mit Eingabeparametern arbeiten.

Länger:
In C# wird eine statische Klasse mit dem Modifizierer static vor der Klassendeklaration erstellt, etwa static class CompanyEmployee. Eine statische Klasse ist grundsätzlich mit einer nicht statischen Klasse identisch, mit dem entscheidenden Unterschied, dass sie nicht mit dem new-Operator instanziiert werden kann; da es keine Instanzvariable gibt, erfolgt der Zugriff auf Member ausschließlich über den Klassennamen selbst. Die wesentlichen Eigenschaften einer statischen Klasse sind: Sie enthält nur statische Member, kann nicht instanziiert werden, ist implizit versiegelt (sealed) und kann keine Instanzkonstruktoren enthalten – wird der Modifizierer static auf eine Klasse angewendet, müssen zwangsläufig alle Member der Klasse ebenfalls static sein. Statische Klassen eignen sich besonders für Utility- bzw. Helper-Funktionalität, die keinen Objektzustand benötigt, etwa mathematische Hilfsfunktionen wie in der .NET-Klasse System.Math. VB.NET kennt kein direktes Äquivalent zum Schlüsselwort static class; dort wird dasselbe Verhalten über das Modul-Konstrukt (Module) erreicht, dessen Member implizit gemeinsam (shared) und ohne Instanziierung nutzbar sind, oder über eine Klasse, deren sämtliche Member als Shared deklariert sind und die einen privaten Konstruktor besitzt.

Statisches Mitglied

Synonyme:
Static Member

Kurz:
Ein statisches Mitglied (statisches Member) gehört zum Typ selbst und nicht zu einer konkreten Instanz dieses Typs; es existiert nur einmal, unabhängig davon, wie viele Objekte der Klasse erzeugt werden. Der Zugriff erfolgt über den Typnamen statt über eine Objektvariable.

Länger:
In C# wird ein statisches Mitglied mit dem Modifizierer static vor dem Rückgabetyp deklariert und kann in Klassen, Structs und Schnittstellen für Felder, Methoden, Eigenschaften, Operatoren, Ereignisse und Konstruktoren verwendet werden; nicht zulässig ist static hingegen bei Indexern oder Finalizern. Während jede Instanz einer Klasse eine eigene Kopie sämtlicher Instanzfelder besitzt, existiert von einem statischen Feld stets nur eine einzige, für alle Instanzen gemeinsame Kopie im Speicher; ein statisches Mitglied kann daher nicht über eine Objektreferenz, sondern nur über den vollqualifizierten Typnamen angesprochen werden, es sei denn, es ist aus demselben Gültigkeitsbereich direkt zugänglich. Konstanten und Typdeklarationen sind implizit immer statisch. Ein statischer Konstruktor (in C# ohne Zugriffsmodifizierer und Parameter deklariert) wird automatisch höchstens einmal aufgerufen, bevor die erste Instanz der Klasse erstellt oder auf ein statisches Mitglied der Klasse zugegriffen wird, und dient typischerweise zur Initialisierung statischer Daten. In VB.NET entspricht dem static-Modifizierer bei Klassenmitgliedern das Schlüsselwort Shared; wichtig ist die Unterscheidung zum VB.NET-Schlüsselwort Static innerhalb von Prozeduren, das eine andere, lokale Bedeutung (Erhalt des Werts einer lokalen Variablen zwischen Aufrufen) hat.

String

Synonyme:
Zeichenfolge

Kurz:
Ein string ist in C# ein unveränderlicher Referenztyp zur Darstellung von Text, der intern durch die Klasse System.String repräsentiert wird. Eine Zeichenfolge ist eine Abfolge von char-Objekten (Unicode-UTF-16-Zeichen).

Länger:
In C# ist string das Sprachschlüsselwort für den Typ System.String; jedes Stringliteral im Quellcode erzeugt eine System.String-Instanz. Zeichenfolgen sind unveränderlich (immutable): Nachdem ein string-Objekt erstellt wurde, kann sein Inhalt nicht mehr geändert werden – Methoden und Operatoren, die scheinbar eine Zeichenfolge verändern, geben stattdessen ein neues Zeichenfolgenobjekt zurück. Diese Unveränderlichkeit erklärt, warum sich string im täglichen Gebrauch wie ein Werttyp verhält, obwohl es sich technisch um einen Referenztyp handelt; sie erlaubt außerdem das sichere Teilen von Zeichenfolgen über Methoden und Threads hinweg. Die Length-Eigenschaft eines Strings gibt die Anzahl der enthaltenen Char-Objekte zurück, nicht notwendigerweise die Anzahl der dargestellten Unicode-Zeichen (bei Zeichen außerhalb der Basic Multilingual Plane können mehrere Char-Werte ein Zeichen bilden). C# unterstützt neben normalen Zeichenfolgenliteralen in doppelten Anführungszeichen auch wortgetreue Zeichenfolgen (@"...") und interpolierte Zeichenfolgen ($"..."). In VB.NET entspricht dem C#-string der Datentyp String.

String Interpolation

(siehe „Interpolierte Zeichenfolge“)

Struct

Synonyme:
Struktur, Structure

Kurz:
Ein Struct (Strukturtyp) ist ein Werttyp in C#, der Daten und zugehörige Funktionalität kapseln kann. Structs verfügen über Wertsemantik: Bei Zuweisung, Übergabe als Methodenargument oder Rückgabe wird die gesamte Instanz kopiert.

Länger:
Ein Strukturtyp wird mit dem Schlüsselwort struct definiert und eignet sich für kleine, leichtgewichtige Typen, deren primäre Rolle das Speichern von Daten ist, nicht die Modellierung komplexen Verhaltens; Microsoft empfiehlt Structs insbesondere für Typen, die einen einzelnen Wert oder eine kleine Gruppe zusammengehöriger Werte (grob 16 Byte oder weniger) darstellen und Wertsemantik benötigen. Da ein Struct seine Daten direkt in der Instanz hält statt über eine Referenz auf den Heap, kopiert die Laufzeit bei einer Zuweisung die gesamte Instanz; Änderungen an einer Kopie wirken sich nicht auf die andere aus, da jede Variable eine eigenständige Instanz repräsentiert. Structs können Konstanten, Felder, Methoden, Eigenschaften, Ereignisse, Indexer, Operatoren und Konstruktoren deklarieren, benötigen im Gegensatz zu Klassen aber keine Heap-Allokation; für jeden Strukturtyp (außer ref struct) existieren Konvertierungen zu und von System.Object bzw. System.ValueType. In VB.NET entspricht dem C#-struct die Structure-Anweisung, die ebenfalls einen anpassbaren, zusammengesetzten Werttyp definiert und mit Structure ... End Structure deklariert wird.

Structure

(siehe „Struct“)

Struktur

(siehe „Struct“)

Sub

Synonyme:
Sub-Prozedur

Kurz:
Eine Sub-Prozedur ist in VB.NET ein Block von Anweisungen, eingeschlossen von Sub und End Sub, der eine Aufgabe ausführt, ohne einen Wert an den aufrufenden Code zurückzugeben.

Länger:
Die Syntax zur Deklaration lautet [Modifiers] Sub SubName [(ParameterList)] ... End Sub. Beim Aufruf einer Sub-Prozedur wird ihr Code, beginnend mit der ersten ausführbaren Anweisung, ausgeführt, bis eine End Sub-, Exit Sub- oder Return-Anweisung erreicht wird; danach kehrt die Kontrolle zum aufrufenden Code zurück, ohne einen Rückgabewert zu liefern. Sub-Prozeduren werden sowohl für allgemeine Hilfsroutinen als auch für Ereignisbehandlungsroutinen verwendet, beispielsweise bei Formularereignissen. Die bekannteste Sub-Prozedur ist Sub Main, die als Einstiegspunkt vieler VB.NET-Konsolenanwendungen dient. Das Gegenstück in C# ist eine Methode mit dem Rückgabetyp void; das begriffliche VB.NET-Pendant zu einer wertliefernden Prozedur ist die Function-Prozedur.

Sub-Prozedur

(siehe „Sub“)

Syntax

Synonyme:
—

Kurz:
Die Syntax einer Programmiersprache legt die formalen Regeln fest, nach denen Zeichen zu Token und Token zu gültigen Programmkonstrukten kombiniert werden dürfen; für C# ist sie in der offiziellen ECMA-334-Sprachspezifikation normativ festgelegt.

Länger:
Die C#-Sprachspezifikation unterscheidet zwei Grammatiken: Die lexikalische Grammatik definiert, wie Unicode-Zeichen zu Zeilenendezeichen, Leerraum, Kommentaren, Token und Präprozessordirektiven kombiniert werden; die syntaktische Grammatik definiert, wie diese Token zu gültigen C#-Programmen zusammengesetzt werden. Die offizielle, normative Referenz für Syntax und Semantik von C# ist die von Ecma International veröffentlichte Spezifikation ECMA-334, die zusätzlich auch als ISO/IEC-Norm (z.B. ISO/IEC 23270) übernommen wurde; seit der 6. Ausgabe (2022) wird die Grammatik durchgängig in ANTLR-Notation dargestellt. Die informelle, auf learn.microsoft.com veröffentlichte C#-Sprachreferenz beschreibt dieselben Syntaxregeln in verständlicherer, beispielorientierter Form für Einsteiger und erfahrene Entwickler, ohne den normativen Anspruch der ECMA-Spezifikation zu erheben. Typische Syntaxelemente in C# sind etwa geschweifte Klammern zur Blockbildung, Semikolons als Anweisungsabschluss sowie feste Reihenfolgen von Modifizierern, Typ und Namen bei Deklarationen.

T

Target Framework

Synonyme:
Ziel-Framework

Kurz:
Das Target Framework (Ziel-Framework) gibt an, welche Menge an APIs einer .NET-App oder -Bibliothek zur Verfügung gestellt werden soll, und wird in der Projektdatei über einen Target Framework Moniker (TFM) angegeben.

Länger:
Eine App oder Bibliothek kann als Zielframework entweder eine Version von .NET Standard verwenden, die standardisierte APIs über mehrere .NET-Implementierungen hinweg bereitstellt, oder eine spezifische .NET-Implementierung wie .NET (Core), .NET Framework oder die Universelle Windows-Plattform, wodurch zusätzlich implementierungsspezifische APIs verfügbar werden. Bei paketbasierten Zielframeworks wie .NET 5 und höher, .NET Core und .NET Standard werden die verfügbaren APIs durch die in der App oder Bibliothek enthaltenen NuGet-Pakete definiert; bei .NET Framework hingegen durch die auf dem System installierten Assemblys. In SDK-Style-Projektdateien wird ein einzelnes Zielframework über das Element TargetFramework angegeben (z. B. <TargetFramework>net9.0</TargetFramework>), mehrere Zielframeworks über TargetFrameworks, getrennt durch Semikolons; bei mehreren Zielframeworks lassen sich Assembly-Verweise bedingt einbinden und Code mithilfe von Präprozessorsymbolen (z. B. NET9_0_OR_GREATER) bedingt kompilieren.

Target Framework Moniker

Synonyme:
TFM

Kurz:
Ein Target Framework Moniker (TFM), auf Deutsch Zielframeworkmoniker, ist ein standardisiertes Tokenformat zur Angabe des Zielframeworks einer .NET-App oder -Bibliothek in der Projektdatei.

Länger:
Gebräuchliche TFMs sind beispielsweise net9.0 und net8.0 für aktuelle .NET-Versionen, netstandard2.1 für .NET Standard, netcoreapp3.1 für .NET Core sowie net481 für .NET Framework 4.8.1; für Windows Store, Windows Phone und die Universelle Windows-Plattform existieren eigene TFMs wie uap10.0. Seit .NET 5 gibt es zusätzlich betriebssystemspezifische TFM-Varianten, etwa net9.0-windows, net9.0-android oder net9.0-ios, die zusätzliche, plattformspezifische APIs verfügbar machen und dabei alle APIs des zugrunde liegenden Basis-TFM erben; an ein solches TFM kann optional eine Betriebssystemversion angehängt werden (z. B. net6.0-ios15.0), die festlegt, welche Referenzassemblys beim Kompilieren verwendet werden, ohne die zur Laufzeit unterstützte Mindestversion zu steuern (dafür ist die Projekteigenschaft SupportedOSPlatformVersion vorgesehen). In der Projektdatei wird ein einzelnes TFM über <TargetFramework>, mehrere TFMs über das durch Semikolon getrennte <TargetFrameworks>-Element angegeben; intern übersetzt das .NET SDK den TFM-Wert zusätzlich in kanonische Eigenschaften wie TargetFrameworkMoniker und gegebenenfalls TargetPlatformMoniker.

Task

Synonyme:
—

Kurz:
Task (System.Threading.Tasks.Task) ist eine .NET-Klasse, die einen asynchronen Vorgang ohne Rückgabewert darstellt und die zentrale Grundlage der Task Parallel Library (TPL) sowie des asynchronen Programmiermodells mit async/await bildet.

Länger:
Ein Task-Objekt kapselt die Infrastrukturdetails eines asynchronen oder parallel ausgeführten Vorgangs und stellt Methoden und Eigenschaften bereit, über die der aufrufende Code während der gesamten Lebensdauer der Aufgabe auf deren Zustand zugreifen kann, etwa über die Status-Eigenschaft oder die Eigenschaften IsCanceled, IsCompleted und IsFaulted. In gewisser Weise ähnelt ein Task einem Thread oder einem Arbeitselement des Threadpools, operiert jedoch auf einer höheren Abstraktionsebene: Die tatsächliche Arbeit eines Tasks wird typischerweise asynchron auf einem Thread des Threadpools ausgeführt, nicht synchron auf dem Hauptthread der Anwendung. Tasks unterstützen kooperativen Abbruch über CancellationToken, Fortsetzungen (Continuations), robuste Ausnahmebehandlung mittels AggregateException sowie benutzerdefinierte Planung, und lassen sich unter anderem über Task.Run erzeugen, das die angegebene Arbeit im Threadpool einreiht. Für Vorgänge mit Rückgabewert existiert die davon abgeleitete generische Klasse Task<TResult>.

Task

Synonyme:
—

Kurz:
Task<TResult> ist die generische, von Task abgeleitete .NET-Klasse, die einen asynchronen Vorgang darstellt, der einen Wert vom Typ TResult zurückgibt.

Länger:
Task<TResult> gehört zu den zentralen Bausteinen des aufgabenbasierten asynchronen Musters (Task-based Asynchronous Pattern, TAP) und wird verwendet, wenn ein asynchroner Vorgang – anders als bei einfachem Task – ein Ergebnis liefern soll. Da die Arbeit eines Task<TResult>-Objekts in der Regel asynchron auf einem Thread des Threadpools statt synchron auf dem Hauptthread der Anwendung ausgeführt wird, lässt sich der Zustand über Eigenschaften wie Status, IsCanceled, IsCompleted und IsFaulted abfragen; das eigentliche Ergebnis wird über die Eigenschaft Result abgerufen, wobei ein Zugriff auf Result den aufrufenden Thread blockiert, bis der Task abgeschlossen ist. In asynchronen Methoden wird Task<TResult> üblicherweise mit dem Operator await konsumiert, wodurch der await-Ausdruck direkt den Wert vom Typ TResult liefert, sobald der Vorgang abgeschlossen ist, ohne den Thread zu blockieren. Für performancekritische Szenarien, in denen die Zuweisung eines Referenztyps vermieden werden soll, bietet .NET zusätzlich die werttypbasierte Struktur ValueTask<TResult> als Alternative.

TFM

(siehe „Target Framework Moniker“)

Thread

Synonyme:
—

Kurz:
Ein Thread ist der grundlegende Ausführungspfad eines Programms; in .NET repräsentiert die Klasse System.Threading.Thread einen verwalteten Thread, den man erstellen, starten und dessen Priorität und Zustand man steuern kann.

Länger:
Nach dem Start eines Prozesses erzeugt die Common Language Runtime automatisch einen einzelnen Vordergrund-Thread zur Ausführung des Anwendungscodes; darüber hinaus kann ein Prozess weitere Threads erstellen, um Teile des Programmcodes parallel oder nebenläufig auszuführen, wobei diese im Vorder- oder Hintergrund laufen können. Ein neuer Thread wird erzeugt, indem eine Instanz der Klasse Thread mit einem Delegaten erstellt wird, der die auszuführende Methode repräsentiert; anschließend startet die Methode Thread.Start die Ausführung. Wichtige Eigenschaften der Thread-Klasse sind u.a. IsAlive, IsBackground, Name, Priority und ThreadState; zur kooperativen Beendigung eines Threads wird ein CancellationToken empfohlen, während Thread.Abort (nur im klassischen .NET Framework) eine erzwungene, aber unsichere Beendigung darstellt. In modernem .NET-Code wird die direkte Verwaltung einzelner Thread-Instanzen zunehmend durch höhere Abstraktionen wie den Threadpool oder die Task Parallel Library ersetzt.

Thread Pool

Synonyme:
Threadpool

Kurz:
Der Threadpool (System.Threading.ThreadPool) stellt einer .NET-Anwendung einen vom System verwalteten Pool wiederverwendbarer Arbeiterthreads bereit, sodass Entwickler sich auf Anwendungsaufgaben statt auf manuelle Thread-Verwaltung konzentrieren können.

Länger:
Für kurze Aufgaben, die Hintergrundverarbeitung erfordern, ist der verwaltete Threadpool eine einfache Möglichkeit, mehrere Threads zu nutzen, ohne für jede Operation einen neuen Thread erstellen zu müssen; sobald ein Thread im Pool seine Aufgabe abgeschlossen hat, kehrt er in eine Warteschlange zurück und kann für nachfolgende Arbeit wiederverwendet werden. Pro Prozess existiert nur ein Threadpool, dessen minimale und maximale Thread-Anzahl über ThreadPool.SetMinThreads/SetMaxThreads bzw. GetMinThreads/GetMaxThreads konfiguriert werden kann. Threadpool-Threads werden in .NET für zahlreiche Zwecke genutzt, u.a. für Operationen der Task Parallel Library (TPL), asynchrone E/A-Vervollständigung, Timer-Rückrufe und asynchrone Delegataufrufe; sie sind grundsätzlich Hintergrundthreads mit Standardpriorität und Standardstapelgröße. Der einfachste Weg, den Threadpool zu nutzen, ist die Verwendung der TPL: Typen wie Task und Task<TResult> verwenden standardmäßig Threadpool-Threads zur Ausführung ihrer Arbeit; alternativ kann der Pool direkt über ThreadPool.QueueUserWorkItem angesprochen werden.

Threadpool

(siehe „Thread Pool“)

Trimming

Synonyme:
Assembly Trimming

Kurz:
Trimming (auch Assembly Trimming genannt) ist ein Publish-Feature für eigenständige .NET-Bereitstellungen, das nicht verwendete Teile der Frameworkbibliotheken aus dem veröffentlichten Paket entfernt, um dessen Größe zu reduzieren.

Länger:
Je nach Komplexität der Anwendung wird nur ein Teil der Frameworkassemblys referenziert und nur ein Teil des Codes innerhalb jeder Assembly tatsächlich benötigt; die nicht verwendeten Teile der Bibliotheken werden beim Trimming aus der veröffentlichten Anwendung entfernt. Aktiviert wird das Feature durch Setzen der Eigenschaft <PublishTrimmed>true</PublishTrimmed> in der Projektdatei, wodurch bei der eigenständigen Veröffentlichung (Self-Contained Deployment) eine gekürzte Version der App erzeugt wird; alternativ kann in Visual Studio die Option „Gekürzt veröffentlichen“ gewählt werden. Trimming steht nur für eigenständige Bereitstellungen zur Verfügung, da bei framework-abhängigen Bereitstellungen die Runtime-Bibliotheken ohnehin nicht mitverteilt werden. Historisch wurde zunächst nur auf Assemblyebene gekürzt (Entfernen ganzer, nicht verwendeter Assemblys); seit .NET 5 kann darüber hinaus auch innerhalb von Assemblys auf Typ- und Memberebene gekürzt werden, was die Größe weiter reduziert, aber ein sorgfältiges Prüfen auf Trimming-Kompatibilität (z. B. bei Reflection-Nutzung) erfordert.

Try / Catch / Finally

(siehe „try / catch / finally“)

try / catch / finally

Synonyme:
Try / Catch / Finally

Kurz:
try, catch und finally sind die C#-Schlüsselwörter (in VB.NET: Try, Catch, Finally), mit denen ein Codeblock auf mögliche Ausnahmen überwacht (try), eine aufgetretene Ausnahme behandelt (catch) und abschließend garantiert ausgeführter Aufräumcode definiert wird (finally).

Länger:
Der try-Block umschließt den Code, der eine Ausnahme auslösen könnte. Tritt darin eine Ausnahme auf, wird die Ausführung im try-Block abgebrochen und die Kontrolle an einen passenden catch-Block übergeben, der den jeweiligen Ausnahmetyp angibt; mehrere catch-Blöcke werden von oben nach unten geprüft, wobei nur der erste passende ausgeführt wird und Ausnahmetypen von der spezifischsten zur allgemeinsten Klasse geordnet sein sollten. Ein finally-Block wird immer ausgeführt – unabhängig davon, ob eine Ausnahme aufgetreten ist oder ob ein catch-Block sie behandelt hat – und dient typischerweise dem Freigeben von Ressourcen wie Dateihandles oder Datenbankverbindungen, wobei moderner C#-Code hierfür oft die using-Anweisung bevorzugt. Ein try-Block erfordert mindestens einen catch-Block, einen finally-Block, oder beides; in VB.NET ist der syntaktische Aufbau mit Try…Catch…Finally…End Try analog.

Tupel

(siehe „Tuple“)

Tuple

Synonyme:
Tupel

Kurz:
Ein Tuple (Tupel) gruppiert mehrere Werte in einer einzigen, leichtgewichtigen Struktur, ohne dass ein eigener benannter Typ definiert werden muss. Seit C# 7 sind Tupel als Werttypen (ValueTuple) mit optionalen benannten Elementen implementiert.

Länger:
Tupel sind Werttypen, die im laufenden Code deklariert, von Methoden zurückgegeben und in einzelne Variablen dekonstruiert werden können; sie eignen sich für die schnelle, temporäre Gruppierung zusammengehöriger Werte, etwa wenn eine Methode mehrere Ergebnisse zurückgeben oder ein Koordinatenpaar gespeichert werden soll. Ein Tupel wird deklariert, indem die Elementtypen in Klammern aufgelistet werden, z. B. (int, string); jedem Element kann optional ein Name gegeben werden, um den Code lesbarer zu machen, etwa (int Alter, string Name). Tupeltypen sind Werttypen, und ihre Elemente sind öffentliche Felder – Tupel sind also veränderliche (mutable) Werttypen. Vor C# 7 existierte bereits die generische Klasse System.Tuple, die jedoch ein Referenztyp ist und keine native Dekonstruktions-Syntax unterstützte; das .NET Framework unterstützt Tupel mit ein bis sieben Elementen direkt, größere Tupel lassen sich durch Verschachtelung über die Rest-Eigenschaft abbilden. Tupel enthalten im Gegensatz zu Structs oder Records typischerweise nur Felder, aber keine Methoden oder Eigenschaften.

Typ

Synonyme:
Type

Kurz:
In C# bezeichnet „Typ“ allgemein die Klassifikation eines Werts oder einer Variable, die festlegt, welche Werte zulässig sind und welche Operationen darauf ausgeführt werden können. Jeder Typ ist entweder ein Werttyp oder ein Referenztyp.

Länger:
Die Typen der C#-Sprache sind laut Sprachspezifikation in zwei Hauptkategorien unterteilt: Referenztyp und Werttyp. Ein Werttyp oder ein Referenztyp kann zusätzlich ein generischer Typ sein, der einen oder mehrere Typparameter verwendet. C# ist eine stark typisierte (typsichere) Sprache: Jede Variable und jeder Ausdruck hat einen Typ, und der Compiler prüft zur Kompilierzeit, ob Zuweisungen und Operationen mit den beteiligten Typen kompatibel sind. Man unterscheidet außerdem zwischen dem Kompilierzeittyp (dem im Quellcode deklarierten oder abgeleiteten Typ) und dem Laufzeittyp (dem tatsächlichen Typ der Instanz, auf die eine Variable zur Laufzeit verweist); der Laufzeittyp muss mit dem Kompilierzeittyp identisch sein oder von ihm abgeleitet sein bzw. ihn implementieren. Typen werden in C# entweder vom System vordefiniert (integrierte Typen wie int oder string) oder vom Entwickler benutzerdefiniert (class, struct, enum, interface, record, delegate).

Type

(siehe „Typ“)

Type Conversion

(siehe „Typkonvertierung“)

Type Parameter

(siehe „Typparameter“)

Typkonvertierung

Synonyme:
Type Conversion

Kurz:
Typkonvertierung bezeichnet den Vorgang, einen Wert von einem Typ in einen anderen Typ umzuwandeln. In C# unterscheidet man zwischen impliziten Konvertierungen, die automatisch und ohne Datenverlust erfolgen, und expliziten Konvertierungen (Umwandlungen bzw. Casts), die eine besondere Syntax erfordern.

Länger:
Implizite Konvertierungen benötigen keine spezielle Syntax, da die Konvertierung immer erfolgreich ist und keine Daten verloren gehen; Beispiele sind Konvertierungen von kleineren zu größeren integralen Typen (z. B. int nach long) oder von abgeleiteten Klassen in ihre Basisklassen. Explizite Konvertierungen (Umwandlungen) sind hingegen erforderlich, wenn Informationen verloren gehen könnten oder die Konvertierung zur Laufzeit fehlschlagen kann, etwa bei der numerischen Konvertierung in einen Typ mit geringerer Genauigkeit oder bei der Konvertierung einer Basisklasseninstanz in eine abgeleitete Klasse; dafür wird der Zieltyp in Klammern vor den zu konvertierenden Ausdruck geschrieben (Cast-Ausdruck). Zusätzlich gibt es Konvertierungen mit Hilfsklassen wie System.Convert oder System.BitConverter für den Umgang mit nicht direkt kompatiblen Typen (z. B. Zeichenfolgen und Zahlen), sowie benutzerdefinierte Konvertierungsoperatoren (implicit/explicit), die eigene Umwandlungslogik zwischen Typen definieren. Die C#-Sprachspezifikation listet als implizite Konvertierungen unter anderem Identitäts-, numerische, Enumerations-, Verweis- und Boxkonvertierungen auf.

Typparameter

Synonyme:
Type Parameter

Kurz:
Ein Typparameter ist ein Platzhalter-Bezeichner in einer generischen Klasse, Methode, Struktur oder Schnittstelle, der zur Kompilierzeit durch ein konkretes Typargument ersetzt wird. Typparameter ermöglichen typsicheren, wiederverwendbaren Code ohne Laufzeit-Casts.

Länger:
Generics führen das Konzept der Typparameter in .NET ein: Statt für jeden benötigten Datentyp eine eigene Klasse oder Methode zu schreiben, definiert man eine generische Deklaration mit einem oder mehreren Typparametern (üblicherweise T, TKey, TValue u. Ä.), deren konkreter Typ erst bei der Verwendung im Code angegeben oder vom Compiler abgeleitet wird. Ein Typparameter kann sowohl einen Werttyp als auch einen Referenztyp bezeichnen; er wird laut C#-Sprachspezifikation zur Laufzeit an einen konkreten Typ gebunden, der durch ein Typargument bei der Instanziierung des generischen Typs festgelegt wurde. Typargumente werden in spitzen Klammern (< und >) direkt nach dem Namen des generischen Typs angegeben, z. B. List<int>. Typparameter können durch Constraints (where T : struct, where T : class, where T : new() etc.) eingeschränkt werden, um bestimmte Fähigkeiten des eingesetzten Typs zu garantieren. Ein bekanntes Beispiel ist die generische Klasse List<T> aus der .NET-Klassenbibliothek.

Typumwandlung

(siehe „Cast“)

U

Überladen

Synonyme:
Overload, Overloading, Überladen (Overload)

Kurz:
Überladen (Overloading) bedeutet, mehrere Member desselben Typs (z. B. Methoden, Konstruktoren oder Eigenschaften) mit demselben Namen, aber unterschiedlicher Parameterliste in derselben Klasse zu definieren. Der Compiler wählt anhand der übergebenen Argumente die passende Überladung zur Kompilierzeit aus.

Länger:
Zwei oder mehr Member gelten in C# und VB.NET als überladen, wenn sie vom selben Typ (etwa beide Methoden oder beide Konstruktoren) sind, denselben Namen tragen, sich aber in Anzahl, Reihenfolge oder Datentyp ihrer Parameter unterscheiden; der reine Rückgabetyp allein reicht zur Unterscheidung nicht aus. Da nur Methoden, Konstruktoren und indizierte Eigenschaften Parameter besitzen können, ist Überladen ausschließlich bei diesen Membertypen möglich. Der Compiler entscheidet anhand der beim Aufruf übergebenen Argumente (Anzahl, Typen, Reihenfolge sowie der Parametermodifizierer ref, out und in), welche konkrete Überladung ausgeführt wird – dieser Vorgang wird als Überladungsauflösung (Overload Resolution) bezeichnet und findet zur Kompilierzeit statt, im Gegensatz zum laufzeitbasierten Überschreiben (Override). Ein typisches Beispiel ist eine Methode Add, die einmal zwei int-Werte und einmal zwei double-Werte entgegennimmt. In VB.NET ist das Schlüsselwort Overloads bei überladenen Membern optional, muss aber, sobald ein überladener Member es verwendet, konsistent bei allen gleichnamigen Overloads angegeben werden. Die Microsoft-Entwurfsrichtlinien empfehlen, bei Überladungsfamilien nur die längste (umfassendste) Überladung als virtual bzw. Overridable zu deklarieren und kürzere Überladungen lediglich die längere aufrufen zu lassen.

Überladen (Overload)

(siehe „Überladen“)

Überschreiben

Synonyme:
Override, Overriding, Überschreiben (Override)

Kurz:
Überschreiben (Override) bezeichnet das Bereitstellen einer neuen Implementierung für eine geerbte virtuelle oder abstrakte Methode, Eigenschaft, Indexer oder Ereignis in einer abgeleiteten Klasse. Die überschreibende Methode muss dieselbe Signatur wie die überschriebene Basismethode besitzen.

Länger:
In C# wird eine überschreibende Methode mit dem Modifizierer override gekennzeichnet, der erforderlich ist, um die abstrakte oder virtuelle Implementierung eines geerbten Members zu erweitern oder zu ändern; die zu überschreibende Basismethode muss dabei zwingend virtual, abstract oder ihrerseits bereits override sein – nicht virtuelle oder statische Methoden können nicht überschrieben werden. Eine override-Deklaration darf die Zugänglichkeit der virtuellen Methode nicht verändern (beide müssen denselben Zugriffsmodifizierer haben) und darf nicht zusätzlich mit new, static oder virtual versehen werden; seit neueren C#-Versionen unterstützen überschreibende Methoden zudem kovariante Rückgabetypen, der Rückgabetyp der überschreibenden Methode kann also von dem der Basismethode abgeleitet sein. Von override zu unterscheiden ist der Modifizierer new, der eine Basisklassenmethode lediglich versteckt (hidet), statt sie im Sinne der Polymorphie zu erweitern – wird die Methode über eine Basisklassenreferenz aufgerufen, kommt bei new weiterhin die Basisimplementierung zur Ausführung, während bei override stets die abgeleitete Implementierung greift. In VB.NET entspricht dem override-Modifizierer das Schlüsselwort Overrides, das eine mit Overridable (oder implizit überschreibbare) Basisklassenmethode überschreibt; Signatur, Zugriffsebene und Rückgabetyp müssen dabei exakt übereinstimmen.

Überschreiben (Override)

(siehe „Überschreiben“)

Übersetzer

(siehe „Compiler“)

Unboxing

Synonyme:
—

Kurz:
Unboxing ist die explizite Konvertierung eines zuvor per Boxing verpackten Objekts zurück in seinen ursprünglichen Werttyp. Im Gegensatz zum impliziten Boxing erfordert Unboxing einen expliziten Cast.

Länger:
Beim Unboxing wird der Werttyp aus dem Objekt extrahiert: Der Vorgang prüft zunächst, ob die Objektinstanz tatsächlich ein per Boxing verpackter Wert des angegebenen Werttyps ist, und kopiert anschließend den Wert aus der Instanz in eine Variable des Werttyps. Damit das Unboxing zur Laufzeit erfolgreich ist, muss das zu entpackende Element eine Objektreferenz sein, die zuvor durch Boxing einer Instanz desselben Werttyps erzeugt wurde; der Versuch, null zu entpacken, führt zu einer NullReferenceException, und der Versuch, eine Referenz auf einen inkompatiblen Werttyp zu entpacken, führt zu einer InvalidCastException. Für Enumerationstypen existieren entsprechend Unboxing-Konvertierungen vom Basistyp System.Enum zu jedem konkreten Enumerationstyp. Boxing und Unboxing treten in C# häufig implizit im Hintergrund auf, etwa bei älteren, nicht generischen Collection-Typen wie ArrayList, die intern mit object arbeiten – ein Grund, warum generische Collections wie List<T> vorzuziehen sind.

Unmanaged Code

Synonyme:
Nicht verwalteter Code

Kurz:
Unmanaged Code (nicht verwalteter Code) ist Code, dessen Ausführung nicht von der Common Language Runtime (CLR) kontrolliert wird, sondern direkt vom Betriebssystem geladen und gestartet wird. Typische Beispiele sind klassische C/C++-Programme, COM-Komponenten, ActiveX-Schnittstellen und Win32-API-Funktionen.

Länger:
Im Gegensatz zu Managed Code übernimmt bei Unmanaged Code kein Laufzeitsystem automatisch Aufgaben wie Speicherverwaltung, Garbage Collection oder Typsicherheit – der Programmierer bzw. das Betriebssystem ist dafür allein zuständig. .NET-Anwendungen können über definierte Interop-Mechanismen (z. B. P/Invoke für native DLL-Aufrufe oder COM-Interop) mit Unmanaged Code zusammenarbeiten; dabei „verbirgt“ die CLR laut Microsoft-Dokumentation Unterschiede zwischen den Objektmodellen, um die Interoperation und Migration zu erleichtern. Beim Überschreiten der Grenze zwischen verwaltetem und nicht verwaltetem Code ist besondere Vorsicht geboten, da der aufrufende verwaltete Code den sicheren, überwachten Bereich der Laufzeit verlässt; hierfür existieren spezielle Sicherheitsprüfungen und Berechtigungen. Zu unterscheiden ist Unmanaged Code vom C#-Konzept des „unsafe“-Codes, der zwar mit Zeigern direkt auf Speicher zugreift, aber weiterhin innerhalb der CLR ausgeführt wird.

Using

(siehe „using-Anweisung (Statement)“)

`using`

(siehe „using-Anweisung (Statement)“)

Using Declaration

(siehe „Using-Deklaration“)

using-Anweisung (Statement)

Synonyme:
using, Using, using-Block

Kurz:
Die using-Anweisung (using statement) in C# stellt sicher, dass eine IDisposable-Instanz ordnungsgemäß und deterministisch freigegeben wird, sobald der Steuerungsfluss den zugehörigen Block verlässt – auch im Fehlerfall.

Länger:
Die using-Anweisung hat die Form using (Ausdruck) { ... } bzw. using (Deklaration) { ... }, wobei der Ausdruck oder die Deklaration eine IDisposable-Instanz liefern muss. Verlässt der Programmablauf den Block – gleich ob normal oder durch eine Ausnahme – wird die Dispose-Methode der Instanz automatisch aufgerufen; dies entspricht funktional in etwa einem try/finally-Konstrukt mit Dispose()-Aufruf im finally-Zweig. Eine Variable, die von der using-Anweisung deklariert wird, ist schreibgeschützt und kann innerhalb des Blocks nicht neu zugewiesen oder als ref- bzw. out-Parameter übergeben werden. Das Schlüsselwort Using (mit End Using) übernimmt in VB.NET dieselbe Rolle. Wichtig ist die klare Abgrenzung zur zweiten Bedeutung von using in C#: Während die hier beschriebene using-Anweisung (ebenso wie die using-Deklaration, siehe eigener Eintrag) zur deterministischen Freigabe von IDisposable-Objekten dient, importiert die gleichlautende using-Direktive Typen aus einem Namespace (siehe „Namespace-Import“ bzw. „Globale using-Anweisung“) – beide Verwendungen sind syntaktisch durch das Schlüsselwort using verbunden, aber semantisch vollständig unabhängig.

using-Block

(siehe „using-Anweisung (Statement)“)

Using-Deklaration

Synonyme:
Using Declaration

Kurz:
Die using-Deklaration (seit C# 8.0) ist eine vereinfachte Schreibweise der using-Anweisung ohne umschließende geschweifte Klammern; die deklarierte IDisposable-Variable wird am Ende des Gültigkeitsbereichs freigegeben, in dem sie deklariert wurde.

Länger:
Statt using (var reader = new StreamReader("data.txt")) { ... } kann seit C# 8.0 einfach using var reader = new StreamReader("data.txt"); geschrieben werden. Der Compiler ruft Dispose() für die Variable automatisch am Ende des umschließenden Blocks bzw. der Methode auf, ohne dass ein separater, eingerückter using-Block nötig ist; dies reduziert die Einrückungstiefe, insbesondere wenn mehrere IDisposable-Objekte nacheinander verwendet werden. Wie bei der using-Anweisung ist die deklarierte Variable schreibgeschützt und kann nicht neu zugewiesen oder als ref/out-Parameter übergeben werden. Auch hier gilt die wichtige Unterscheidung: Die using-Deklaration betrifft ausschließlich die Ressourcenfreigabe von IDisposable-Objekten und darf nicht mit der using-Direktive zum Namespace-Import verwechselt werden, obwohl beide dasselbe Schlüsselwort using verwenden.

using-Direktive (C#)

(siehe „Namespace-Import“)

V

Value Type

Synonyme:
Werttyp

Kurz:
Ein Value Type (Werttyp) ist eine Kategorie von C#-Typen, bei der eine Variable die Daten direkt enthält statt einen Verweis auf sie. Zu den Werttypen zählen struct- und enum-Typen, einschließlich aller integrierten numerischen Typen sowie bool und char.

Länger:
Werttypen unterscheiden sich von Referenztypen dadurch, dass eine Variable eines Werttyps eine Instanz des Typs direkt enthält, während eine Variable eines Referenztyps lediglich einen Verweis auf ein Objekt speichert. Wird eine Werttyp-Variable einer anderen zugewiesen, als Methodenargument übergeben oder als Rückgabewert verwendet, wird standardmäßig eine Kopie der zugrundeliegenden Daten erzeugt; Änderungen an einer Kopie wirken sich nicht auf die andere aus (Ausnahme: Parameter mit in, ref oder out). Ein Werttyp ist entweder ein Strukturtyp (struct) oder ein Enumerationstyp (enum); alle vordefinierten einfachen Typen wie int oder double sind ebenfalls Strukturtypen. Enthält ein Werttyp ein Datenmitglied eines Referenztyps, wird bei der Kopie nur der Verweis auf dieses Referenztyp-Objekt kopiert, sodass Kopie und Original weiterhin auf dasselbe Objekt zugreifen. In VB.NET entspricht dem C#-struct die Structure, die ebenfalls einen Werttyp definiert.

`var`

Synonyme:
Implizit typisierte lokale Variable

Kurz:
var ist ein C#-Schlüsselwort, das eine lokale Variable implizit typisiert: Der Compiler leitet den Datentyp der Variable aus dem Ausdruck auf der rechten Seite der Initialisierung ab. Die Variable ist dabei weiterhin stark typisiert, nur die Typangabe im Quellcode entfällt.

Länger:
Das var-Schlüsselwort teilt dem Compiler mit, dass der Datentyp einer lokalen Variable durch den zugewiesenen Initialisierungswert impliziert werden soll; nach der Ableitung verhält sich die Variable exakt so, als wäre der tatsächliche Datentyp explizit bei der Deklaration angegeben worden. Wichtig ist, dass var nicht „variant“ bedeutet und nicht auf schwache Typisierung oder späte Bindung hinweist – der Compiler bestimmt lediglich automatisch den passendsten konkreten Typ. Für implizit typisierte Variablendeklarationen gelten mehrere Einschränkungen: var kann nur verwendet werden, wenn eine lokale Variable im selben Ausdruck deklariert und initialisiert wird; die Variable darf nicht mit null, einer Methodengruppe oder einer anonymen Funktion initialisiert werden; var kann nicht für Felder auf Klassenebene oder für Methodenparameter verwendet werden; und es können nicht mehrere implizit typisierte Variablen in derselben Anweisung deklariert werden. In einem aktivierten Nullable-Kontext leitet der Compiler bei var und einem Referenztyp-Initialisierungsausdruck stets einen nullbaren Referenztyp ab. Die entsprechende Funktionalität in VB.NET wird als lokaler Typrückschluss (Local Type Inference) bezeichnet: Bei einer Dim-Deklaration ohne As-Klausel und aktiviertem Option Infer On (dem Standard) leitet der Compiler den Datentyp ebenfalls aus dem Initialisierungsausdruck ab, z. B. Dim qty = 5.

Variable

Synonyme:
—

Kurz:
Eine Variable ist ein benannter Speicherort mit einem festgelegten Typ, der bestimmt, welche Werte in ihr abgelegt werden können. C# ist eine typsichere Sprache, die garantiert, dass in Variablen gespeicherte Werte stets vom passenden Typ sind.

Länger:
Laut C#-Sprachspezifikation stellen Variablen Speicherorte dar; C# definiert acht Variablenkategorien: statische Variablen, Instanzvariablen, Arrayelemente, Wertparameter, Eingabeparameter (in), Referenzparameter (ref), Ausgabeparameter (out) und lokale Variablen. Jede Variable hat einen Typ, der ihren zulässigen Wertebereich sowie die auf ihr ausführbaren Operationen festlegt; lokale Variablen werden typischerweise innerhalb eines Methodenkörpers deklariert und können entweder explizit mit einem Typnamen oder implizit mit dem Schlüsselwort var deklariert werden. Eine Sonderform ist das „Discard“ (_), eine lokale Variable ohne Namen, die eingesetzt wird, wenn ein Rückgabewert bewusst ignoriert werden soll. In VB.NET werden Variablen mit der Dim-Anweisung deklariert, üblicherweise mit einer As-Klausel zur Typangabe, etwa Dim zahl As Integer; wird keine As-Klausel angegeben und ist Option Infer aktiviert, leitet der Compiler den Typ aus dem Initialisierungsausdruck ab.

VB.NET

(siehe „Visual Basic“)

vbc

(siehe „Visual-Basic-Compiler“)

.vbproj

(siehe „Projektdatei“)

Vererbung

Synonyme:
Inheritance

Kurz:
Vererbung ermöglicht es, eine neue Klasse (abgeleitete Klasse) zu definieren, die das Verhalten einer bestehenden Klasse (Basisklasse) wiederverwendet, erweitert oder verändert. Sie ist neben Kapselung und Polymorphismus eines der drei Hauptmerkmale der objektorientierten Programmierung.

Länger:
Wenn eine Klasse von einer anderen Klasse abgeleitet wird, erhält die abgeleitete Klasse implizit alle Member der Basisklasse mit Ausnahme von Konstruktoren und Finalizern, ohne dass diese neu implementiert werden müssen; zusätzliche Member können in der abgeleiteten Klasse ergänzt werden. C# und .NET unterstützen bei Klassen ausschließlich Einfachvererbung – eine Klasse kann also nur von genau einer Basisklasse erben –, wobei Vererbung transitiv ist, sodass sich Vererbungshierarchien über mehrere Ebenen bilden lassen. In C# wird die Basisklasse durch einen Doppelpunkt nach dem abgeleiteten Klassennamen angegeben (class Derived : Base), in VB.NET geschieht dies mit dem Schlüsselwort Inherits innerhalb des Klassenkörpers. Üblicherweise drückt Vererbung eine „ist-ein“-Beziehung aus, bei der die abgeleitete Klasse eine spezialisierte Version der Basisklasse darstellt. Da C# keine Mehrfachvererbung von Klassen erlaubt, wird für vergleichbare Zwecke häufig die Implementierung mehrerer Schnittstellen (Interfaces) genutzt. Eng mit Vererbung verknüpft sind die Schlüsselwörter virtual, override und abstract (bzw. Overridable, Overrides und MustOverride/MustInherit in VB.NET), mit denen das Verhalten geerbter Methoden in abgeleiteten Klassen angepasst werden kann.

Verschachtelte Klasse

(siehe „Geschachtelte Klasse“)

Verwalteter Code

(siehe „Managed Code“)

Virtual Method

(siehe „Virtuelle Methode“)

Virtuelle Methode

Synonyme:
Virtual Method

Kurz:
Eine virtuelle Methode ist eine Methode, die mit dem Modifizierer virtual deklariert wird und dadurch von abgeleiteten Klassen mit override überschrieben werden kann. Sie ist die Grundlage für Laufzeitpolymorphismus in C#.

Länger:
Standardmäßig sind Methoden in C# nicht virtuell und können daher nicht überschrieben werden; erst der Modifizierer virtual bei einer Methoden-, Eigenschaften-, Indexer- oder Ereignisdeklaration in der Basisklasse erlaubt es einer abgeleiteten Klasse, mittels override eine eigene, abweichende Implementierung bereitzustellen. Wird eine virtuelle Methode zur Laufzeit über eine Variable vom Typ der Basisklasse aufgerufen, ermittelt die Common Language Runtime (CLR) den tatsächlichen Laufzeittyp des referenzierten Objekts und ruft die überschriebene Version in der am weitesten abgeleiteten Klasse auf, sofern eine solche existiert – andernfalls wird die ursprüngliche Implementierung der Basisklasse ausgeführt. Dieser Mechanismus, bei dem der aufgerufene Methodencode nicht zur Kompilierzeit, sondern erst zur Laufzeit anhand des tatsächlichen Objekttyps bestimmt wird, ist die technische Grundlage für Polymorphismus. Eine virtuelle Methode kann, muss aber nicht überschrieben werden; abstrakte Methoden hingegen sind implizit virtuell und müssen zwingend implementiert werden. In VB.NET entspricht dem C#-Schlüsselwort virtual der Modifizierer Overridable; eine mit Overridable gekennzeichnete Methode oder Eigenschaft kann in einer abgeleiteten Klasse mit Overrides überschrieben werden.

Visual Basic

Synonyme:
VB.NET

Kurz:
Visual Basic (in der aktuellen, auf dem .NET-Framework bzw. .NET aufbauenden Version auch Visual Basic .NET oder VB.NET genannt) ist eine von Microsoft entwickelte, objektorientierte Programmiersprache. Sie ist Teil der .NET-Plattform und wird syntaktisch stark von den Sprachwurzeln des klassischen Visual Basic (VB6) und VBA geprägt, unterscheidet sich technisch aber grundlegend von diesen Vorgängern.

Länger:
Visual Basic .NET wurde von Microsoft im Zuge der Einführung des .NET-Frameworks als Nachfolger von Visual Basic 6.0 geschaffen und vereint syntaktische Elemente von VB6, VBA und VBScript in einer modernen, vollständig objektorientierten Sprache, die auf der Common Language Infrastructure (CLI) aufbaut. Anders als VB6 ist VB.NET streng typisiert (optional über Option Strict erzwingbar), unterstützt Vererbung, Schnittstellen, generische Typen und wird wie C# in Zwischencode (IL) kompiliert und von der .NET-Laufzeit ausgeführt. Die Sprache wird in der offiziellen Dokumentation unter dem Namen „Visual Basic“ geführt und ist Teil der .NET-Sprachfamilie neben C# und F#. Heute wird VB.NET von Microsoft primär für die Pflege bestehender Anwendungen empfohlen, während für Neuentwicklungen meist C# bevorzugt wird.

Visual-Basic-Compiler

Synonyme:
vbc

Kurz:
Der Visual-Basic-Compiler übersetzt Visual-Basic-.NET-Quellcode in Common Intermediate Language (CIL); der klassische Befehlszeilencompiler heißt vbc.exe (vbc), wird heute jedoch für Kompilierungen außerhalb der Visual-Studio-IDE zunehmend durch dotnet build ersetzt.

Länger:
Visual Basic stellt mit dem Befehlszeilencompiler vbc eine Alternative zum Kompilieren von Programmen innerhalb der integrierten Entwicklungsumgebung von Visual Studio bereit; er unterstützt Optionen, die Eingabe- und Ausgabedateien, referenzierte Assemblys sowie Debug- und Präprozessoreinstellungen steuern, etwa vbc -target:library File.vb zum Erzeugen einer DLL oder vbc -out:My.exe File.vb zur Angabe des Ausgabedateinamens. Laut offizieller Microsoft-Dokumentation wird vbc inzwischen ausdrücklich als „Legacy“-Befehlszeilencompiler bezeichnet: Der Befehl dotnet build ersetzt vbc heute als primäres Werkzeug zum Kompilieren von Visual-Basic-Programmen außerhalb der Visual-Studio-IDE. In MSBuild wird der Compiler über die Vbc-Aufgabe eingebunden, die vbc.exe umschließt und ausführbare Dateien (.exe), dynamische Linkbibliotheken (.dll) oder Codemodule (.netmodule) erzeugt; moderne SDK-Style-.vbproj-Projekte rufen den Compiler in der Regel indirekt über dotnet build bzw. MSBuild auf, statt vbc.exe direkt in der Befehlszeile zu verwenden.

Void

Synonyme:
—

Kurz:
void ist ein Schlüsselwort in C#, das als Rückgabetyp einer Methode oder lokalen Funktion angibt, dass diese keinen Wert zurückgibt. void kann nicht als Typ einer Variablen verwendet werden.

Länger:
Verwendet man void als Rückgabetyp einer Methode, signalisiert dies, dass die Methode keinen Wert an den Aufrufer zurückliefert; im Unterschied dazu ist void in der Parameterliste einer Methode nicht zulässig. Eine Methode ohne Parameter und ohne Rückgabewert wird beispielsweise als void SampleMethod(); deklariert. Zusätzlich kann void in einem unsicheren (unsafe) Kontext als Bestandteil eines Zeigertyps verwendet werden, um einen Zeiger auf einen unbekannten Typ zu deklarieren (void*). void ist ein Alias für den .NET-Typ System.Void; da void jedoch keinen Wert repräsentiert, unterscheidet es sich grundlegend von anderen Typen und kann nicht instanziiert oder als Variablentyp verwendet werden. In VB.NET existiert keine direkte void-Entsprechung als Schlüsselwort; stattdessen wird eine Prozedur ohne Rückgabewert mit Sub (statt Function) deklariert.

W

Werttyp

(siehe „Value Type“)

WithEvents

Synonyme:
—

Kurz:
WithEvents ist ein VB.NET-Schlüsselwort, das bei der Deklaration einer Objektvariablen angibt, dass diese zum Behandeln von Ereignissen des referenzierten Objekts verwendet werden soll, üblicherweise in Kombination mit der Handles-Klausel.

Länger:
Eine mit WithEvents deklarierte Variable muss klassenebenenweit (also nicht lokal in einer Prozedur) deklariert werden und erfordert immer die Angabe eines konkreten Objekttyps über die As-Klausel; ein generischer Object-Typ ist nicht zulässig. Nach der Deklaration kann eine Ereignisbehandlungsmethode über Sub ... Handles VariablenName.EreignisName mit dem jeweiligen Ereignis der Instanz verknüpft werden. Dieser Mechanismus stellt in VB.NET das direkte Gegenstück zur klassischen VB6/VBA-Ereignisbehandlung dar und ist eine Alternative zur dynamischeren, mit AddHandler/RemoveHandler arbeitenden Ereignisverknüpfung, die – im Unterschied zu WithEvents – Ereignisquellen zur Laufzeit wechseln kann. C# besitzt keine direkte Entsprechung zu WithEvents; dort werden Ereignisse stets explizit mit dem +=-Operator abonniert.

X

XML

Synonyme:
Extensible Markup Language

Kurz:
XML (Extensible Markup Language) ist eine erweiterbare Auszeichnungssprache zur Darstellung hierarchisch strukturierter Daten in einem sowohl für Menschen als auch für Maschinen lesbaren Textformat.

Länger:
XML wurde vom World Wide Web Consortium (W3C) entwickelt und definiert Regeln zur Kodierung von Dokumenten, die eine hierarchische Baumstruktur aus Elementen, Attributen und Textinhalten abbilden. Anders als HTML legt XML keine festen Tag-Namen vor, sondern erlaubt es, eigene Auszeichnungselemente für den jeweiligen Anwendungsfall zu definieren, weshalb es als Metasprache gilt. In .NET wird XML unter anderem über die Klassen im Namespace System.Xml (z. B. XmlDocument, XmlReader, XmlWriter) sowie über LINQ to XML (XDocument, XElement) verarbeitet; zur Umwandlung von Objekten in XML-Dokumente und zurück dient die XML-Serialisierung mit der Klasse XmlSerializer. XML wird u. a. für Konfigurationsdateien, Web Services (z. B. SOAP) und Dokumentenformate eingesetzt und steht in Konkurrenz zu JSON als Austauschformat.

XML Literals (VB.NET-Feature)

(siehe „XML-Literale“)

XML-Literale

Synonyme:
XML Literals (VB.NET-Feature)

Kurz:
XML-Literale sind ein Visual-Basic-spezifisches Sprachfeature, mit dem XML-Code direkt in Visual-Basic-Quelltext eingebettet werden kann; der Compiler übersetzt diese Literale in LINQ-to-XML-Objekte.

Länger:
Die XML-Literalsyntax in Visual Basic ähnelt der XML-1.0-Syntax und erlaubt es, gültige XML-Fragmente direkt im Code zu schreiben, ohne diese als Zeichenketten zu maskieren. Ein XML-Elementliteral erzeugt zur Laufzeit ein XElement-Objekt, ein XML-Dokumentliteral (eingeleitet mit der XML-Deklaration <?xml version="1.0"?>) ein XDocument-Objekt; der Visual-Basic-Compiler übersetzt die Literale dabei in entsprechende Aufrufe der LINQ-to-XML-Konstruktoren wie XElement, XAttribute und XProcessingInstruction. In XML-Literale lassen sich Visual-Basic-Ausdrücke einbetten (Syntax <%= Ausdruck %>), auch als Ergebnis von LINQ-Abfragen, sodass dynamischer Inhalt programmgesteuert erzeugt werden kann. Dieses Feature ist ausschließlich in Visual Basic (VB.NET) verfügbar; C# besitzt keine vergleichbare native Syntax zur direkten Einbettung von XML in den Quellcode, sondern muss XML-Inhalte über Zeichenketten oder API-Aufrufe der Klassen XElement/XDocument konstruieren.

Y

`yield`

Synonyme:
yield return, yield break

Kurz:
Die yield-Anweisung wird in einer Iteratormethode verwendet, um entweder den nächsten Wert einer Sequenz bereitzustellen (yield return) oder das Ende der Iteration explizit zu signalisieren (yield break).

Länger:
yield ist in C# ein kontextbezogenes Schlüsselwort, das nur innerhalb von Iteratorblöcken erkannt wird und stets in Verbindung mit return oder break steht – ein alleinstehendes yield ist nicht zulässig. yield return <Ausdruck>; fügt der Ergebnissequenz ein Element hinzu und hält die Ausführung der Methode an dieser Stelle an, bis der Aufrufer das nächste Element anfordert; yield break; beendet die Iteration sofort und unwiderruflich, ohne dass ein reguläres return mit Wert verwendet werden dürfte, da beide Formen sich gegenseitig ausschließen. Laut deutscher Wikipedia zu den Sprachelementen von C# wird bei jedem Aufruf von yield return bis zum Verlassen der Methode ein neues Element der Sequenz hinzugefügt; wird die Anweisung nie erreicht, bleibt die zurückgegebene Sequenz leer. Einschränkungen bestehen unter anderem darin, dass yield-Anweisungen nicht in anonymen Methoden, in unsafe-Blöcken oder in Methoden mit ref- bzw. out-Parametern verwendet werden dürfen und yield return nicht innerhalb eines catch- oder finally-Blocks bzw. eines try-Blocks mit zugehörigem catch stehen darf.

yield break

(siehe „yield“)

yield return

(siehe „yield“)

Z

Zeichenfolge

(siehe „String“)

Ziel-Framework

(siehe „Target Framework“)

Zugriffsmodifizierer

(siehe „Access Modifier“)