Vorgehensweise: Sicheres Umwandeln mit Musterabgleich und den Operatoren „is“ und „as“

Da Objekte polymorph sind, ist es möglich, dass eine Variable eines Basisklassentyps einen abgeleiteten Typ enthält. Um auf die Instanzmitglieder des abgeleiteten Typs zuzugreifen, müssen Sie den Wert auf den abgeleiteten Typ zurückwandeln. Allerdings entsteht durch eine Umwandlung das Risiko, eine InvalidCastException-Ausnahme auszulösen. C# stellt Musterabgleich-Anweisungen bereit, die eine Umwandlung unter der Bedingung ausführen, dass sie erfolgreich sein wird. C# bietet auch die Operatoren is und as an, um zu testen, ob ein Wert einem bestimmten Typ entspricht.

Das folgende Beispiel zeigt die Verwendung der is-Anweisung zum Musterabgleich:

var g = new Giraffe();
var a = new Animal();
FeedMammals(g);
FeedMammals(a);
// Output:
// Eating.
// Animal is not a Mammal

SuperNova sn = new SuperNova();
TestForMammals(g);
TestForMammals(sn);
// Output:
// I am an animal.
// SuperNova is not a Mammal

static void FeedMammals(Animal a)
{
    if (a is Mammal m)
    {
        m.Eat();
    }
    else
    {
        // variable 'm' is not in scope here, and can't be used.
        Console.WriteLine($"{a.GetType().Name} is not a Mammal");
    }
}

static void TestForMammals(object o)
{
    // You also can use the as operator and test for null
    // before referencing the variable.
    var m = o as Mammal;
    if (m != null)
    {
        Console.WriteLine(m.ToString());
    }
    else
    {
        Console.WriteLine($"{o.GetType().Name} is not a Mammal");
    }
}

class Animal
{
    public void Eat() { Console.WriteLine("Eating."); }
    public override string ToString()
    {
        return "I am an animal.";
    }
}
class Mammal : Animal { }
class Giraffe : Mammal { }

class SuperNova { }

Im vorherigen Beispiel werden einige Features der Musterabgleichssyntax veranschaulicht. Die if (a is Mammal m) Anweisung kombiniert den Test mit einer Initialisierungszuweisung. Die Zuweisung erfolgt nur, wenn der Test erfolgreich ist. Die Variable m befindet sich nur im Bereich der eingebetteten if Anweisung, der sie zugewiesen wurde. Auf m kann später innerhalb derselben Methode nicht zugegriffen werden. Im vorherigen Beispiel wird auch gezeigt, wie Sie mit dem as Operator ein Objekt in einen angegebenen Typ konvertieren.

Sie können auch dieselbe Syntax zum Testen verwenden, wenn ein Nullwerttyp einen Wert aufweist, wie im folgenden Beispiel gezeigt:

int i = 5;
PatternMatchingNullable(i);

int? j = null;
PatternMatchingNullable(j);

double d = 9.78654;
PatternMatchingNullable(d);

PatternMatchingSwitch(i);
PatternMatchingSwitch(j);
PatternMatchingSwitch(d);

static void PatternMatchingNullable(ValueType? val)
{
    if (val is int j) // Nullable types are not allowed in patterns
    {
        Console.WriteLine(j);
    }
    else if (val is null) // If val is a nullable type with no value, this expression is true
    {
        Console.WriteLine("val is a nullable type with the null value");
    }
    else
    {
        Console.WriteLine("Could not convert " + val.ToString());
    }
}

static void PatternMatchingSwitch(ValueType? val)
{
    switch (val)
    {
        case int number:
            Console.WriteLine(number);
            break;
        case long number:
            Console.WriteLine(number);
            break;
        case decimal number:
            Console.WriteLine(number);
            break;
        case float number:
            Console.WriteLine(number);
            break;
        case double number:
            Console.WriteLine(number);
            break;
        case null:
            Console.WriteLine("val is a nullable type with the null value");
            break;
        default:
            Console.WriteLine("Could not convert " + val.ToString());
            break;
    }
}

Im vorherigen Beispiel werden weitere Features des Musterabgleichs veranschaulicht, die mit Konvertierungen verwendet werden sollen. Sie können eine Variable für das Nullmuster testen, indem Sie speziell auf den null Wert überprüfen. Wenn der Laufzeitwert der Variablen null ist, liefert eine is-Anweisung, die einen Typ überprüft, immer false zurück. Die Musterabgleichsanweisung is lässt keinen nullfähigen Werttyp wie int? oder Nullable<int> zu, jedoch können Sie für jeden anderen Werttyp testen. Die is Muster aus dem vorherigen Beispiel sind nicht auf die Nullwertetypen beschränkt. Sie können diese Muster auch verwenden, um zu testen, ob eine Variable eines Referenztyps einen Wert hat oder ob sie null ist.

Im vorherigen Beispiel wird auch gezeigt, wie Sie das Typmuster in einer switch Anweisung verwenden, in der die Variable einen von vielen verschiedenen Typen sein kann.

Wenn Sie testen möchten, ob eine Variable einen bestimmten Typ hat, sie aber keiner neuen Variable zuweisen möchten, können Sie die Operatoren is und as sowohl für Verweistypen als auch für nullable Werttypen verwenden. Der folgende Code zeigt, wie die Anweisungen is und as in der C#-Sprache verwendet werden, die vor der Einführung der Mustererkennung existierten, um zu testen, ob eine Variable einem bestimmten Typ entspricht.

// Use the is operator to verify the type.
// before performing a cast.
Giraffe g = new();
UseIsOperator(g);

// Use the as operator and test for null
// before referencing the variable.
UseAsOperator(g);

// Use pattern matching to test for null
// before referencing the variable
UsePatternMatchingIs(g);

// Use the as operator to test
// an incompatible type.
SuperNova sn = new();
UseAsOperator(sn);

// Use the as operator with a value type.
// Note the implicit conversion to int? in
// the method body.
int i = 5;
UseAsWithNullable(i);

double d = 9.78654;
UseAsWithNullable(d);

static void UseIsOperator(Animal a)
{
    if (a is Mammal)
    {
        Mammal m = (Mammal)a;
        m.Eat();
    }
}

static void UsePatternMatchingIs(Animal a)
{
    if (a is Mammal m)
    {
        m.Eat();
    }
}

static void UseAsOperator(object o)
{
    Mammal? m = o as Mammal;
    if (m is not null)
    {
        Console.WriteLine(m.ToString());
    }
    else
    {
        Console.WriteLine($"{o.GetType().Name} is not a Mammal");
    }
}

static void UseAsWithNullable(System.ValueType val)
{
    int? j = val as int?;
    if (j is not null)
    {
        Console.WriteLine(j);
    }
    else
    {
        Console.WriteLine("Could not convert " + val.ToString());
    }
}
class Animal
{
    public void Eat() => Console.WriteLine("Eating.");
    public override string ToString() => "I am an animal.";
}
class Mammal : Animal { }
class Giraffe : Mammal { }

class SuperNova { }

Wie Sie sehen können, indem Sie diesen Code mit dem Musterabgleichscode vergleichen, bietet die Mustervergleichssyntax robustere Features, indem sie den Test und die Zuordnung in einer einzelnen Anweisung kombinieren. Verwenden Sie nach Möglichkeit die Mustervergleichssyntax.