Überblick über C#A tour of the C# language

C# (Aussprache „C Sharp“) ist eine moderne, objektorientierte und typsichere Programmiersprache.C# (pronounced "See Sharp") is a modern, object-oriented, and type-safe programming language. C# hat seine Wurzeln in der C-Sprachenfamilie und ist Programmierern, die mit C, C++, Java und JavaScript arbeiten, sofort vertraut.C# has its roots in the C family of languages and will be immediately familiar to C, C++, Java, and JavaScript programmers. Diese Einführung bietet einen Überblick über die wichtigsten Komponenten der Sprache in C# 8 und früheren Versionen.This tour provides an overview of the major components of the language in C# 8 and earlier. Wenn Sie die Sprache anhand von interaktiven Beispielen kennenlernen möchten, arbeiten Sie die Tutorials auf der Seite Einführung in C# durch.If you want to explore the language through interactive examples, try the introduction to C# tutorials.

C# ist eine objektorientierte, komponentenorientierte Programmiersprache.C# is an object-oriented, component-oriented programming language. C# bietet Sprachkonstrukte zur direkten Unterstützung dieser Konzepte, was C# zu einer natürlichen Sprache macht, in der Softwarekomponenten erstellt und verwendet werden.C# provides language constructs to directly support these concepts, making C# a natural language in which to create and use software components. Seit Veröffentlichung wurden C# Features hinzugefügt, um neue Workloads und Methoden zur Gestaltung von Software zu unterstützen.Since its origin, C# has added features to support new workloads and emerging software design practices.

Einige C#-Features helfen beim Entwickeln stabiler und dauerhafter Anwendungen.Several C# features aid in the construction of robust and durable applications. Die Garbage Collection gibt Arbeitsspeicher automatisch frei, der von unerreichbaren nicht verwendeten Objekten belegt wird.Garbage collection automatically reclaims memory occupied by unreachable unused objects. Die Ausnahmebehandlung bietet einen strukturierten und erweiterbaren Ansatz zur Fehlererkennung und Wiederherstellung.Exception handling provides a structured and extensible approach to error detection and recovery. Lambda-Ausdrücke unterstützen funktionale Programmiertechniken.Lambda expressions support functional programming techniques. Die Abfragesyntax schafft ein einheitliches Muster für das Arbeiten mit Daten aus beliebigen Quellen.Query syntax creates a common pattern for working with data from any source. Dank Sprachunterstützung für asynchrone Vorgänge wird eine Syntax für den Aufbau verteilter Systeme bereitgestellt.Language support for asynchronous operations provides syntax for building distributed systems. Der Musterabgleich bietet eine Syntax, mit der sich Daten und Algorithmen in modernen verteilten Systemen leicht voneinander trennen lassen.Pattern matching provides syntax to easily separate data from algorithms in modern distributed systems. C# bietet ein einheitliches Typsystem.C# has a unified type system. Alle C#-Typen, einschließlich primitiver Typen wie int und double, erben von einem einzelnen object-Stammtyp.All C# types, including primitive types such as int and double, inherit from a single root object type. Allen Typen teilen sich eine Reihe allgemeiner Vorgänge.All types share a set of common operations. Werte jeglicher Art können einheitlich gespeichert, transportiert und bearbeitet werden.Values of any type can be stored, transported, and operated upon in a consistent manner. Darüber hinaus unterstützt C# benutzerdefinierte Verweis- und Werttypen.Furthermore, C# supports both user-defined reference types and value types. C# ermöglicht die dynamische Zuteilung von Objekten und die Inlinespeicherung schlanker Strukturen.C# allows dynamic allocation of objects and in-line storage of lightweight structures.

In C# dient die Versionsverwaltung zum Sicherstellen, dass sich Programme und Bibliotheken im Laufe der Zeit kompatibel weiterentwickeln können.C# emphasizes versioning to ensure programs and libraries can evolve over time in a compatible manner. Zu den Aspekten der Entwicklung von C#, die direkt von Überlegungen bei der Versionskontrolle beeinflusst wurden, gehören die separaten virtual- und override-Modifizierer, die Regeln für die Überladungsauflösung und die Unterstützung für explizite Schnittstellenmember-Deklarationen.Aspects of C#'s design that were directly influenced by versioning considerations include the separate virtual and override modifiers, the rules for method overload resolution, and support for explicit interface member declarations.

Hello WorldHello world

Das Programm „Hello, World“ wird für gewöhnlich zur Einführung einer Programmiersprache verwendet.The "Hello, World" program is traditionally used to introduce a programming language. Hier ist es in C#:Here it is in C#:

using System;

class Hello
{
    static void Main()
    {
        Console.WriteLine("Hello, World");
    }
}

Das Programm „Hello, World“ wird mit einer using-Richtlinie gestartet, die auf den System-Namespace verweist.The "Hello, World" program starts with a using directive that references the System namespace. Namespaces bieten eine hierarchische Möglichkeit zum Organisieren von C#-Programmen und -Bibliotheken.Namespaces provide a hierarchical means of organizing C# programs and libraries. Namespaces enthalten Typen und andere Namespaces. Beispiel: Der System-Namespace enthält eine Reihe von Typen, wie etwa die Console-Klasse, auf die im Programm verwiesen wird, und eine Reihe anderer Namespaces, wie etwa IO und Collections.Namespaces contain types and other namespaces—for example, the System namespace contains a number of types, such as the Console class referenced in the program, and a number of other namespaces, such as IO and Collections. Eine using-Richtlinie, die auf einen bestimmten Namespace verweist, ermöglicht die nicht qualifizierte Nutzung der Typen, die Member dieses Namespace sind.A using directive that references a given namespace enables unqualified use of the types that are members of that namespace. Aufgrund der using-Direktive kann das Programm Console.WriteLine als Abkürzung für System.Console.WriteLine verwenden.Because of the using directive, the program can use Console.WriteLine as shorthand for System.Console.WriteLine.

Die Hello-Klasse, die vom Programm „Hello, World“ deklariert wird, verfügt über einen einzelnen Member: die Main-Methode.The Hello class declared by the "Hello, World" program has a single member, the method named Main. Die Main-Methode wird mit dem Modifizierer static deklariert.The Main method is declared with the static modifier. Auch wenn Instanzmethoden mit dem Schlüsselwort this auf eine bestimmte einschließende Objektinstanz verweisen können, agieren statische Methoden ohne Verweis auf ein bestimmtes Objekt.While instance methods can reference a particular enclosing object instance using the keyword this, static methods operate without reference to a particular object. Gemäß Konvention fungiert eine statische Methode mit der Bezeichnung Main als Einstiegspunkt eines C#-Programms.By convention, a static method named Main serves as the entry point of a C# program.

Die Ausgabe des Programms wird anhand der WriteLine-Methode der Console-Klasse im System-Namespace generiert.The output of the program is produced by the WriteLine method of the Console class in the System namespace. Diese Klasse wird anhand der Standardklassenbibliotheken bereitgestellt, auf die standardmäßig automatisch vom Compiler verwiesen wird.This class is provided by the standard class libraries, which, by default, are automatically referenced by the compiler.

Typen und VariablenTypes and variables

Es gibt zwei Arten von Typen in C#: Werttypen und Verweistypen.There are two kinds of types in C#: value types and reference types. Variablen von Werttypen enthalten ihre Daten direkt, Variablen von Verweistypen speichern hingegen Verweise auf ihre Daten – letztere werden als Objekte bezeichnet.Variables of value types directly contain their data whereas variables of reference types store references to their data, the latter being known as objects. Dank Verweistypen können zwei Variablen auf das gleiche Objekt verweisen. So können auf eine Variable angewendete Vorgänge das Objekt beeinflussen, auf das die andere Variable verweist.With reference types, it's possible for two variables to reference the same object and possible for operations on one variable to affect the object referenced by the other variable. Bei Werttypen besitzen die Variablen jeweils eigene Kopien der Daten. Auf eine Variable angewendete Vorgänge können sich nicht auf die andere Variable auswirken (außer im Fall der Parametervariablen ref und out).With value types, the variables each have their own copy of the data, and it isn't possible for operations on one to affect the other (except for ref and out parameter variables).

Ein Bezeichner ist ein Variablenname.An identifier is a variable name. Ein Bezeichner ist eine Sequenz von Unicode-Zeichen ohne Leerzeichen.An identifier is a sequence of unicode characters without any whitespace. Ein Bezeichner kann ein in C# reserviertes Wort sein, wenn ihm das Präfix @ vorangestellt ist.An identifier may be a C# reserved word, if it is prefixed by @. Das kann bei der Interaktion mit anderen Sprachen nützlich sein.That can be useful when interacting with other languages.

C#-Werttypen sind weiter unterteilt in einfache Typen, Enumerationstypen, Strukturtypen, Nullable-Werttypen und Tuple-Werttypen.C#'s value types are further divided into simple types, enum types, struct types, nullable value types and tuple value types. C#-Verweistypen sind weiter unterteilt in Klassentypen, Schnittstellentypen, Arraytypen und Delegattypen.C#'s reference types are further divided into class types, interface types, array types, and delegate types.

Im Folgenden finden Sie eine Übersicht des C#-Typsystems.The following outline provides an overview of C#'s type system.

C#-Programme verwenden Typdeklarationen, um neue Typen zu erstellen.C# programs use type declarations to create new types. Eine Typdeklaration gibt den Namen und die Member des neuen Typs an.A type declaration specifies the name and the members of the new type. Sechs Typkategorien von C# können von Benutzern definiert werden: Klassentypen, Strukturtypen, Schnittstellentypen, Enumerationstypen, Delegattypen und Tuple-Werttypen.Six of C#'s categories of types are user-definable: class types, struct types, interface types, enum types, delegate types and tuple value types.

  • Ein class-Typ definiert eine Datenstruktur, die Datenmember (Felder) und Funktionsmember (Methoden, Eigenschaften usw.) enthält.A class type defines a data structure that contains data members (fields) and function members (methods, properties, and others). Klassentypen unterstützen einzelne Vererbung und Polymorphie. Dies sind Mechanismen, durch die abgeleitete Klassen erweitert und Basisklassen spezialisiert werden können.Class types support single inheritance and polymorphism, mechanisms whereby derived classes can extend and specialize base classes.
  • Ein struct-Typ ähnelt einem Klassentyp, da er eine Struktur mit Datenmembern und Funktionsmembern darstellt.A struct type is similar to a class type in that it represents a structure with data members and function members. Im Gegensatz zu Klassen sind Strukturen Werttypen, die in der Regel keine Heapzuordnung erfordern.However, unlike classes, structs are value types and don't typically require heap allocation. Strukturtypen unterstützen keine benutzerdefinierte Vererbung, und alle Strukturtypen erben implizit vom Typ object.Struct types don't support user-specified inheritance, and all struct types implicitly inherit from type object.
  • Ein interface-Typ definiert einen Vertrag als benannte Gruppe öffentlicher Member.An interface type defines a contract as a named set of public members. Ein class- oder struct-Typ, der einen interface-Typ implementiert, muss Implementierungen der Member der Schnittstelle bereitstellen.A class or struct that implements an interface must provide implementations of the interface's members. Eine interface kann von mehreren Basisschnittstellen erben, und eine class oder struct kann mehrere Schnittstellen implementieren.An interface may inherit from multiple base interfaces, and a class or struct may implement multiple interfaces.
  • Ein delegate-Typ stellt Verweise auf Methoden mit einer bestimmten Parameterliste und dem Rückgabetyp dar.A delegate type represents references to methods with a particular parameter list and return type. Delegate ermöglichen die Behandlung von Methoden als Entitäten, die Variablen zugewiesen und als Parameter übergeben werden können.Delegates make it possible to treat methods as entities that can be assigned to variables and passed as parameters. Delegate werden analog zu Funktionstypen von funktionalen Sprachen bereitgestellt.Delegates are analogous to function types provided by functional languages. Außerdem ähneln sie konzeptionell Funktionszeigern, die es in einigen anderen Sprachen gibt.They're also similar to the concept of function pointers found in some other languages. Im Gegensatz zu Funktionszeigern sind Delegaten objektorientiert und typsicher.Unlike function pointers, delegates are object-oriented and type-safe.

Die Typen, class, struct, interface und delegate unterstützen Generics, wodurch sie mit anderen Typen parametrisiert werden können.The class, struct, interface, and delegate types all support generics, whereby they can be parameterized with other types.

C# unterstützt ein- und mehrdimensionale Arrays aller beliebigen Typen.C# supports single-dimensional and multi-dimensional arrays of any type. Im Gegensatz zu den oben aufgeführten Typen müssen Arraytypen nicht deklariert werden, bevor sie verwendet werden können.Unlike the types listed above, array types don't have to be declared before they can be used. Stattdessen werden Arraytypen erstellt, indem hinter einen Typnamen eckige Klammern gesetzt werden.Instead, array types are constructed by following a type name with square brackets. int[] ist beispielsweise ein eindimensionales Array aus int, int[,] ein zweidimensionales Array aus int, während int[][] ein eindimensionales Array aus eindimensionalen Arrays oder ein Jagged Array aus int ist.For example, int[] is a single-dimensional array of int, int[,] is a two-dimensional array of int, and int[][] is a single-dimensional array of single-dimensional arrays, or a "jagged" array, of int.

Nullable-Typen erfordern keine getrennte Definition.Nullable types don't require a separate definition. Für jeden Non-Nullable-Typ T gibt es einen entsprechenden Nullable-Typ T?, der einen zusätzlichen Wert, null, enthalten kann.For each non-nullable type T, there's a corresponding nullable type T?, which can hold an additional value, null. Beispielsweise ist int? ein Typ, der jeden 32-Bit-Ganzzahlwert oder den Wert null enthalten kann. string? ist ein Typ, der beliebige string-Typen oder den Wert null enthalten kann.For instance, int? is a type that can hold any 32-bit integer or the value null, and string? is a type that can hold any string or the value null.

Das C#-Typsystem ist dahingehend vereinheitlicht, dass ein Wert eines beliebigen Typs als object behandelt werden kann.C#'s type system is unified such that a value of any type can be treated as an object. Jeder Typ in C# ist direkt oder indirekt vom object-Klassentyp abgeleitet, und object ist die ultimative Basisklasse aller Typen.Every type in C# directly or indirectly derives from the object class type, and object is the ultimate base class of all types. Werte von Verweistypen werden als Objekte behandelt, indem die Werte einfach als Typ object angezeigt werden.Values of reference types are treated as objects simply by viewing the values as type object. Werte von Werttypen werden durch Ausführen von Boxing- und Unboxingvorgängen als Objekte behandelt.Values of value types are treated as objects by performing boxing and unboxing operations. Im folgenden Beispiel wird ein int-Wert in ein object und wieder in einen int-Wert konvertiert.In the following example, an int value is converted to object and back again to int.

int i = 123;
object o = i;    // Boxing
int j = (int)o;  // Unboxing

Wenn ein Wert eines Werttyps einem object-Verweis zugewiesen wird, wird eine „Box“ zugeordnet, die den Wert enthalten soll.When a value of a value type is assigned to an object reference, a "box" is allocated to hold the value. Bei dieser Box handelt es sich um eine Instanz eines Verweistyps, und der Wert wird in diese Box kopiert.That box is an instance of a reference type, and the value is copied into that box. Wenn umgekehrt ein object-Verweis in einen Werttyp umgewandelt wird, wird überprüft, ob der object-Typ, auf den verwiesen wird, eine Box des korrekten Werttyps ist.Conversely, when an object reference is cast to a value type, a check is made that the referenced object is a box of the correct value type. Nach erfolgreicher Überprüfung wird der Wert in der Box zum Werttyp kopiert.If the check succeeds, the value in the box is copied to the value type.

Aus dem einheitlichen C#-Typensystem resultiert, dass Werttypen „bei Nachfrage“ als object-Verweise behandelt werden.C#'s unified type system effectively means that value types are treated as object references "on demand." Aufgrund der Vereinheitlichung können Bibliotheken für allgemeine Zwecke, die den Typ object verwenden, mit allen Typen verwendet werden können, die von object abgeleitet werden, wozu sowohl Verweis- als auch Werttypen zählen.Because of the unification, general-purpose libraries that use type object can be used with all types that derive from object, including both reference types and value types.

Es gibt mehrere Arten von Variablen in C#, einschließlich Feldern, Arrayelementen, lokalen Variablen und Parametern.There are several kinds of variables in C#, including fields, array elements, local variables, and parameters. Variablen stellen Speicherorte dar.Variables represent storage locations. Jede Variable hat, wie nachstehend gezeigt, einen Typ, der bestimmt, welche Werte in der Variablen gespeichert werden können.Every variable has a type that determines what values can be stored in the variable, as shown below.

  • Nicht auf NULL festlegbarer WerttypNon-nullable value type
    • Ein Wert genau dieses TypsA value of that exact type
  • Auf NULL festlegbarer WerttypNullable value type
    • Ein null-Wert oder ein Wert genau dieses TypsA null value or a value of that exact type
  • objectobject
    • Ein null-Verweis, ein Verweis auf ein Objekt eines beliebigen Verweistyps oder ein Verweis auf einen geschachtelten Wert eines beliebigen WerttypsA null reference, a reference to an object of any reference type, or a reference to a boxed value of any value type
  • KlassentypClass type
    • Ein null-Verweis, ein Verweis auf eine Instanz dieses Klassentyps oder ein Verweis auf eine Instanz einer Klasse, die von diesem Klassentyp abgeleitet istA null reference, a reference to an instance of that class type, or a reference to an instance of a class derived from that class type
  • SchnittstellentypInterface type
    • Ein null-Verweis, ein Verweis auf eine Instanz eines Klassentyps, der diesen Schnittstellentyp implementiert, oder ein Verweis auf einen geschachtelten Wert eines Werttyps, der diesen Schnittstellentyp implementiertA null reference, a reference to an instance of a class type that implements that interface type, or a reference to a boxed value of a value type that implements that interface type
  • ArraytypArray type
    • Ein null-Verweis, ein Verweis auf eine Instanz dieses Arraytyps oder ein Verweis auf eine Instanz eines kompatiblen ArraytypsA null reference, a reference to an instance of that array type, or a reference to an instance of a compatible array type
  • DelegattypDelegate type
    • Ein null-Verweis oder ein Verweis auf eine Instanz eines kompatiblen DelegattypA null reference or a reference to an instance of a compatible delegate type

ProgrammstrukturProgram structure

Die wichtigsten Organisationskonzepte in C# sind Programme, Namespaces, Typen, Member und Assemblys.The key organizational concepts in C# are programs, namespaces, types, members, and assemblies. Programme deklarieren Typen, die Member enthalten, und können in Namespaces organisiert werden.Programs declare types, which contain members and can be organized into namespaces. Klassen, Strukturen und Schnittstellen sind Beispiele von Typen.Classes, structs, and interfaces are examples of types. Felder, Methoden, Eigenschaften und Ereignisse sind Beispiele für Member.Fields, methods, properties, and events are examples of members. Wenn C#-Programme kompiliert werden, werden sie physisch in Assemblys gepackt.When C# programs are compiled, they're physically packaged into assemblies. Assemblys haben in der Regel die Erweiterung .exe oder .dll, je nachdem, ob sie Anwendungen oder Bibliotheken implementieren.Assemblies typically have the file extension .exe or .dll, depending on whether they implement applications or libraries, respectively.

Nehmen Sie als einfaches Beispiel eine Assembly, die den folgenden Code enthält:As a small example, consider an assembly that contains the following code:

using System;

namespace Acme.Collections
{
    public class Stack<T>
    {
        Entry _top;
        
        public void Push(T data)
        {
            _top = new Entry(_top, data);
        }

        public T Pop()
        {
            if (_top == null)
            {
                throw new InvalidOperationException();
            }
            T result = _top.Data;
            _top = _top.Next;
            
            return result;
        }

        class Entry
        {
            public Entry Next { get; set; }
            public T Data { get; set; }
            
            public Entry(Entry next, T data)
            {
                Next = next;
                Data = data;
            }
        }
    }
}

Der vollqualifizierte Name dieser Klasse ist Acme.Collections.Stack.The fully qualified name of this class is Acme.Collections.Stack. Die Klasse enthält mehrere Member: ein Feld mit dem Namen top, zwei Methoden mit dem Namen Push und Pop sowie eine geschachtelte Klasse mit dem Namen Entry.The class contains several members: a field named top, two methods named Push and Pop, and a nested class named Entry. Die Entry-Klasse enthält weitere drei Member: ein Feld mit dem Namen next, ein Feld mit dem Namen data und einen Konstruktor.The Entry class further contains three members: a field named next, a field named data, and a constructor. Stack ist eine generische Klasse.The Stack is a generic class. Sie hat einen Typparameter, T, der bei seiner Verwendung durch einen konkreten Typ ersetzt wird.It has one type parameter, T that is replaced with a concrete type when it's used.

Hinweis

Ein Stapel ist eine FILO-Sammlung (First In, Last Out).A stack is a "first in - last out" (FILO) collection. Neue Elemente werden am Anfang des Stapels hinzugefügt.New elements are added to the top of the stack. Das Entfernen eines Elements erfolgt von oben im Stapel.When an element is removed, it is removed from the top of the stack.

Assemblys enthalten ausführbaren Code in Form von Zwischensprachenanweisungen (Intermediate Language, IL) und symbolischen Informationen in Form von Metadaten.Assemblies contain executable code in the form of Intermediate Language (IL) instructions, and symbolic information in the form of metadata. Vor der Ausführen konvertiert der JIT-Compiler (Just-In-Time) der .NET Common Language Runtime den IL-Code in einer Assembly in prozessorspezifischen Code.Before it's executed, the Just-In-Time (JIT) compiler of .NET Common Language Runtime converts the IL code in an assembly to processor-specific code.

Da eine Assembly eine selbstbeschreibende Funktionseinheit mit Code und Metadaten ist, besteht in C# keine Notwendigkeit für #include-Direktiven und Headerdateien.Because an assembly is a self-describing unit of functionality containing both code and metadata, there's no need for #include directives and header files in C#. Die öffentlichen Typen und Member, die in einer bestimmten Assembly enthalten sind, werden einfach durch Verweisen auf die Assembly beim Kompilieren des Programms in einem C#-Programm verfügbar gemacht.The public types and members contained in a particular assembly are made available in a C# program simply by referencing that assembly when compiling the program. Dieses Programm verwendet z.B. die Acme.Collections.Stack-Klasse aus der acme.dll-Assembly:For example, this program uses the Acme.Collections.Stack class from the acme.dll assembly:

using System;
using Acme.Collections;

class Example
{
    public static void Main()
    {
        var s = new Stack<int>();
        s.Push(1); // stack contains 1
        s.Push(10); // stack contains 1, 10
        s.Push(100); // stack contains 1, 10, 100
        Console.WriteLine(s.Pop()); // stack contains 1, 10
        Console.WriteLine(s.Pop()); // stack contains 1
        Console.WriteLine(s.Pop()); // stack is empty
    }
}

Um dieses Programm zu kompilieren, müssen Sie auf die Assembly verweisen, die die im vorherigen Beispiel definierte Stapelklasse enthält.To compile this program, you would need to reference the assembly containing the stack class defined in the earlier example.

C#-Programme können in mehreren Quelldateien gespeichert werden.C# programs can be stored in several source files. Bei der Kompilierung eines C#-Programms werden alle Quelldateien zusammen verarbeitet. Die Quelldateien können frei aufeinander verweisen.When a C# program is compiled, all of the source files are processed together, and the source files can freely reference each other. Konzeptionell ist das Ganze so, als ob alle Quelldateien vor der Verarbeitung zu einer großen Datei verkettet worden wären.Conceptually, it's as if all the source files were concatenated into one large file before being processed. Vorwärtsdeklarationen sind in C# nie erforderlich, da die Reihenfolge der Deklaration mit wenigen Ausnahmen unbedeutend ist.Forward declarations are never needed in C# because, with few exceptions, declaration order is insignificant. C# beschränkt eine Quelldatei weder auf die Deklaration eines einzigen öffentlichen Typs, noch muss der Name der Quelldatei mit einem in der Quelldatei deklarierten Typ übereinstimmen.C# doesn't limit a source file to declaring only one public type nor does it require the name of the source file to match a type declared in the source file.

In weiteren Artikeln in dieser Einführung werden diese Organisationsblöcke erläutert.Further articles in this tour explain these organizational blocks.