Freigeben über

Integrierte Verweistypen (C#-Referenz)

  • Artikel

C# umfasst eine Vielzahl von integrierten Verweistypen. Diese enthalten Schlüsselwörter oder Operatoren, die Synonyme für einen Typ in der .NET-Bibliothek sind.

den Objekttyp

Der object-Typ ist ein Alias für 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. Sie können Werte eines beliebigen Typs Variablen des Typs object zuweisen. Diesem Standardwert kann mithilfe des Literals null eine beliebige object-Variable zugewiesen werden. Wenn eine Variable eines Werttyps in ein Objekt konvertiert wird, gilt es als geschachtelt. Wenn eine Variable des Typs object in ein Werttyps konvertiert wird, gilt es als nicht geschachtelt. Weitere Informationen finden Sie unter Boxing und Unboxing.

Der Zeichenfolgentyp

Der Typ string stellt eine Sequenz von Null oder mehr Unicode-Zeichen dar. string ist ein Alias für System.String in .NET.

Obwohl string ein Verweistyp ist, werden die Gleichheitsoperatoren== und != zum Vergleichen der Werte von string-Objekten, nicht von Verweisen, definiert. Durch wertbasierte Gleichheit wird das Testen auf Zeichenfolgengleichheit intuitiver. Beispiel:

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

Im obigen Beispiel wird TRUE und dann FALSE angezeigt, weil der Inhalt der Zeichenfolgen äquivalent ist. Allerdings verweisen a und b nicht auf die gleiche Zeichenfolgeninstanz.

Der Operator „+“ verkettet Zeichenfolgen:

string a = "good " + "morning";

Der obige Code erstellt ein Zeichenfolgenobjekt, das „good morning“ enthält.

Zeichenfolgen sind unveränderlich. Der Inhalt eines Zeichenfolgenobjekts kann nach der Erstellung des Objekts nicht mehr geändert werden. 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. Der Speicherplatz, der b zugeordnet wurde (sofern die Zeichenfolge „h“ enthalten war), hat dann Anspruch auf die Garbage Collection.

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

Der []-Operator kann für schreibgeschützten Zugriff auf einzelne Zeichen einer Zeichenfolge verwendet werden: Gültige Indexwerte beginnen bei 0 und müssen kleiner als die Länge der Zeichenfolge sein:

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:

string str = "test";

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

Zeichenfolgenliterale

Zeichenfolgenliterale sind vom Typ string und können in drei Formaten geschrieben werden: unformatiert, in Anführungszeichen und ausführlich.

Unformatierte Zeichenfolgenliterale sind ab C# 11 verfügbar. Unformatierte Zeichenfolgenliterale können beliebigen Text enthalten, ohne dass Escapesequenzen erforderlich sind. Unformatierte Zeichenfolgenliterale können Leerzeichen und Zeilenumbrüche, eingebettete Anführungszeichen und andere Sonderzeichen enthalten. Unformatierte Zeichenfolgenliterale sind in mindestens drei doppelte Anführungszeichen (""") eingeschlossen:

"""
This is a multi-line
    string literal with the second line indented.
"""

Sie können sogar eine Sequenz von drei (oder mehr) doppelten Anführungszeichen verwenden. Wenn der Text eine eingebettete Sequenz von Anführungszeichen erfordert, müssen Sie das unformatierte Zeichenfolgenliteral je nach Bedarf mit weiteren Anführungszeichen beginnen und beenden:

"""""
This raw string literal has four """", count them: """" four!
embedded quote characters in a sequence. That's why it starts and ends
with five double quotes.

You could extend this example with as many embedded quotes as needed for your text.
"""""

Bei unformatierten Zeichenfolgenliteralen befinden sich die Sequenzen von Anführungszeichen am Anfang und Ende in der Regel in getrennten Zeilen vom eingebetteten Text. Mehrzeilige unformatierte Zeichenfolgenliterale unterstützen Zeichenfolgen, die selbst Zeichenfolgen in Anführungszeichen sind:

var message = """
"This is a very important message."
""";
Console.WriteLine(message);
// output: "This is a very important message."

Wenn sich die Anführungszeichen am Anfang und Ende in separaten Zeilen befinden, sind die Zeilenumbrüche nach den öffnenden Anführungszeichen und vor dem schließenden Anführungszeichen nicht im endgültigen Inhalt enthalten. Die schließende Anführungszeichensequenz legt die linke Spalte für das Zeichenfolgenliteral fest. Sie können ein unformatiertes Zeichenfolgenliteral einrücken, damit es dem verwendeten Codeformat entspricht:

var message = """
    "This is a very important message."
    """;
Console.WriteLine(message);
// output: "This is a very important message."
// The leftmost whitespace is not part of the raw string literal

Spalten rechts neben der schließenden Anführungszeichensequenz werden beibehalten. Dieses Verhalten ermöglicht unformatierte Zeichenfolgen für Datenformate wie JSON, YAML oder XML, wie im folgenden Beispiel gezeigt:

var json= """
    {
        "prop": 0
    }
    """;

Der Compiler gibt einen Fehler aus, wenn sich eine der Textzeilen von der schließenden Anführungszeichensequenz nach links erstreckt. Die öffnenden und schließenden Anführungszeichensequenz können sich in derselben Zeile befinden, sofern der Zeichenfolgenliteral weder mit einem Anführungszeichen beginnt noch damit endet:

var shortText = """He said "hello!" this morning.""";

Sie können unformatierte Zeichenfolgenliterale mit der Zeichenfolgeninterpolation kombinieren, um Anführungszeichen und Klammern in die Ausgabezeichenfolge einzuschließen.

Zeichenfolgenliterale in Anführungszeichen werden in doppelte Anführungszeichen (") eingeschlossen:

"good morning"  // a string literal

Zeichenfolgenliterale können jeden Zeichenliteral enthalten. Escapesequenzen sind enthalten. 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.

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. Escapecodes aus achtstelligen Unicode werden auch erkannt: \Udddddddd.

Wörtliche Zeichenfolgenliterale beginnen mit @ und sind ebenfalls in doppelte Anführungszeichen eingeschlossen. Beispiel:

@"good morning"  // a string literal

Der Vorteil von ausführlichen Zeichenfolgen besteht darin, dass Escapesequenzen nicht verarbeitet werden, sodass das Schreiben erleichtert wird. Der folgende Text entspricht beispielsweise einem vollqualifizierten Windows-Dateinamen:

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

Um ein doppeltes Anführungszeichen in eine @-Zeichenfolge aufzunehmen, müssen Sie es verdoppeln:

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

UTF-8-Zeichenfolgenliterale

Zeichenfolgen in .NET werden mit UTF-16-Codierung gespeichert. UTF-8 ist der Standard für Webprotokolle und andere wichtige Bibliotheken. Ab C# 11 können Sie das Suffix u8 zu einem Zeichenfolgenliteral hinzufügen, um die UTF-8-Codierung anzugeben. UTF-8-Literale werden als ReadOnlySpan<byte>-Objekte gespeichert. Der natürliche Typ eines UTF-8-Zeichenfolgenliterals ist ReadOnlySpan<byte>. Durch Verwendung eines UTF-8-Zeichenfolgenliterals entsteht eine klarere Deklaration als beim Deklarieren des entsprechenden System.ReadOnlySpan<T>, wie im folgenden Code gezeigt:

ReadOnlySpan<byte> AuthWithTrailingSpace = new byte[] { 0x41, 0x55, 0x54, 0x48, 0x20 };
ReadOnlySpan<byte> AuthStringLiteral = "AUTH "u8;

Zum Speichern eines UTF-8-Zeichenfolgenliterals als Array muss ReadOnlySpan<T>.ToArray() verwendet werden, um die Bytes, die das Literal enthalten, in das veränderliche Array zu kopieren:

byte[] AuthStringLiteral = "AUTH "u8.ToArray();

UTF-8-Zeichenfolgenliterale sind keine Kompilierzeitkonstanten, sondern Laufzeitkonstanten. Daher können sie nicht als Standardwert für einen optionalen Parameter verwendet werden. UTF-8-Zeichenfolgenliterale können nicht mit der Zeichenfolgeninterpolation kombiniert werden. Sie können das $-Token und das u8-Suffix nicht für denselben Zeichenfolgenausdruck verwenden.

Der Delegattyp

Die Deklaration eines Delegattyps ähnelt einer Methodensignatur. Er verfügt über einen Rückgabewert und eine beliebige Anzahl Parameter eines beliebigen Typs:

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. Sie werden sehr wahrscheinlich keine neuen benutzerdefinierten Delegattypen definieren müssen. Stattdessen können Sie Instanziierungen der bereitgestellten generischen Typen erstellen.

Ein delegate ist ein Verweistyp, der verwendet werden kann, um eine benannte oder anonyme Methode zu kapseln. Delegaten entsprechen den Funktionszeigern in C++, sind jedoch typsicher und geschützt. Anwendungsmöglichkeiten von Delegaten finden Sie unter Delegaten und Generische Delegaten. Delegaten bilden die Grundlage für Ereignisse. Ein Delegat kann instanziiert werden, entweder durch Zuordnen mit einer benannten oder einer anonymen Methode.

Der Delegat muss mit einer Methode oder einem Lambda-Ausdruck instanziiert werden, der über einen kompatiblen Rückgabetypen und Eingabeparameter verfügt. Weitere Informationen zum Grad der Varianz, der in der Methodensignatur zulässig ist, finden Sie unter Varianz bei Delegaten. Für die Verwendung mit anonymen Methoden werden der Delegat und der Code, der mit ihm zugeordnet werden soll, zusammen deklariert.

Das Kombinieren oder Entfernen von Delegaten schlägt mit einer Laufzeitausnahme fehl, wenn die zur Laufzeit beteiligten Delegattypen aufgrund der Variantenkonvertierung unterschiedlich sind. Im folgenden Beispiel wird eine Situation veranschaulicht, in der ein Fehler auftritt:

Action<string> stringAction = str => {};
Action<object> objectAction = obj => {};
  
// Valid due to implicit reference conversion of
// objectAction to Action<string>, but may fail
// at run time.
Action<string> combination = stringAction + objectAction;

Sie können einen Delegaten mit dem richtigen Laufzeittyp erstellen, indem Sie ein neues Delegatobjekt erstellen. Im folgenden Beispiel wird veranschaulicht, wie diese Problemumgehung auf das vorherige Beispiel angewendet werden kann.

Action<string> stringAction = str => {};
Action<object> objectAction = obj => {};
  
// Creates a new delegate instance with a runtime type of Action<string>.
Action<string> wrappedObjectAction = new Action<string>(objectAction);

// The two Action<string> delegate instances can now be combined.
Action<string> combination = stringAction + wrappedObjectAction;

Sie können Funktionszeiger deklarieren, die eine ähnliche Syntax verwenden. Ein Funktionszeiger verwendet die calli-Anweisung, anstatt einen Delegattyp zu instanziieren und die virtuelle Invoke-Methode aufzurufen.

Der dynamische Typ

Der dynamic-Typ gibt an, dass durch die Verwendung der Variablen und Verweise auf die entsprechenden Member die Prüfung des Kompilierzeittyps umgangen wird. Stattdessen werden diese Vorgänge zur Laufzeit aufgelöst. 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).

Der Typ dynamic verhält sich in den meisten Fällen wie Typ object. Insbesondere können alle Ausdrücke, die nicht NULL sind, in den dynamic-Typ konvertiert werden. 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. Der Compiler packt Informationen über den Vorgang. Diese Informationen werden später zur Evaluierung des Vorgangs zur Laufzeit verwendet. Als Teil dieses Prozesses werden Variablen des Typs dynamic in Variablen des Typs object kompiliert. Deshalb existiert der Typ dynamic nur zur Kompilierzeit und nicht zur Laufzeit.

Das folgende Beispiel vergleicht den Unterschied einer Variable des Typs dynamic mit einer Variable des Typs object. Um den Typ jeder Variable zur Kompilierzeit zu überprüfen, zeigen Sie mit dem Mauszeiger auf dyn oder obj in den WriteLine-Anweisungen. Kopieren Sie den folgenden Code in einen Editor, in dem IntelliSense verfügbar ist. IntelliSense zeigt dynamic für dyn und object für 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. Zu diesem Zeitpunkt verfügen beide denselben Typ, Integer. Es wird die folgende Ausgabe generiert:

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.

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. Es wird jedoch kein Fehler für dyn + 3 gemeldet. Der Ausdruck, der dyn enthält, wird nicht zur Kompilierzeit überprüft, da der Typ von dyndynamic ist.

Das folgende Beispiel verwendet dynamic in einigen Deklarationen. Die Main-Methode unterscheidet auch die Typüberprüfung zur Kompilierzeit und die Laufzeittypüberprüfung.

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

C#-Sprachspezifikation

Weitere Informationen finden Sie in den folgenden Abschnitten der C#-Sprachspezifikation:

Weitere Informationen