Gewusst wie: Sichere Umwandlung mit den Operatoren "as" und "is" (C#-Programmierhandbuch)

Da Objekte polymorph sind, kann eine Variable eines Basisklassentyps einen abgeleiteten Typ enthalten. Zum Zugreifen auf die Methode des angeleiteten Typs muss der Wert wieder in den abgeleiteten Typ umgewandelt werden. Wenn Sie in diesen Fällen jedoch versuchen, eine einfache Umwandlung durchzuführen, riskieren Sie das Auslösen einer InvalidCastException. Dies ist der Grund, warum C# die Operatoren is und as bereitstellt. Sie können diese Operatoren verwenden, um zu testen, ob eine Umwandlung erfolgreich sein wird, ohne dass eine Ausnahme ausgelöst wird. Im Allgemeinen ist der Operator as effizienter, da er tatsächlich den Umwandlungswert zurückgibt, falls die Umwandlung erfolgreich durchgeführt werden kann. Der is-Operator gibt nur einen booleschen Wert zurück. Er kann deshalb verwendet werden, wenn Sie nur den Objekttyp ermitteln möchten, ihn aber nicht umwandeln müssen.

Beispiel

In den folgenden Beispielen wird dargestellt, wie die Operatoren is und as zum Umwandeln von einem Referenztyp in einen anderen verwendet werden, ohne dass eine Ausnahme ausgelöst wird. Im Beispiel wird auch dargestellt, wie der as-Operator mit auf NULL festlegbaren Werttypen verwendet wird.

class SafeCasting
{
    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 { }

    static void Main()
    {
        SafeCasting app = new SafeCasting();

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

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

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

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


        double d = 9.78654;
        app.UseAsWithNullable(d);

        // Keep the console window open in debug mode.
        System.Console.WriteLine("Press any key to exit.");
        System.Console.ReadKey();
    }

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

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

    void UseAsWithNullable(System.ValueType val)
    {
        int? j = val as int?;
        if (j != null)
        {
            Console.WriteLine(j);
        }
        else
        {
            Console.WriteLine("Could not convert " + val.ToString());
        }
    }
}

Siehe auch

Typen
Umwandlung und Typkonvertierungen
Typen, die NULL-Werte zulassen