Integrierte Verweistypen (C#-Referenz)Built-in reference types (C# reference)

C# enthält eine Reihe von integrierten Verweistypen.C# has a number of built-in reference types. Diese enthalten Schlüsselwörter oder Operatoren, die Synonyme für einen Typ in der .NET-Bibliothek sind.They have keywords or operators that are synonyms for a type in the .NET library.

Der ObjekttypThe object type

Der object-Typ ist ein Alias für System.Object in .NET.The object type is an alias for System.Object in .NET. Im vereinheitlichen Typsystem von C# erben alle Typen, vordefiniert und benutzerdefiniert sowie Verweis- und Werttypen, direkt oder indirekt von System.Object.In the unified type system of C#, all types, predefined and user-defined, reference types and value types, inherit directly or indirectly from System.Object. Sie können Werte eines beliebigen Typs Variablen des Typs object zuweisen.You can assign values of any type to variables of type object. Diesem Standardwert kann mithilfe des Literals null eine beliebige object-Variable zugewiesen werden.Any object variable can be assigned to its default value using the literal null. Wenn eine Variable eines Werttyps in ein Objekt konvertiert wird, gilt es als geschachtelt.When a variable of a value type is converted to object, it is said to be boxed. Wenn eine Variable des Typs object in ein Wertobjekt konvertiert wird, gilt es als nicht geschachtelt.When a variable of type object is converted to a value type, it is said to be unboxed. Weitere Informationen finden Sie unter Boxing und Unboxing.For more information, see Boxing and Unboxing.

Der ZeichenfolgentypThe string type

Der Typ string stellt eine Sequenz von Null oder mehr Unicode-Zeichen dar.The string type represents a sequence of zero or more Unicode characters. string ist ein Alias für System.String in .NET.string is an alias for System.String in .NET.

Obwohl string ein Verweistyp ist, werden die Gleichheitsoperatoren== und != zum Vergleichen der Werte von string-Objekten, nicht von Verweisen, definiert.Although string is a reference type, the equality operators == and != are defined to compare the values of string objects, not references. Dadurch wird das Testen auf Zeichenfolgengleichheit intuitiver.This makes testing for string equality more intuitive. Beispiel:For example:

string a = "hello";
string b = "h";
// Append to contents of 'b'
b += "ello";
Console.WriteLine(a == b);
Console.WriteLine(object.ReferenceEquals(a, b));

Dies zeigt TRUE und anschließend FALSE an, weil der Inhalt der Zeichenfolgen gleich sind. Jedoch verweisen a und b nicht auf die gleiche Zeichenfolgeninstanz.This displays "True" and then "False" because the content of the strings are equivalent, but a and b do not refer to the same string instance.

Der Operator „+“ verkettet Zeichenfolgen:The + operator concatenates strings:

string a = "good " + "morning";

Dadurch wird ein Zeichenfolgenobjekt erstellt, das „Guten Morgen“ enthält.This creates a string object that contains "good morning".

Zeichenfolgen sind unveränderlich. Die Inhalte eines Zeichenfolgenobjekts können nicht geändert werden, nachdem ein Objekt erstellt wurde, obwohl die Syntax den Eindruck erweckt, dass es machbar wäre.Strings are immutable--the contents of a string object cannot be changed after the object is created, although the syntax makes it appear as if you can do this. Wenn Sie z. B. diesen Code schreiben, erstellt der Compiler tatsächlich ein neues Zeichenfolgenobjekt, um die neue Zeichensequenz zu speichern. Das neue Objekt wird b zugewiesen.For example, when you write this code, the compiler actually creates a new string object to hold the new sequence of characters, and that new object is assigned to b. Der Speicherplatz, der b zugeordnet wurde (sofern die Zeichenfolge „h“ enthalten war), hat dann Anspruch auf die Garbage Collection.The memory that had been allocated for b (when it contained the string "h") is then eligible for garbage collection.

string b = "h";
b += "ello";

Der []-Operator kann für schreibgeschützten Zugriff auf einzelne Zeichen einer Zeichenfolge verwendet werden:The [] operator can be used for readonly access to individual characters of a string. Gültige Indexwerte beginnen bei 0 und müssen kleiner als die Länge der Zeichenfolge sein:Valid index values start at 0 and must be less than the length of the string:

string str = "test";
char x = str[2];  // x = 's';

Auf gleiche Weise kann der []-Operator auch für das Durchlaufen jedes Zeichens in der Zeichenfolge verwendet werden:In similar fashion, the [] operator can also be used for iterating over each character in a string:

string str = "test";

for (int i = 0; i < str.Length; i++)
{
  Console.Write(str[i] + " ");
}
// Output: t e s t

Zeichenfolgenliterale sind Typ string und können in zwei Formaten geschrieben werden: in Anführungszeichen und mit @.String literals are of type string and can be written in two forms, quoted and @-quoted. Zeichenfolgenliterale in Anführungszeichen werden in doppelte Anführungszeichen (") eingeschlossen:Quoted string literals are enclosed in double quotation marks ("):

"good morning"  // a string literal

Zeichenfolgenliterale können jeden Zeichenliteral enthalten.String literals can contain any character literal. Escapesequenzen sind enthalten.Escape sequences are included. Im folgenden Beispiel wird die Escapesequenz \\ für den umgekehrten Schrägstrich, \u0066 für den Buchstaben „f“ und \n für den Zeilenumbruch verwendet.The following example uses escape sequence \\ for backslash, \u0066 for the letter f, and \n for newline.

string a = "\\\u0066\n F";
Console.WriteLine(a);
// Output:
// \f
//  F

Hinweis

Der Escapecode \udddd (wobei dddd eine vierstellige Zahl ist) stellt das Unicode-Zeichen U+dddd dar.The escape code \udddd (where dddd is a four-digit number) represents the Unicode character U+dddd. Escapecodes aus achtstelligen Unicode werden auch erkannt: \Udddddddd.Eight-digit Unicode escape codes are also recognized: \Udddddddd.

Wörtliche Zeichenfolgenliterale beginnen mit @ und sind ebenfalls in doppelte Anführungszeichen eingeschlossen.Verbatim string literals start with @ and are also enclosed in double quotation marks. Beispiel:For example:

@"good morning"  // a string literal

Der Vorteil von wörtlichen Zeichenfolgen besteht darin, dass Escapesequenzen nicht verarbeitet werden, wodurch z. B. das Schreiben eines vollqualifizierten Windows-Dateinamens erleichtert wird:The advantage of verbatim strings is that escape sequences are not processed, which makes it easy to write, for example, a fully qualified Windows file name:

@"c:\Docs\Source\a.txt"  // rather than "c:\\Docs\\Source\\a.txt"

Verdoppeln Sie das doppelte Anführungszeichen, um es in einer @-quoted-Zeichenfolge aufzunehmen:To include a double quotation mark in an @-quoted string, double it:

@"""Ahoy!"" cried the captain." // "Ahoy!" cried the captain.

Der DelegattypThe delegate type

Die Deklaration eines Delegattyps ähnelt einer Methodensignatur.The declaration of a delegate type is similar to a method signature. Er verfügt über einen Rückgabewert und eine beliebige Anzahl Parameter eines beliebigen Typs:It has a return value and any number of parameters of any type:

public delegate void MessageDelegate(string message);
public delegate int AnotherDelegate(MyType m, long num);

In .NET stellen die Typen System.Action und System.Func generische Definitionen für zahlreiche allgemeine Delegaten bereit.In .NET, System.Action and System.Func types provide generic definitions for many common delegates. Sie werden sehr wahrscheinlich keine neuen benutzerdefinierten Delegattypen definieren müssen.You likely don't need to define new custom delegate types. Stattdessen können Sie Instanziierungen der bereitgestellten generischen Typen erstellen.Instead, you can create instantiations of the provided generic types.

Ein delegate ist ein Verweistyp, der verwendet werden kann, um eine benannte oder anonyme Methode zu kapseln.A delegate is a reference type that can be used to encapsulate a named or an anonymous method. Delegaten entsprechen den Funktionszeigern in C++, sind jedoch typsicher und geschützt.Delegates are similar to function pointers in C++; however, delegates are type-safe and secure. Anwendungsmöglichkeiten von Delegaten finden Sie unter Delegaten und Generische Delegaten.For applications of delegates, see Delegates and Generic Delegates. Delegaten bilden die Grundlage für Ereignisse.Delegates are the basis for Events. Ein Delegat kann instanziiert werden, entweder durch Zuordnen mit einer benannten oder einer anonymen Methode.A delegate can be instantiated by associating it either with a named or anonymous method.

Der Delegat muss mit einer Methode oder einem Lambda-Ausdruck instanziiert werden, der über einen kompatiblen Rückgabetypen und Eingabeparameter verfügt.The delegate must be instantiated with a method or lambda expression that has a compatible return type and input parameters. Weitere Informationen zum Grad der Varianz, der in der Methodensignatur zulässig ist, finden Sie unter Varianz bei Delegaten.For more information on the degree of variance that is allowed in the method signature, see Variance in Delegates. Für die Verwendung mit anonymen Methoden werden der Delegat und der Code, der mit ihm zugeordnet werden soll, zusammen deklariert.For use with anonymous methods, the delegate and the code to be associated with it are declared together.

Der dynamische TypThe dynamic type

Der dynamic-Typ gibt an, dass durch die Verwendung der Variablen und Verweise auf die entsprechenden Member die Prüfung des Kompilierzeittyps umgangen wird.The dynamic type indicates that use of the variable and references to its members bypass compile-time type checking. Stattdessen werden diese Vorgänge zur Laufzeit aufgelöst.Instead, these operations are resolved at run time. Der dynamic-Typ vereinfacht den Zugriff auf COM-APIs, z. B. die Office Automation-APIs, auf dynamische APIs, beispielsweise IronPython-Bibliotheken und auf das HTML-Dokumentobjektmodell (Document Object Model, DOM).The dynamic type simplifies access to COM APIs such as the Office Automation APIs, to dynamic APIs such as IronPython libraries, and to the HTML Document Object Model (DOM).

Der Typ dynamic verhält sich in den meisten Fällen wie Typ object.Type dynamic behaves like type object in most circumstances. Insbesondere können alle Ausdrücke, die nicht NULL sind, in den dynamic-Typ konvertiert werden.In particular, any non-null expression can be converted to the dynamic type. Der dynamic-Typ unterscheidet sich jedoch von object insofern, als dass Vorgänge, die Ausdrücke des Typs dynamic enthalten, nicht aufgelöst oder durch den Compiler typgeprüft werden.The dynamic type differs from object in that operations that contain expressions of type dynamic are not resolved or type checked by the compiler. Der Compiler packt Informationen über den Vorgang. Diese Informationen werden später zur Evaluierung des Vorgangs zur Laufzeit verwendet.The compiler packages together information about the operation, and that information is later used to evaluate the operation at run time. Als Teil dieses Prozesses werden Variablen des Typs dynamic in Variablen des Typs object kompiliert.As part of the process, variables of type dynamic are compiled into variables of type object. Deshalb existiert der Typ dynamic nur zur Kompilierzeit und nicht zur Laufzeit.Therefore, type dynamic exists only at compile time, not at run time.

Das folgende Beispiel vergleicht den Unterschied einer Variable des Typs dynamic mit einer Variable des Typs object.The following example contrasts a variable of type dynamic to a variable of type object. Um den Typ jeder Variable zur Kompilierzeit zu überprüfen, zeigen Sie mit dem Mauszeiger auf dyn oder obj in den WriteLine-Anweisungen.To verify the type of each variable at compile time, place the mouse pointer over dyn or obj in the WriteLine statements. Kopieren Sie den folgenden Code in einen Editor, in dem IntelliSense verfügbar ist.Copy the following code into an editor where IntelliSense is available. IntelliSense zeigt dynamic für dyn und object für obj.IntelliSense shows dynamic for dyn and object for obj.

class Program
{
    static void Main(string[] args)
    {
        dynamic dyn = 1;
        object obj = 1;

        // Rest the mouse pointer over dyn and obj to see their
        // types at compile time.
        System.Console.WriteLine(dyn.GetType());
        System.Console.WriteLine(obj.GetType());
    }
}

Die WriteLine-Anweisungen zeigen die Laufzeittypen von dyn und obj.The WriteLine statements display the run-time types of dyn and obj. Zu diesem Zeitpunkt verfügen beide denselben Typ, Integer.At that point, both have the same type, integer. Es wird die folgende Ausgabe generiert:The following output is produced:

System.Int32
System.Int32

Um den Unterschied zwischen dyn und obj zur Kompilierzeit anzuzeigen, fügen Sie die folgenden zwei Zeilen zwischen die Deklarationen und die WriteLine-Anweisungen im vorherigen Beispiel ein.To see the difference between dyn and obj at compile time, add the following two lines between the declarations and the WriteLine statements in the previous example.

dyn = dyn + 3;
obj = obj + 3;

Es wird ein Kompilierfehler für den Versuch, einen Integer und ein Objekt im Ausdruck obj + 3 einzufügen, ausgegeben.A compiler error is reported for the attempted addition of an integer and an object in expression obj + 3. Es wird jedoch kein Fehler für dyn + 3 gemeldet.However, no error is reported for dyn + 3. Der Ausdruck, der dyn enthält, wird nicht zur Kompilierzeit überprüft, da der Typ von dyn``dynamic ist.The expression that contains dyn is not checked at compile time because the type of dyn is dynamic.

Das folgende Beispiel verwendet dynamic in einigen Deklarationen.The following example uses dynamic in several declarations. Die Main-Methode unterscheidet auch die Typüberprüfung zur Kompilierzeit und die Laufzeittypüberprüfung.The Main method also contrasts compile-time type checking with run-time type checking.

using System;

namespace DynamicExamples
{
    class Program
    {
        static void Main(string[] args)
        {
            ExampleClass ec = new ExampleClass();
            Console.WriteLine(ec.exampleMethod(10));
            Console.WriteLine(ec.exampleMethod("value"));

            // The following line causes a compiler error because exampleMethod
            // takes only one argument.
            //Console.WriteLine(ec.exampleMethod(10, 4));

            dynamic dynamic_ec = new ExampleClass();
            Console.WriteLine(dynamic_ec.exampleMethod(10));

            // Because dynamic_ec is dynamic, the following call to exampleMethod
            // with two arguments does not produce an error at compile time.
            // However, it does cause a run-time error.
            //Console.WriteLine(dynamic_ec.exampleMethod(10, 4));
        }
    }

    class ExampleClass
    {
        static dynamic field;
        dynamic prop { get; set; }

        public dynamic exampleMethod(dynamic d)
        {
            dynamic local = "Local variable";
            int two = 2;

            if (d is int)
            {
                return local;
            }
            else
            {
                return two;
            }
        }
    }
}
// Results:
// Local variable
// 2
// Local variable

Weitere InformationenSee also