Allgemeines TypsystemCommon Type System

Das allgemeine Typsystem legt fest, wie Typen in der Common Language Runtime deklariert, verwendet und verwaltet werden. Außerdem ist das System ein wichtiger Bestandteil der Laufzeitunterstützung für die sprachübergreifende Integration.The common type system defines how types are declared, used, and managed in the common language runtime, and is also an important part of the runtime's support for cross-language integration. Das allgemeine Typsystem hat die folgenden Funktionen:The common type system performs the following functions:

  • Aufbau eines Frameworks, das die sprachübergreifende Integration, Typsicherheit sowie eine äußerst leistungsfähige Codeausführung ermöglicht.Establishes a framework that helps enable cross-language integration, type safety, and high-performance code execution.

  • Bereitstellung eines objektorientierten Modells, das die vollständige Implementierung zahlreicher Programmiersprachen unterstützt.Provides an object-oriented model that supports the complete implementation of many programming languages.

  • Definition von Regeln, die von Programmiersprachen eingehalten werden müssen und sicherstellen, dass in verschiedenen Sprachen programmierte Objekte miteinander interagieren können.Defines rules that languages must follow, which helps ensure that objects written in different languages can interact with each other.

  • Bereitstellung einer Bibliothek, die die bei der Anwendungsentwicklung verwendeten primitiven Datentypen enthält (z. B. Boolean, Byte, Char, Int32 und UInt64).Provides a library that contains the primitive data types (such as Boolean, Byte, Char, Int32, and UInt64) used in application development.

Dieses Thema enthält folgende Abschnitte:This topic contains the following sections:

Typen in .NETTypes in .NET

Alle Typen in .NET sind entweder Werttypen oder Verweistypen.All types in .NET are either value types or reference types.

Werttypen sind Datentypen, deren Objekte durch den tatsächlichen Wert des Objekts dargestellt werden.Value types are data types whose objects are represented by the object's actual value. Wenn einer Variablen eine Instanz eines Werttyps zugewiesen wird, wird dieser Variablen eine neue Kopie des Werts übergeben.If an instance of a value type is assigned to a variable, that variable is given a fresh copy of the value.

Referenztypen sind Datentypen, deren Objekte durch einen Verweis (ähnlich einem Zeiger) auf den tatsächlichen Wert des Objekts dargestellt werden.Reference types are data types whose objects are represented by a reference (similar to a pointer) to the object's actual value. Wenn ein Verweistyp einer Variablen zugeordnet wird, verweist (oder zeigt) diese Variable auf den ursprünglichen Wert.If a reference type is assigned to a variable, that variable references (points to) the original value. Es wird keine Kopie erstellt.No copy is made.

Das allgemeine Typsystem in .NET unterstützt die folgenden fünf Typkategorien:The common type system in .NET supports the following five categories of types:

KlassenClasses

Eine Klasse ist ein Referenztyp, der direkt von einer anderen Klasse abgeleitet werden kann und der implizit von System.Object abgeleitet ist.A class is a reference type that can be derived directly from another class and that is derived implicitly from System.Object. Die Klasse definiert die Vorgänge, die ein Objekt (d. h. eine Instanz der Klasse) ausführen kann (Methoden, Ereignisse oder Eigenschaften), sowie die Daten, die das Objekt enthält (Felder).The class defines the operations that an object (which is an instance of the class) can perform (methods, events, or properties) and the data that the object contains (fields). Obwohl eine Klasse im Allgemeinen sowohl Definition als auch Implementierung enthält (im Gegensatz zu Schnittstellen, die z. B. nur eine Definition ohne Implementierung enthalten), kann sie über einen oder mehrere Member ohne Implementierung verfügen.Although a class generally includes both definition and implementation (unlike interfaces, for example, which contain only definition without implementation), it can have one or more members that have no implementation.

In der folgenden Tabelle werden einige Eigenschaften beschrieben, über die eine Klasse verfügen kann.The following table describes some of the characteristics that a class may have. Jede für Laufzeitunterstützung ausgelegte Sprache bietet eine Möglichkeit, eines oder mehrere Merkmale für eine Klasse oder einen Klassenmember festzulegen.Each language that supports the runtime provides a way to indicate that a class or class member has one or more of these characteristics. In einzelnen Programmiersprachen, die .NET als Ziel haben, sind jedoch möglicherweise nicht alle dieser Eigenschaften verfügbar.However, individual programming languages that target .NET may not make all these characteristics available.

MerkmalCharacteristic descriptionDescription
sealedsealed Legt fest, dass von diesem Typ keine andere Klasse abgeleitet werden kann.Specifies that another class cannot be derived from this type.
implementsimplements Gibt an, dass die Klasse eine oder mehrere Schnittstellen verwendet; es werden Implementierungen von Schnittstellenmembern bereitgestellt.Indicates that the class uses one or more interfaces by providing implementations of interface members.
abstractabstract Gibt an, dass die Klasse nicht instanziiert werden kann.Indicates that the class cannot be instantiated. Um die Klasse verwenden zu können, müssen Sie eine andere Klasse davon ableiten.To use it, you must derive another class from it.
inheritsinherits Legt fest, dass an jeder Stelle, an der die Basisklasse angegeben ist, Instanzen der Klasse verwendet werden können.Indicates that instances of the class can be used anywhere the base class is specified. Eine abgeleitete Klasse, die von einer Basisklasse erbt, kann die Implementierung jedes öffentlichen Members verwenden, der von der Basisklasse bereitgestellt wird, oder die abgeleitete Klasse kann die Implementierung der öffentlichen Member mit einer eigenen Implementierung überschreiben.A derived class that inherits from a base class can use the implementation of any public members provided by the base class, or the derived class can override the implementation of the public members with its own implementation.
exported oder not exportedexported or not exported Gibt an, ob eine Klasse außerhalb der Assembly, in der sie definiert wurde, sichtbar ist.Indicates whether a class is visible outside the assembly in which it is defined. Dieses Merkmal gilt nur für Klassen der obersten Ebene und nicht für geschachtelte Klassen.This characteristic applies only to top-level classes and not to nested classes.

Hinweis

Eine Klasse kann auch in einer übergeordneten Klasse oder Struktur geschachtelt werden.A class can also be nested in a parent class or structure. Auch geschachtelte Klassen verfügen über Membermerkmale.Nested classes also have member characteristics. Weitere Informationen finden Sie unter Geschachtelte Typen.For more information, see Nested Types.

Klassenmember, die keine Implementierung haben, sind abstrakte Member.Class members that have no implementation are abstract members. Eine Klasse mit einem oder mehreren abstrakten Membern ist selbst abstrakt, und von dieser Klasse können keine Instanzen erstellt werden.A class that has one or more abstract members is itself abstract; new instances of it cannot be created. Bei einigen Sprachen, die für die Laufzeit konzipiert sind, können Klassen selbst dann als abstrakt gekennzeichnet werden, wenn sie keine abstrakten Member haben.Some languages that target the runtime let you mark a class as abstract even if none of its members are abstract. Sie können eine abstrakte Klasse verwenden, um eine gewisse Basisfunktionalität einzuschließen, die von abgeleiteten Klassen ggf. geerbt bzw. überschrieben werden kann.You can use an abstract class when you want to encapsulate a basic set of functionality that derived classes can inherit or override when appropriate. Nicht abstrakte Klassen werden als konkrete Klassen bezeichnet.Classes that are not abstract are referred to as concrete classes.

Eine Klasse kann eine beliebige Anzahl von Schnittstellen implementieren, sie kann jedoch nur von einer Basisklasse neben System.Object erben. Hiervon erben alle Klassen implizit.A class can implement any number of interfaces, but it can inherit from only one base class in addition to System.Object, from which all classes inherit implicitly. Alle Klassen müssen über mindestens einen Konstruktor verfügen, durch den neue Instanzen der Klasse initialisiert werden.All classes must have at least one constructor, which initializes new instances of the class. Wenn Sie nicht explizit einen Konstruktor definieren, stellen die meisten Compiler automatisch einen Standardkonstruktor (ohne Parameter) bereit.If you do not explicitly define a constructor, most compilers will automatically provide a default (parameterless) constructor.

StrukturenStructures

Eine Struktur ist ein Werttyp, der implizit von System.ValueType abgeleitet ist. Dies ist wiederum von System.Object abgeleitet.A structure is a value type that derives implicitly from System.ValueType, which in turn is derived from System.Object. Eine Struktur ist hilfreich beim Darstellen von Werten mit geringen Arbeitsspeicheranforderungen und beim Übergeben von Werten über Parameter als Wert an Methoden mit stark typisierten Parametern.A structure is very useful for representing values whose memory requirements are small, and for passing values as by-value parameters to methods that have strongly typed parameters. In .NET werden alle primitiven Datentypen (Boolean, Byte, Char, DateTime, Decimal, Double, Int16, Int32, Int64, SByte, Single, UInt16, UInt32 und UInt64) als Strukturen definiert.In .NET, all primitive data types (Boolean, Byte, Char, DateTime, Decimal, Double, Int16, Int32, Int64, SByte, Single, UInt16, UInt32, and UInt64) are defined as structures.

Wie Klassen definieren Strukturen sowohl Daten (die Felder der Struktur) als auch die Vorgänge, die für diese Daten (die Methoden der Struktur) ausgeführt werden können.Like classes, structures define both data (the fields of the structure) and the operations that can be performed on that data (the methods of the structure). Dies bedeutet, dass Sie Methoden für Strukturen aufrufen können, einschließlich der für die System.Object-Klasse und die System.ValueType-Klasse definierten virtuellen Methoden sowie aller Methoden, die für den Werttyp selbst definiert wurden.This means that you can call methods on structures, including the virtual methods defined on the System.Object and System.ValueType classes, and any methods defined on the value type itself. Anders ausgedrückt können Strukturen Felder, Eigenschaften und Ereignisse sowie statische und nicht statische Methoden aufweisen.In other words, structures can have fields, properties, and events, as well as static and nonstatic methods. Sie können Instanzen von Strukturen erstellen, diese als Parameter übergeben, als lokale Variablen speichern oder im Feld eines anderen Werttyps oder Verweistyps speichern.You can create instances of structures, pass them as parameters, store them as local variables, or store them in a field of another value type or reference type. Strukturen können auch Schnittstellen implementieren.Structures can also implement interfaces.

Werttypen unterscheiden sich in mehreren Punkten auch von Klassen.Value types also differ from classes in several respects. Zunächst können sie nicht direkt von einem Typ erben, obwohl sie implizit von System.ValueType erben.First, although they implicitly inherit from System.ValueType, they cannot directly inherit from any type. Ebenso sind alle Werttypen versiegelt, was bedeutet, dass kein anderer Typ von ihnen abgeleitet werden kann.Similarly, all value types are sealed, which means that no other type can be derived from them. Außerdem benötigen sie keine Konstruktoren.They also do not require constructors.

Die Common Language Runtime stellt für jeden Werttyp einen entsprechenden geschachtelten Werttyp bereit, der eine Klasse darstellt, die denselben Zustand und dasselbe Verhalten wie der Werttyp aufweist.For each value type, the common language runtime supplies a corresponding boxed type, which is a class that has the same state and behavior as the value type. Eine Instanz eines Werttyps wird beim Übergeben an eine Methode geschachtelt, die einen Parameter vom Typ System.Object annimmt.An instance of a value type is boxed when it is passed to a method that accepts a parameter of type System.Object. Sie wird mittels Unboxing konvertiert (d. h. aus einer Instanz einer Klasse zurück in die Instanz eines Werttyps konvertiert), wenn ein Steuerelement aus einem Methodenaufruf zurückgegeben wird, in dem ein Werttyp als Parameter als Verweis angenommen wird.It is unboxed (that is, converted from an instance of a class back to an instance of a value type) when control returns from a method call that accepts a value type as a by-reference parameter. In einigen Sprachen muss eine spezielle Syntax verwendet werden, wenn ein mittels Boxing gepackter Typ erforderlich ist; in anderen Sprachen wird der mittels Boxing gepackte Typ bei Bedarf automatisch verwendet.Some languages require that you use special syntax when the boxed type is required; others automatically use the boxed type when it is needed. Die Definition eines Werttyps schließt sowohl den mittels Boxing gepackten als auch den mittels Unboxing entpackten Typ ein.When you define a value type, you are defining both the boxed and the unboxed type.

EnumerationenEnumerations

Eine Enumeration ist ein Werttyp, der direkt von System.Enum erbt und alternative Namen für die Werte eines zugrunde liegenden primitiven Typs bereitstellt.An enumeration (enum) is a value type that inherits directly from System.Enum and that supplies alternate names for the values of an underlying primitive type. Ein Enumerationstyp verfügt über einen Namen, einen zugrunde liegenden Typ, bei dem es sich um einen der integrierten Ganzzahltypen mit oder ohne Vorzeichen handeln muss (z. B. Byte, Int32 oder UInt64), und einen Satz von Feldern.An enumeration type has a name, an underlying type that must be one of the built-in signed or unsigned integer types (such as Byte, Int32, or UInt64), and a set of fields. Die Felder sind statische Literalfelder, von denen jedes eine Konstante darstellt.The fields are static literal fields, each of which represents a constant. Derselbe Wert kann auch mehreren Feldern zugewiesen werden.The same value can be assigned to multiple fields. In dieser Situation muss einer der Werte als primärer Enumerationswert für die Reflektion und Zeichenfolgenkonvertierung gekennzeichnet werden.When this occurs, you must mark one of the values as the primary enumeration value for reflection and string conversion.

Sie können einer Enumeration einen Wert des zugrunde liegenden Typs zuweisen und umgekehrt (für die Laufzeit ist keine Typumwandlung erforderlich).You can assign a value of the underlying type to an enumeration and vice versa (no cast is required by the runtime). Sie können eine Instanz einer Enumeration erstellen und die Methoden von System.Enum sowie alle für den zugrunde liegenden Enumerationstyp definierten Methoden aufrufen.You can create an instance of an enumeration and call the methods of System.Enum, as well as any methods defined on the enumeration's underlying type. In einigen Sprachen ist es jedoch möglicherweise nicht zulässig, dass eine Enumeration als Parameter übergeben wird, wenn eine Instanz des zugrunde liegenden Typs erforderlich ist (oder umgekehrt).However, some languages might not let you pass an enumeration as a parameter when an instance of the underlying type is required (or vice versa).

Für Enumerationen gelten die folgenden zusätzlichen Beschränkungen:The following additional restrictions apply to enumerations:

  • Sie können keine eigenen Methoden definieren.They cannot define their own methods.

  • Sie können keine Schnittstellen implementieren.They cannot implement interfaces.

  • Sie können keine Eigenschaften oder Ereignisse definieren.They cannot define properties or events.

  • Sie können nicht generisch sein, es sei denn, sie sind nur deshalb generisch, weil sie in einem generischen Typ geschachtelt sind.They cannot be generic, unless they are generic only because they are nested within a generic type. Das bedeutet, dass eine Enumeration nicht über eigene Typparameter verfügen kann.That is, an enumeration cannot have type parameters of its own.

    Hinweis

    Geschachtelte Typen (z. B. Enumerationen), die mit Visual Basic, C# oder C++ erstellt wurden, enthalten die Typparameter aller einschließenden generischen Typen und sind daher generisch, auch wenn sie über keine eigenen Typparameter verfügen.Nested types (including enumerations) created with Visual Basic, C#, and C++ include the type parameters of all enclosing generic types, and are therefore generic even if they do not have type parameters of their own. Weitere Informationen finden Sie im Referenzthema Type.MakeGenericType unter "Geschachtelte Typen".For more information, see "Nested Types" in the Type.MakeGenericType reference topic.

Durch das FlagsAttribute-Attribut wird eine spezielle Art von Enumeration, das so genannte Bitfeld, ausgewiesen.The FlagsAttribute attribute denotes a special kind of enumeration called a bit field. Von der Laufzeit selbst wird nicht zwischen herkömmlichen Enumerationen und Bitfeldern unterschieden, in Ihrer Programmiersprache könnte dies jedoch der Fall sein.The runtime itself does not distinguish between traditional enumerations and bit fields, but your language might do so. Wird diese Unterscheidung getroffen, können zum Generieren nicht benannter Werte zwar bitweise Operatoren für Bitfelder, jedoch nicht für Enumerationen verwendet werden.When this distinction is made, bitwise operators can be used on bit fields, but not on enumerations, to generate unnamed values. Enumerationen werden im Allgemeinen für Listen eindeutiger Elemente verwendet, z. B. für Wochentage bzw. Namen für Regionen oder Länder usw.Enumerations are generally used for lists of unique elements, such as days of the week, country or region names, and so on. Bitfelder werden in der Regel für Listen verwendet, in denen Qualitätsmerkmale oder Mengen definiert sind, die kombiniert auftreten können, z. B. Red And Big And Fast.Bit fields are generally used for lists of qualities or quantities that might occur in combination, such as Red And Big And Fast.

Das folgende Beispiel zeigt, wie Bitfelder und herkömmliche Enumerationen in Kombination verwendet werden können.The following example shows how to use both bit fields and traditional enumerations.

using System;
using System.Collections.Generic;

// A traditional enumeration of some root vegetables.
public enum SomeRootVegetables
{
    HorseRadish,
    Radish,
    Turnip
}

// A bit field or flag enumeration of harvesting seasons.
[Flags]
public enum Seasons
{
    None = 0,
    Summer = 1,
    Autumn = 2,
    Winter = 4,
    Spring = 8,
    All = Summer | Autumn | Winter | Spring
}

public class Example
{
   public static void Main()
   {
       // Hash table of when vegetables are available.
       Dictionary<SomeRootVegetables, Seasons> AvailableIn = new Dictionary<SomeRootVegetables, Seasons>();

       AvailableIn[SomeRootVegetables.HorseRadish] = Seasons.All;
       AvailableIn[SomeRootVegetables.Radish] = Seasons.Spring;
       AvailableIn[SomeRootVegetables.Turnip] = Seasons.Spring | 
            Seasons.Autumn;

       // Array of the seasons, using the enumeration.
       Seasons[] theSeasons = new Seasons[] { Seasons.Summer, Seasons.Autumn, 
            Seasons.Winter, Seasons.Spring };

       // Print information of what vegetables are available each season.
       foreach (Seasons season in theSeasons)
       {
          Console.Write(String.Format(
              "The following root vegetables are harvested in {0}:\n", 
              season.ToString("G")));
          foreach (KeyValuePair<SomeRootVegetables, Seasons> item in AvailableIn)
          {
             // A bitwise comparison.
             if (((Seasons)item.Value & season) > 0)
                 Console.Write(String.Format("  {0:G}\n", 
                      (SomeRootVegetables)item.Key));
          }
       }
   }
}
// The example displays the following output:
//    The following root vegetables are harvested in Summer:
//      HorseRadish
//    The following root vegetables are harvested in Autumn:
//      Turnip
//      HorseRadish
//    The following root vegetables are harvested in Winter:
//      HorseRadish
//    The following root vegetables are harvested in Spring:
//      Turnip
//      Radish
//      HorseRadish
Imports System.Collections.Generic

' A traditional enumeration of some root vegetables.
Public Enum SomeRootVegetables
   HorseRadish
   Radish
   Turnip
End Enum 

' A bit field or flag enumeration of harvesting seasons.
<Flags()> Public Enum Seasons
   None = 0
   Summer = 1
   Autumn = 2
   Winter = 4
   Spring = 8
   All = Summer Or Autumn Or Winter Or Spring
End Enum 

' Entry point.
Public Class Example
   Public Shared Sub Main()
      ' Hash table of when vegetables are available.
      Dim AvailableIn As New Dictionary(Of SomeRootVegetables, Seasons)()
        
      AvailableIn(SomeRootVegetables.HorseRadish) = Seasons.All
      AvailableIn(SomeRootVegetables.Radish) = Seasons.Spring
      AvailableIn(SomeRootVegetables.Turnip) = Seasons.Spring Or _
                                               Seasons.Autumn
        
      ' Array of the seasons, using the enumeration.
      Dim theSeasons() As Seasons = {Seasons.Summer, Seasons.Autumn, _
                                     Seasons.Winter, Seasons.Spring}
        
      ' Print information of what vegetables are available each season.
      For Each season As Seasons In theSeasons
         Console.WriteLine(String.Format( _
              "The following root vegetables are harvested in {0}:", _
              season.ToString("G")))
         For Each item As KeyValuePair(Of SomeRootVegetables, Seasons) In AvailableIn
            ' A bitwise comparison.
            If(CType(item.Value, Seasons) And season) > 0 Then
               Console.WriteLine("  " + _
                     CType(item.Key, SomeRootVegetables).ToString("G"))
            End If
         Next
      Next
   End Sub 
End Class 
' The example displays the following output:
'    The following root vegetables are harvested in Summer:
'      HorseRadish
'    The following root vegetables are harvested in Autumn:
'      Turnip
'      HorseRadish
'    The following root vegetables are harvested in Winter:
'      HorseRadish
'    The following root vegetables are harvested in Spring:
'      Turnip
'      Radish
'      HorseRadish

SchnittstellenInterfaces

Eine Schnittstelle definiert einen Vertrag, der eine Kann-Beziehung oder eine Hat-ein-Beziehung angibt.An interface defines a contract that specifies a "can do" relationship or a "has a" relationship. Schnittstellen werden häufig zur Implementierung einer Funktionalität verwendet, z. B. Vergleichen und Sortieren (die IComparable- und IComparable<T>-Schnittstellen), Testen auf Gleichheit (die IEquatable<T>-Schnittstelle) oder Auflistung von Elementen in einer Sammlung (die IEnumerable- und IEnumerable<T>-Schnittstellen).Interfaces are often used to implement functionality, such as comparing and sorting (the IComparable and IComparable<T> interfaces), testing for equality (the IEquatable<T> interface), or enumerating items in a collection (the IEnumerable and IEnumerable<T> interfaces). Schnittstellen können Eigenschaften, Methoden und Ereignisse aufweisen, die alle abstrakte Member sind. Während die Schnittstelle die Member und deren Signaturen definiert, definiert der die Schnittstelle implementierende Typ die Funktionalität der Schnittstellenmember.Interfaces can have properties, methods, and events, all of which are abstract members; that is, although the interface defines the members and their signatures, it leaves it to the type that implements the interface to define the functionality of each interface member. Dies bedeutet, dass jede Klasse oder Struktur, die eine Schnittstelle implementiert, Definitionen für die in der Schnittstelle deklarierten abstrakten Member bereitstellen muss.This means that any class or structure that implements an interface must supply definitions for the abstract members declared in the interface. Für eine Schnittstelle kann es erforderlich sein, dass eine beliebige implementierende Klasse oder Struktur auch mindestens eine andere Schnittstelle implementiert.An interface can require any implementing class or structure to also implement one or more other interfaces.

Für Schnittstellen gelten die folgenden Beschränkungen:The following restrictions apply to interfaces:

  • Eine Schnittstelle kann mit beliebigem Zugriff deklariert werden, die Schnittstellenmember müssen jedoch alle über die Zugriffsart public verfügen.An interface can be declared with any accessibility, but interface members must all have public accessibility.

  • Schnittstellen können keine Konstruktoren definieren.Interfaces cannot define constructors.

  • Schnittstellen können keine Felder definieren.Interfaces cannot define fields.

  • Schnittstellen können nur Instanzmember definieren.Interfaces can define only instance members. Sie können keine statischen Member definieren.They cannot define static members.

Jede Sprache muss Regeln zur Verfügung stellen, mit deren Hilfe eine Implementierung der Schnittstelle zugeordnet werden kann, die den Member benötigt. Der Grund ist, dass in mehreren Schnittstellen Member mit identischen Signaturen deklariert werden können, die jedoch möglicherweise über separate Implementierungen verfügen.Each language must provide rules for mapping an implementation to the interface that requires the member, because more than one interface can declare a member with the same signature, and these members can have separate implementations.

DelegatenDelegates

Delegaten sind Verweistypen, die einen ähnlichen Zweck erfüllen wie Funktionszeiger in C++.Delegates are reference types that serve a purpose similar to that of function pointers in C++. Sie werden für Ereignishandler und Rückruffunktionen in .NET verwendet.They are used for event handlers and callback functions in .NET. Im Gegensatz zu Funktionszeigern sind Delegaten sicher, überprüfbar und typsicher.Unlike function pointers, delegates are secure, verifiable, and type safe. Ein Delegattyp kann jede Instanzmethode oder statische Methode darstellen, die über eine kompatible Signatur verfügt.A delegate type can represent any instance method or static method that has a compatible signature.

Ein Parameter eines Delegaten ist mit dem entsprechenden Parameter einer Methode kompatibel, wenn der Typ des Delegatenparameters restriktiver ist als der Methodenparameter, da so gewährleistet ist, dass ein an den Delegaten übergebenes Argument problemlos an die Methode weitergeleitet werden kann.A parameter of a delegate is compatible with the corresponding parameter of a method if the type of the delegate parameter is more restrictive than the type of the method parameter, because this guarantees that an argument passed to the delegate can be passed safely to the method.

Ebenso ist der Rückgabetyp eines Delegaten kompatibel mit dem Rückgabetyp einer Methode, wenn der Rückgabetyp der Methode restriktiver ist als der Rückgabetyp des Delegaten, da so gewährleistet ist, dass der Rückgabewert der Methode problemlos in den Rückgabetyp des Delegaten umgewandelt werden kann.Similarly, the return type of a delegate is compatible with the return type of a method if the return type of the method is more restrictive than the return type of the delegate, because this guarantees that the return value of the method can be cast safely to the return type of the delegate.

Beispielsweise kann ein Delegat mit dem Parametertyp IEnumerable und dem Rückgabetyp Object eine Methode mit dem Parametertyp Object und dem Rückgabetyp IEnumerable darstellen.For example, a delegate that has a parameter of type IEnumerable and a return type of Object can represent a method that has a parameter of type Object and a return value of type IEnumerable. Weitere Informationen und Beispielcode finden Sie unter Delegate.CreateDelegate(Type, Object, MethodInfo).For more information and example code, see Delegate.CreateDelegate(Type, Object, MethodInfo).

Ein Delegat wird als gebunden an die Methode bezeichnet, die er darstellt.A delegate is said to be bound to the method it represents. Ein Delegat kann nicht nur an die Methode, sondern auch an ein Objekt gebunden sein.In addition to being bound to the method, a delegate can be bound to an object. Das Objekt stellt den ersten Parameter der Methode dar und wird jedes Mal an die Methode übergeben, wenn der Delegat aufgerufen wird.The object represents the first parameter of the method, and is passed to the method every time the delegate is invoked. Wenn es sich bei der Methode um eine Instanzmethode handelt, wird das gebundene Objekt als impliziter this-Parameter (Me in Visual Basic) übergeben. Wenn die Methode statisch ist, wird das Objekt als erster formaler Parameter der Methode übergeben, und die Delegatsignatur muss den verbleibenden Parametern entsprechen.If the method is an instance method, the bound object is passed as the implicit this parameter (Me in Visual Basic); if the method is static, the object is passed as the first formal parameter of the method, and the delegate signature must match the remaining parameters. Weitere Informationen und Beispielcode finden Sie unter System.Delegate.For more information and example code, see System.Delegate.

Alle Delegaten erben von System.MulticastDelegate, welcher von System.Delegate erbt.All delegates inherit from System.MulticastDelegate, which inherits from System.Delegate. In den Programmiersprachen C#, Visual Basic und C++ ist die Vererbung von diesen Typen nicht zulässig.The C#, Visual Basic, and C++ languages do not allow inheritance from these types. Stattdessen werden Schlüsselwörter zum Deklarieren von Delegaten bereitgestellt.Instead, they provide keywords for declaring delegates.

Da Delegaten von MulticastDelegate erben, verfügt ein Delegat über eine Aufrufliste. Dabei handelt es sich um eine Liste der Methoden, die dieser Delegat darstellt und die beim Aufrufen des Delegaten ausgeführt werden.Because delegates inherit from MulticastDelegate, a delegate has an invocation list, which is a list of methods that the delegate represents and that are executed when the delegate is invoked. Alle Methoden in der Liste empfangen die beim Aufrufen des Delegaten angegebenen Argumente.All methods in the list receive the arguments supplied when the delegate is invoked.

Hinweis

Der Rückgabewert von Delegaten mit mehr als einer Methode in der Aufrufliste ist nicht definiert, selbst wenn diese über einen Rückgabetyp verfügen.The return value is not defined for a delegate that has more than one method in its invocation list, even if the delegate has a return type.

In vielen Fällen (z. B. bei Rückrufmethoden) stellt ein Delegat nur eine Methode dar. Sie müssen den Delegaten lediglich erstellen und aufrufen.In many cases, such as with callback methods, a delegate represents only one method, and the only actions you have to take are creating the delegate and invoking it.

Für Delegaten, die mehrere Methoden darstellen, enthält .NET Methoden der Delegate-Delegatklasse und MulticastDelegate-Delegatklasse, um verschiedene Vorgänge zu unterstützen. Dazu gehören das Hinzufügen einer Methode zur Aufrufliste eines Delegaten (die Delegate.Combine-Methode), das Entfernen einer Methode (die Delegate.Remove-Methode) und das Abrufen der Aufrufliste (die Delegate.GetInvocationList-Methode).For delegates that represent multiple methods, .NET provides methods of the Delegate and MulticastDelegate delegate classes to support operations such as adding a method to a delegate's invocation list (the Delegate.Combine method), removing a method (the Delegate.Remove method), and getting the invocation list (the Delegate.GetInvocationList method).

Hinweis

Es ist in C#, C++ und Visual Basic nicht erforderlich, diese Methoden für Ereignishandlerdelegaten einzusetzen, da in diesen Programmiersprachen Syntax zum Hinzufügen und Entfernen von Ereignishandlern bereitsteht.It is not necessary to use these methods for event-handler delegates in C#, C++, and Visual Basic, because these languages provide syntax for adding and removing event handlers.

TypdefinitionenType Definitions

Eine Typdefinition enthält Folgendes:A type definition includes the following:

  • Alle für den Typ definierten Attribute.Any attributes defined on the type.

  • Den Zugriff des Typs (Sichtbarkeit).The type's accessibility (visibility).

  • Den Typnamen.The type's name.

  • Den Basistyp des Typs.The type's base type.

  • Alle durch den Typ implementierten Schnittstellen.Any interfaces implemented by the type.

  • Definitionen für jeden Member des Typs.Definitions for each of the type's members.

AttributeAttributes

Durch Attribute werden zusätzliche benutzerdefinierte Metadaten bereitgestellt.Attributes provide additional user-defined metadata. Sie werden in dem meisten Fällen verwendet, um zusätzliche Informationen zu einem Typ in seiner Assembly zu speichern oder um das Verhalten eines Typmembers zur Entwurfszeit oder in der Laufzeitumgebung zu ändern.Most commonly, they are used to store additional information about a type in its assembly, or to modify the behavior of a type member in either the design-time or run-time environment.

Attribute sind selbst Klassen, die von System.Attribute erben.Attributes are themselves classes that inherit from System.Attribute. Sprachen, die die Verwendung von Attributen unterstützen, verfügen über eine eigene Syntax zum Anwenden von Attributen auf ein Sprachelement.Languages that support the use of attributes each have their own syntax for applying attributes to a language element. Attribute können auf fast alle Sprachelemente angewendet werden. Die einzelnen Elemente, auf die ein Attribut angewendet werden kann, werden vom auf die Attributklasse angewendeten AttributeUsageAttribute definiert.Attributes can be applied to almost any language element; the specific elements to which an attribute can be applied are defined by the AttributeUsageAttribute that is applied to that attribute class.

TypzugriffType Accessibility

Alle Typen verfügen über einen Modifizierer, der regelt, welche anderen Typen auf diesen Typ zugreifen können.All types have a modifier that governs their accessibility from other types. In der folgenden Tabelle werden die von der Laufzeit unterstützten Zugriffsarten auf Typen beschrieben.The following table describes the type accessibilities supported by the runtime.

ZugriffAccessibility descriptionDescription
publicpublic Auf diesen Typ kann von allen Assemblys zugegriffen werden.The type is accessible by all assemblies.
Assemblyassembly Auf diesen Typ kann nur innerhalb seiner Assembly zugegriffen werden.The type is accessible only from within its assembly.

Der Zugriff auf einen geschachtelten Typ hängt von seiner Zugriffsdomäne ab, die sowohl durch den deklarierten Zugriffstyp des Members als auch durch die Zugriffsdomäne des direkt enthaltenden Typs bestimmt wird.The accessibility of a nested type depends on its accessibility domain, which is determined by both the declared accessibility of the member and the accessibility domain of the immediately containing type. Die Zugriffsdomäne eines geschachtelten Typs kann jedoch nicht über die des enthaltenden Typs hinausgehen.However, the accessibility domain of a nested type cannot exceed that of the containing type.

Die Zugriffsdomäne eines geschachtelten Members M, der in einem Typ T innerhalb eines Programms P deklariert ist, wird wie folgt definiert (wobei M selbst ein Typ sein kann):The accessibility domain of a nested member M declared in a type T within a program P is defined as follows (noting that M might itself be a type):

  • Wenn die deklarierte Zugriffsart von M den Wert public hat, entspricht die Zugriffsdomäne von M der von T.If the declared accessibility of M is public, the accessibility domain of M is the accessibility domain of T.

  • Wenn die deklarierte Zugriffsart von M den Wert protected internal hat, entspricht die Zugriffsdomäne von M der Schnittmenge zwischen der Zugriffsdomäne von T, dem Programmtext von P und dem Programmtext jedes Typs, der von T abgeleitet und außerhalb von P deklariert wurde.If the declared accessibility of M is protected internal, the accessibility domain of M is the intersection of the accessibility domain of T with the program text of P and the program text of any type derived from T declared outside P.

  • Wenn die deklarierte Zugriffsart von M den Wert protected hat, entspricht die Zugriffsdomäne von M der Schnittmenge zwischen der Zugriffsdomäne von T, dem Programmtext von T und jedem von T abgeleiteten Typ.If the declared accessibility of M is protected, the accessibility domain of M is the intersection of the accessibility domain of T with the program text of T and any type derived from T.

  • Wenn die deklarierte Zugriffsart von M den Wert internal hat, entspricht die Zugriffsdomäne von M der Schnittmenge zwischen der Zugriffsdomäne von T und dem Programmtext von P.If the declared accessibility of M is internal, the accessibility domain of M is the intersection of the accessibility domain of T with the program text of P.

  • Wenn die deklarierte Zugriffsart von M den Wert private hat, entspricht die Zugriffsdomäne von M dem Programmtext von T.If the declared accessibility of M is private, the accessibility domain of M is the program text of T.

TypnamenType Names

Das allgemeine Typsystem sieht lediglich zwei Namenseinschränkungen vor:The common type system imposes only two restrictions on names:

  • Alle Namen werden als Unicode-Zeichenfolgen (16-Bit-Zeichen) codiert.All names are encoded as strings of Unicode (16-bit) characters.

  • Ein eingebetteter Wert von 0x0000 (16 Bits) ist für Namen nicht zulässig.Names are not permitted to have an embedded (16-bit) value of 0x0000.

In den meisten Sprachen gelten jedoch möglicherweise zusätzliche Beschränkungen für Typnamen.However, most languages impose additional restrictions on type names. Alle Vergleiche erfolgen byteweise, sie berücksichtigen daher die Groß-/Kleinschreibung und sind unabhängig vom Gebietsschema.All comparisons are done on a byte-by-byte basis, and are therefore case-sensitive and locale-independent.

Obwohl ein Typ auf Typen aus anderen Modulen und Assemblys verweisen kann, muss er vollständig innerhalb eines .NET-Moduls definiert werden.Although a type might reference types from other modules and assemblies, a type must be fully defined within one .NET module. (Abhängig von der Compilerunterstützung kann er jedoch auf mehrere Quellcodedateien aufgeteilt werden.) Typnamen müssen nur innerhalb eines Namespace eindeutig sein.(Depending on compiler support, however, it can be divided into multiple source code files.) Type names need be unique only within a namespace. Um einen Typ vollständig zu identifizieren, muss der Typname durch den Namespace gekennzeichnet werden, die die Typimplementierung enthält.To fully identify a type, the type name must be qualified by the namespace that contains the implementation of the type.

Basistypen und SchnittstellenBase Types and Interfaces

Ein Typ kann Werte und Verhaltensdefinitionen von anderen Typen erben.A type can inherit values and behaviors from another type. Gemäß dem allgemeinen Typsystem können Typen nicht von mehr als einem Basistyp erben.The common type system does not allow types to inherit from more than one base type.

Ein Typ kann eine beliebige Anzahl von Schnittstellen implementieren.A type can implement any number of interfaces. Zur Implementierung einer Schnittstelle muss ein Typ alle virtuellen Member der betreffenden Schnittstelle implementieren.To implement an interface, a type must implement all the virtual members of that interface. Eine virtuelle Methode kann durch einen abgeleiteten Typ implementiert und entweder statisch oder dynamisch aufgerufen werden.A virtual method can be implemented by a derived type and can be invoked either statically or dynamically.

TypmemberType Members

Die Laufzeit ermöglicht es Ihnen, Member des Typs zu definieren. Hierbei werden das Verhalten und der Zustand eines Typs angegeben.The runtime enables you to define members of your type, which specifies the behavior and state of a type. Typmember umfassen Folgendes:Type members include the following:

FelderFields

Ein Feld beschreibt und enthält Teile des Typzustands.A field describes and contains part of the type's state. Felder können jedem von der Laufzeit unterstützten Typ entsprechen.Fields can be of any type supported by the runtime. In den meisten Fällen sind Felder private oder protected, damit auf sie nur innerhalb der Klasse oder aus einer abgeleiteten Klasse zugegriffen werden kann.Most commonly, fields are either private or protected, so that they are accessible only from within the class or from a derived class. Wenn der Wert eines Felds außerhalb seines Typs geändert werden kann, wird normalerweise ein Eigenschaftensatzaccessor verwendet.If the value of a field can be modified from outside its type, a property set accessor is typically used. Öffentlich verfügbar gemachte Felder sind normalerweise schreibgeschützt und können zwei Typen aufweisen:Publicly exposed fields are usually read-only and can be of two types:

  • Konstanten, deren Wert zur Entwurfszeit zugewiesen wird.Constants, whose value is assigned at design time. Diese sind statische Member einer Klasse, obwohl sie nicht mit dem static-Schlüsselwort (Shared in Visual Basic) definiert werden.These are static members of a class, although they are not defined using the static (Shared in Visual Basic) keyword.

  • Schreibgeschützte Variablen, deren Werte im Klassenkonstruktor zugewiesen werden können.Read-only variables, whose values can be assigned in the class constructor.

Im folgenden Beispiel werden diese zwei Verwendungen für schreibgeschützte Felder veranschaulicht.The following example illustrates these two usages of read-only fields.

using System;

public class Constants
{
   public const double Pi = 3.1416;
   public readonly DateTime BirthDate;
   
   public Constants(DateTime birthDate)
   {
      this.BirthDate = birthDate;
   }
}

public class Example
{
   public static void Main()
   {
      Constants con = new Constants(new DateTime(1974, 8, 18));
      Console.Write(Constants.Pi + "\n");
      Console.Write(con.BirthDate.ToString("d") + "\n");
   }
}
// The example displays the following output if run on a system whose current
// culture is en-US:
//    3.1416
//    8/18/1974
Public Class Constants
   Public Const Pi As Double = 3.1416
   Public ReadOnly BirthDate As Date
   
   Public Sub New(birthDate As Date)
      Me.BirthDate = birthDate
   End Sub
End Class

Public Module Example
   Public Sub Main()
      Dim con As New Constants(#8/18/1974#)
      Console.WriteLine(Constants.Pi.ToString())
      Console.WriteLine(con.BirthDate.ToString("d"))
   End Sub
End Module
' The example displays the following output if run on a system whose current
' culture is en-US:
'    3.1416
'    8/18/1974

EigenschaftenProperties

Eine Eigenschaft benennt einen Wert oder Zustand des Typs und definiert Methoden zum Abrufen oder Festlegen des Eigenschaftswerts.A property names a value or state of the type and defines methods for getting or setting the property's value. Eigenschaften können primitive Typen, Auflistungen primitiver Typen, benutzerdefinierte Typen oder Auflistungen benutzerdefinierter Typen sein.Properties can be primitive types, collections of primitive types, user-defined types, or collections of user-defined types. Eigenschaften werden häufig verwendet, um die Unabhängigkeit der öffentlichen Schnittstelle eines Typs von seiner tatsächlichen Darstellung zu gewährleisten.Properties are often used to keep the public interface of a type independent from the type's actual representation. So können Eigenschaften Werte reflektieren, die nicht direkt in der Klasse gespeichert sind (z. B., wenn eine Eigenschaft einen berechneten Wert zurückgibt), oder eine Validierung ausführen, bevor privaten Feldern Werte zugewiesen werden.This enables properties to reflect values that are not directly stored in the class (for example, when a property returns a computed value) or to perform validation before values are assigned to private fields. Im folgenden Codebeispiel wird das zweite Schema veranschaulicht.The following example illustrates the latter pattern.

using System;

public class Person
{
   private int m_Age;
   
   public int Age
   { 
      get { return m_Age; }
      set {
         if (value < 0 || value > 125)
         {
            throw new ArgumentOutOfRangeException("The value of the Age property must be between 0 and 125.");
         }
         else
         {
            m_Age = value;
         }         
      }
   }
}
Public Class Person
   Private m_Age As Integer
   
   Public Property Age As Integer
      Get
         Return m_Age
      End Get
      Set
         If value < 0 Or value > 125 Then
            Throw New ArgumentOutOfRangeException("The value of the Age property must be between 0 and 125.")
         Else
            m_Age = value
         End If
      End Set
   End Property
End Class

Die Microsoft Intermediate Language (MSIL) schließt nicht nur die Eigenschaft ein, sondern für einen Typ mit einer lesbaren Eigenschaft darüber hinaus eine get_Eigenschaftsname-Methode und für einen Typ mit einer beschreibbaren Eigenschaft eine set_Eigenschaftsname-Methode.In addition to including the property itself, the Microsoft intermediate language (MSIL) for a type that contains a readable property includes a get_propertyname method, and the MSIL for a type that contains a writable property includes a set_propertyname method.

MethodenMethods

Eine Methode beschreibt Vorgänge, die für den Typ verfügbar sind.A method describes operations that are available on the type. Eine Methodensignatur gibt die zulässigen Typen aller Parameter sowie des Rückgabewerts der Methode an.A method's signature specifies the allowable types of all its parameters and of its return value.

Obwohl die meisten Methoden die erforderliche Anzahl von Parametern für Methodenaufrufe genau definieren, unterstützen einige Methoden eine variable Anzahl von Parametern.Although most methods define the precise number of parameters required for method calls, some methods support a variable number of parameters. Der letzte deklarierte Parameter dieser Methoden wird mit dem ParamArrayAttribute-Attribut markiert.The final declared parameter of these methods is marked with the ParamArrayAttribute attribute. Sprachcompiler stellen in der Regel ein Schlüsselwort bereit, z. B. params in C# und ParamArray in Visual Basic, das die explizite Verwendung von ParamArrayAttribute unnötig macht.Language compilers typically provide a keyword, such as params in C# and ParamArray in Visual Basic, that makes explicit use of ParamArrayAttribute unnecessary.

KonstruktorenConstructors

Ein Konstruktor ist eine spezielle Methodenform, durch die neue Instanzen einer Klasse oder Struktur erstellt werden.A constructor is a special kind of method that creates new instances of a class or structure. Wie jede andere Methode kann ein Konstruktor Parameter einschließen. Konstruktoren verfügen jedoch nicht über einen Rückgabewert (d. h., sie geben void zurück).Like any other method, a constructor can include parameters; however, constructors have no return value (that is, they return void).

Wenn der Quellcode für eine Klasse nicht explizit einen Konstruktor definiert, schließt der Compiler einen Standardkonstruktor (ohne Parameter) ein.If the source code for a class does not explicitly define a constructor, the compiler includes a default (parameterless) constructor. Wenn der Quellcode für eine Klasse jedoch nur parametrisierte Konstruktoren definiert, generieren der Visual Basic-Compiler und der C#-Compiler keinen parameterlosen Konstruktor.However, if the source code for a class defines only parameterized constructors, the Visual Basic and C# compilers do not generate a parameterless constructor.

Wenn der Quellcode für eine Struktur Konstruktoren definiert, müssen diese parametrisiert werden. Eine Struktur kann keinen Standardkonstruktor (parameterlos) definieren, und Compiler generieren keine parameterlosen Konstruktoren für Strukturen oder andere Werttypen.If the source code for a structure defines constructors, they must be parameterized; a structure cannot define a default (parameterless) constructor, and compilers do not generate parameterless constructors for structures or other value types. Alle Werttypen verfügen über einen impliziten Standardkonstruktor.All value types do have an implicit default constructor. Dieser Konstruktor wird von der Common Language Runtime implementiert und initialisiert alle Felder der Struktur mit ihren Standardwerten.This constructor is implemented by the common language runtime and initializes all fields of the structure to their default values.

EreignisseEvents

Ein Ereignis definiert ein Ereignis, auf das reagiert werden kann, und definiert Methoden, mit denen das Ereignis ausgelöst und abonniert bzw. sein Abonnement aufgehoben werden kann.An event defines an incident that can be responded to, and defines methods for subscribing to, unsubscribing from, and raising the event. Häufig werden mithilfe von Ereignissen andere Typen über Zustandsänderungen informiert.Events are often used to inform other types of state changes. Weitere Informationen finden Sie unter Ereignisse.For more information, see Events.

Geschachtelte TypenNested Types

Ein geschachtelter Typ ist ein Typ, der ein Member eines anderen Typs ist.A nested type is a type that is a member of some other type. Geschachtelte Typen müssen eng mit dem zugehörigen enthaltenden Typ verknüpft sein und dürfen nicht für allgemeine Zwecke verwendbar sein.Nested types should be tightly coupled to their containing type and must not be useful as a general-purpose type. Geschachtelte Typen sind sinnvoll, wenn der deklarierende Typ Instanzen des geschachtelten Typs verwendet und erstellt und die Verwendung des geschachtelten Typs nicht in öffentlichen Membern verfügbar gemacht wird.Nested types are useful when the declaring type uses and creates instances of the nested type, and use of the nested type is not exposed in public members.

Für einige Entwickler sind geschachtelte Typen verwirrend, und sie sollten nur öffentlich sichtbar sein, wenn ein zwingender Grund dafür vorliegt.Nested types are confusing to some developers and should not be publicly visible unless there is a compelling reason for visibility. In einer gut entworfenen Bibliothek sollten Entwickler nur selten geschachtelte Typen zum Instanziieren von Objekten oder Deklarieren von Variablen verwenden müssen.In a well-designed library, developers should rarely have to use nested types to instantiate objects or declare variables.

Eigenschaften von TypmembernCharacteristics of Type Members

Das allgemeine Typsystem unterstützt Typmember, die eine Vielzahl unterschiedlicher Merkmale haben können. Zur Unterstützung all dieser Merkmale sind jedoch keine speziellen Sprachen erforderlich.The common type system allows type members to have a variety of characteristics; however, languages are not required to support all these characteristics. In der folgenden Tabelle sind diese Membermerkmale beschrieben.The following table describes member characteristics.

MerkmalCharacteristic Anwendbar aufCan apply to descriptionDescription
abstractabstract Methoden, Eigenschaften und EreignisseMethods, properties, and events Der Typ stellt keine Methodenimplementierung bereit.The type does not supply the method's implementation. Typen, die abstrakte Methoden erben oder implementieren, müssen eine Implementierung für die Methode bereitstellen.Types that inherit or implement abstract methods must supply an implementation for the method. Die einzige Ausnahme liegt vor, wenn der abgeleitete Typ selbst vom Typ abstract ist.The only exception is when the derived type is itself an abstract type. Alle Methoden vom Typ abstract sind auch virtual.All abstract methods are virtual.
private, family, assembly, family und assembly, family oder assembly oder publicprivate, family, assembly, family and assembly, family or assembly, or public AlleAll Definiert die Zugriffsart des Members:Defines the accessibility of the member:

privateprivate
Zugriff ist nur innerhalb desselben Typs wie dem des Members oder innerhalb eines geschachtelten Typs möglich.Accessible only from within the same type as the member, or within a nested type.

familyfamily
Zugriff innerhalb desselben Typs wie dem des Members und von abgeleiteten Typen möglich, die davon erben.Accessible from within the same type as the member, and from derived types that inherit from it.

Assemblyassembly
Zugriff nur in der Assembly möglich, in der der Typ definiert ist.Accessible only in the assembly in which the type is defined.

family und assemblyfamily and assembly
Zugriff nur von Typen möglich, die sowohl über den Zugriffstyp family als auch assembly verfügen.Accessible only from types that qualify for both family and assembly access.

family oder assemblyfamily or assembly
Zugriff nur von Typen möglich, die über den Zugriffstyp "family" oder "assembly" verfügen.Accessible only from types that qualify for either family or assembly access.

publicpublic
Zugriff von jedem Typ möglich.Accessible from any type.
finalfinal Methoden, Eigenschaften und EreignisseMethods, properties, and events Die virtuelle Methode kann in einem abgeleiteten Typ nicht überschrieben werden.The virtual method cannot be overridden in a derived type.
initialize-onlyinitialize-only FelderFields Der Wert kann lediglich initialisiert werden. Nach der Initialisierung ist kein Schreibzugriff möglich.The value can only be initialized, and cannot be written after initialization.
instanceinstance Felder, Methoden, Eigenschaften und EreignisseFields, methods, properties, and events Wenn ein Member nicht als static (C# und C++), Shared (Visual Basic), virtual (C# und C++) oder Overridable (Visual Basic) gekennzeichnet ist, handelt es sich um einen Instanzmember (es ist kein instance-Schlüsselwort vorhanden).If a member is not marked as static (C# and C++), Shared (Visual Basic), virtual (C# and C++), or Overridable (Visual Basic), it is an instance member (there is no instance keyword). Im Arbeitsspeicher befinden sich so viele Kopien dieser Member wie Objekte, von denen sie verwendet werden.There will be as many copies of such members in memory as there are objects that use it.
literalliteral FelderFields Der dem Feld zugewiesene Wert ist ein fester, zur Kompilierungszeit bekannter Wert eines integrierten Werttyps.The value assigned to the field is a fixed value, known at compile time, of a built-in value type. Literalfelder werden zeitweise auch als Konstanten bezeichnet.Literal fields are sometimes referred to as constants.
newslot oder overridenewslot or override AlleAll Definiert, wie der Member mit geerbten Membern interagiert, die dieselbe Signatur haben:Defines how the member interacts with inherited members that have the same signature:

newslotnewslot
Geerbte Member mit derselben Signatur werden verdeckt.Hides inherited members that have the same signature.

overrideoverride
Ersetzt die Definition einer geerbten virtuellen Methode.Replaces the definition of an inherited virtual method.

Der Standardwert ist newslot.The default is newslot.
staticstatic Felder, Methoden, Eigenschaften und EreignisseFields, methods, properties, and events Der Member gehört dem Typ an, mit dem er definiert wurde, und keiner bestimmten Instanz des Typs. Der Member existiert selbst dann, wenn keine Instanz des Typs erstellt wird, und wird von allen Instanzen des Typs gemeinsam genutzt.The member belongs to the type it is defined on, not to a particular instance of the type; the member exists even if an instance of the type is not created, and it is shared among all instances of the type.
virtualvirtual Methoden, Eigenschaften und EreignisseMethods, properties, and events Die Methode kann durch einen abgeleiteten Typ implementiert und entweder statisch oder dynamisch aufgerufen werden.The method can be implemented by a derived type and can be invoked either statically or dynamically. Beim dynamischen Aufruf bestimmt der Typ der Instanz, durch die der Aufruf zur Laufzeit ausgeführt wird (und nicht der zur Kompilierungszeit bekannte Typ), welche Implementierung der Methode aufgerufen wird.If dynamic invocation is used, the type of the instance that makes the call at run time (rather than the type known at compile time) determines which implementation of the method is called. Um eine Methode vom Typ virtual statisch aufzurufen, muss die Variable u. U. in einen Typ umgewandelt werden, der die gewünschte Methodenversion verwendet.To invoke a virtual method statically, the variable might have to be cast to a type that uses the desired version of the method.

ÜberladenOverloading

Jeder Typmember verfügt über eine eindeutige Signatur.Each type member has a unique signature. Methodensignaturen bestehen aus dem Methodennamen und einer Parameterliste (die Reihenfolge und Typen der Argumente der Methode).Method signatures consist of the method name and a parameter list (the order and types of the method's arguments). Solange die Signaturen unterschiedlich sind, können innerhalb eines Typs mehrere Methoden mit demselben Namen definiert werden.Multiple methods with the same name can be defined within a type as long as their signatures differ. Wenn zwei oder mehrere Methoden mit demselben Namen definiert sind, wird von einer "überladenen" Methode gesprochen.When two or more methods with the same name are defined, the method is said to be overloaded. In System.Char wird z. B. die IsDigit-Methode überladen.For example, in System.Char, the IsDigit method is overloaded. Eine Methode nimmt einen Char an.One method takes a Char. Die andere Methode nimmt einen String und einen Int32 an.The other method takes a String and an Int32.

Hinweis

Der Rückgabetyp wird nicht als Teil der Signatur einer Methode betrachtet.The return type is not considered part of a method's signature. Dies bedeutet, dass Methoden nicht überladen werden können, wenn sich nur ihr Rückgabetyp unterscheidet.That is, methods cannot be overloaded if they differ only by return type.

Vererben, Überschreiben und Verdecken von MembernInheriting, Overriding, and Hiding Members

Ein abgeleiteter Typ erbt alle Member seines Basistyps. Dies bedeutet, dass diese Member für den abgeleiteten Typ definiert und verfügbar sind.A derived type inherits all members of its base type; that is, these members are defined on, and available to, the derived type. Das Verhalten oder die Merkmale geerbter Member können auf zwei Weisen geändert werden:The behavior or qualities of inherited members can be modified in two ways:

  • Ein abgeleiteter Typ kann einen geerbten Member verdecken, indem er einen neuen Member mit derselben Signatur definiert.A derived type can hide an inherited member by defining a new member with the same signature. Dies kann z. B. geschehen, um einen Member, der zuvor als public deklariert war, als private zu definieren, oder um ein neues Verhalten für eine geerbte Methode zu definieren, die mit final gekennzeichnet ist.This might be done to make a previously public member private or to define new behavior for an inherited method that is marked as final.

  • Ein abgeleiteter Typ kann eine geerbte virtuelle Methode überschreiben.A derived type can override an inherited virtual method. Die überschreibende Methode stellt eine neue Definition für die Methode bereit, die basierend auf dem Werttyp zur Laufzeit aufgerufen wird und nicht basierend auf dem zur Kompilierungszeit bekannten Variablentyp.The overriding method provides a new definition of the method that will be invoked based on the type of the value at run time rather than the type of the variable known at compile time. Eine virtuelle Methode kann nur von einer Methode überschrieben werden, wenn die virtuelle Methode nicht als final gekennzeichnet ist und die neue Methode mindestens dieselben Zugriffstypen unterstützt wie die virtuelle Methode.A method can override a virtual method only if the virtual method is not marked as final and the new method is at least as accessible as the virtual method.

Siehe auchSee Also

.NET API-Browser.NET API Browser
Common Language RuntimeCommon Language Runtime
Typkonvertierung in .NETType Conversion in .NET