Was ist eine angemessene Verwendung von Downcasting?

Downcasting bedeutet das Umwandeln von einer Basisklasse (oder Schnittstelle) in eine Unterklasse oder Blattklasse.

Ein Beispiel für einen Downcast könnte sein, wenn Sie von System.Objectzu einem anderen Typ wechseln.

Downcasting ist unbeliebt, vielleicht ein Code-Geruch: Objektorientierte Doktrin ist es beispielsweise vorzuziehen, virtuelle oder abstrakte Methoden zu definieren und aufzurufen, anstatt Downcasting.

• Was sind gute und angemessene Anwendungsfälle für das Downcasting? Das heißt, unter welchen Umständen ist es angemessen, heruntergestoßenen Code zu schreiben?
• Wenn Ihre Antwort "keine" lautet, warum wird Downcasting dann von der Sprache unterstützt?

Hier sind einige Verwendungszwecke von Downcasting.

Und ich widerspreche anderen hier mit Respekt vehement , dass die Verwendung von Downcasts definitiv ein Codegeruch ist , weil ich glaube, dass es keinen anderen vernünftigen Weg gibt, die entsprechenden Probleme zu lösen.

Equals:

class A
{
    // Nothing here, but if you're a C++ programmer who dislikes object.Equals(object),
    // pretend it's not there and we have abstract bool A.Equals(A) instead.
}
class B : A
{
    private int x;
    public override bool Equals(object other)
    {
        var casted = other as B;  // cautious downcast (dynamic_cast in C++)
        return casted != null && this.x == casted.x;
    }
}

Clone:

class A : ICloneable
{
    // Again, if you dislike ICloneable, that's not the point.
    // Just ignore that and pretend this method returns type A instead of object.
    public virtual object Clone()
    {
        return this.MemberwiseClone();  // some sane default behavior, whatever
    }
}
class B : A
{
    private int[] x;
    public override object Clone()
    {
        var copy = (B)base.Clone();  // known downcast (static_cast in C++)
        copy.x = (int[])this.x.Clone();  // oh hey, another downcast!!
        return copy;
    }
}

Stream.EndRead/Write:

class MyStream : Stream
{
    private class AsyncResult : IAsyncResult
    {
        // ...
    }
    public override int EndRead(IAsyncResult other)
    {
        return Blah((AsyncResult)other);  // another downcast (likely ~static_cast)
    }
}

Wenn Sie behaupten, dass dies Code-Gerüche sind, müssen Sie bessere Lösungen für sie bereitstellen (auch wenn sie aufgrund von Unannehmlichkeiten vermieden werden). Ich glaube nicht, dass es bessere Lösungen gibt.

Downcasting ist unbeliebt, vielleicht ein Codegeruch

Ich stimme dir nicht zu. Downcasting ist sehr beliebt ; Eine große Anzahl realer Programme enthält einen oder mehrere Downcasts. Und es ist vielleicht kein Codegeruch . Es ist definitiv ein Codegeruch. Aus diesem Grund muss der Downcasting-Vorgang im Programmtext enthalten sein . Es ist so, dass Sie den Geruch leichter bemerken und die Aufmerksamkeit der Code-Überprüfung darauf richten können.

unter welchen umständen ist es angebracht, code zu schreiben, der downcasts?

In allen Fällen, in denen:

• Sie verfügen über eine 100% korrekte Kenntnis eines Fakts über den Laufzeittyp eines Ausdrucks, der spezifischer ist als der Typ des Ausdrucks zur Kompilierungszeit
• Sie müssen diese Tatsache ausnutzen, um eine Funktion des Objekts zu verwenden, die für den Kompilierungstyp nicht verfügbar ist
• Es ist ein besserer Zeit- und Arbeitsaufwand, die Besetzung zu schreiben, als das Programm zu überarbeiten, um einen der ersten beiden Punkte zu eliminieren.

Wenn Sie ein Programm kostengünstig umgestalten können, so dass entweder der Laufzeit-Typ vom Compiler abgeleitet werden kann, oder das Programm umgestalten können, damit Sie nicht die Fähigkeit des weiter abgeleiteten Typs benötigen, dann tun Sie dies. Downcasts wurden zu der Sprache hinzugefügt, wenn es schwierig und teuer ist , das Programm so umzugestalten.

warum wird downcasting von der sprache unterstützt?

C # wurde von pragmatischen Programmierern erfunden, die Jobs zu erledigen haben, für pragmatische Programmierer, die Jobs zu erledigen haben. Die C # -Designer sind keine OO-Puristen. Und das C # -System ist nicht perfekt; Designbedingt werden die Einschränkungen, die für den Laufzeittyp einer Variablen gelten können, unterschätzt.

Downcasting ist auch in C # sehr sicher. Wir haben eine starke Garantie, dass der Downcast zur Laufzeit überprüft wird. Wenn dies nicht möglich ist, wird das Programm das Richtige tun und stürzt ab. Das ist wunderbar; Wenn sich herausstellt, dass Ihr 100% korrektes Verständnis der Typensemantik zu 99,99% korrekt ist, funktioniert Ihr Programm zu 99,99% und stürzt den Rest der Zeit ab, anstatt sich unvorhersehbar zu verhalten und Benutzerdaten in 0,01% der Fälle zu beschädigen .

ÜBUNG: Es gibt mindestens eine Möglichkeit, in C # einen Downcast zu erstellen, ohne einen expliziten Umwandlungsoperator zu verwenden. Können Sie sich solche Szenarien vorstellen? Da es sich auch um potenzielle Code-Gerüche handelt, welche Designfaktoren sind Ihrer Meinung nach für das Design eines Features verantwortlich, das einen Absturz nach unten verursachen kann, ohne dass eine Manifestierung im Code vorgenommen wird?

Ereignishandler haben normalerweise die Signatur MethodName(object sender, EventArgs e). In einigen Fällen ist es möglich, das Ereignis ohne Rücksicht auf den Typ senderoder sogar ohne Verwendung senderzu behandeln, in anderen Fällen sendermuss es jedoch auf einen spezifischeren Typ umgewandelt werden, um das Ereignis zu behandeln.

Beispielsweise haben Sie möglicherweise zwei TextBoxs und möchten einen einzelnen Delegaten verwenden, um ein Ereignis von jedem von ihnen zu behandeln. Dann müssten Sie senderin eine TextBoxumwandeln, damit Sie auf die erforderlichen Eigenschaften zugreifen können, um das Ereignis zu behandeln:

private void TextBox_TextChanged(object sender, EventArgs e)
{
   TextBox box = (TextBox)sender;
   box.BackColor = string.IsNullOrEmpty(box.Text) ? Color.Red : Color.White;
}

Ja, in diesem Beispiel können Sie eine eigene Unterklasse erstellen, für TextBoxdie dies intern durchgeführt wurde. Nicht immer praktisch oder möglich.

Sie brauchen Downcasting, wenn Ihnen etwas einen Supertyp gibt, und Sie müssen ihn je nach Subtyp unterschiedlich behandeln.

decimal value;
Donation d = user.getDonation();
if (d is CashDonation) {
     value = ((CashDonation)d).getValue();
}
if (d is ItemDonation) {
     value = itemValueEstimator.estimateValueOf(((ItemDonation)d).getItem());
}
System.out.println("Thank you for your generous donation of $" + value);

Nein, das riecht nicht gut. In einer perfekten Welt Donationhätte eine abstrakte Methode getValueund jeder implementierende Subtyp hätte eine entsprechende Implementierung.

Aber was ist, wenn diese Klassen aus einer Bibliothek stammen, die Sie nicht ändern können oder wollen? Dann gibt es keine andere Möglichkeit.

Hinzufügen zu Eric Lipperts Antwort, da ich keinen Kommentar abgeben kann ...

Sie können das Downcasting häufig vermeiden, indem Sie eine API für die Verwendung von Generika umgestalten. Aber Generika wurden erst die Version 2.0 der Sprache hinzugefügt . Selbst wenn Ihr eigener Code keine alten Sprachversionen unterstützen muss, werden Sie möglicherweise Legacy-Klassen verwenden, die nicht parametrisiert sind. Zum Beispiel kann eine Klasse so definiert werden, dass sie eine Nutzlast vom Typ trägt Object, die Sie gezwungenermaßen in den Typ umwandeln müssen, von dem Sie wissen, dass er tatsächlich ist.

Es gibt einen Kompromiss zwischen statischen und dynamisch getippten Sprachen. Durch die statische Typisierung erhält der Compiler eine Vielzahl von Informationen, um relativ starke Garantien für die Sicherheit von (Teilen von) Programmen zu geben. Dies ist jedoch mit Kosten verbunden, da Sie nicht nur wissen müssen, dass Ihr Programm korrekt ist, sondern auch den entsprechenden Code schreiben müssen, um den Compiler davon zu überzeugen, dass dies der Fall ist. Mit anderen Worten, Ansprüche zu erheben ist einfacher als sie zu beweisen.

Es gibt "unsichere" Konstrukte, mit deren Hilfe Sie dem Compiler unbewiesene Aussagen machen können . Zum Beispiel bedingungslose Anrufe an Nullable.Value, bedingungslose Unterdrückung, dynamicObjekte usw. Sie ermöglichen es Ihnen, eine Behauptung ("Ich behaupte, dass ein Objekt aein String, wenn ich mich irre, wirf ein InvalidCastException") geltend zu machen, ohne dass Sie dies beweisen müssen. Dies kann in Fällen hilfreich sein, in denen der Nachweis erheblich schwieriger ist als der Wert.

Missbrauch ist riskant, weshalb die explizite Downcast-Notation existiert und obligatorisch ist. Es ist syntaktisches Salz , das die Aufmerksamkeit auf eine unsichere Operation lenken soll. Die Sprache hätte mit implizitem Downcasting implementiert werden können (wobei der abgeleitete Typ eindeutig ist), aber das würde diese unsichere Operation verbergen, was nicht wünschenswert ist.

Downcasting wird aus mehreren Gründen als schlecht angesehen. In erster Linie denke ich, weil es Anti-OOP ist.

OOP würde es wirklich mögen, wenn Sie nie niedergeschlagen werden müssten, da Polymorphismus bedeutet, dass Sie nicht gehen müssen

if(object is X)
{
    //do the thing we do with X's
}
else
{
    //of the thing we do with Y's
}

du tust es einfach

x.DoThing()

und der Code macht automatisch das Richtige.

Es gibt einige "harte" Gründe, nicht niederzuschlagen:

• In C ++ ist es langsam.
• Sie erhalten einen Laufzeitfehler, wenn Sie den falschen Typ auswählen.

Aber die Alternative zum Downcasting in einigen Szenarien kann ziemlich hässlich sein.

Das klassische Beispiel ist die Nachrichtenverarbeitung, bei der Sie die Verarbeitungsfunktion nicht zum Objekt hinzufügen, sondern im Nachrichtenprozessor behalten möchten. Ich habe dann eine Tonne MessageBaseClassin einem Array zu verarbeiten, aber ich brauche auch jede nach Subtyp für die korrekte Verarbeitung.

Sie können Double Dispatch verwenden, um das Problem zu umgehen ( https://en.wikipedia.org/wiki/Double_dispatch ) ... Aber das hat auch seine Probleme. Oder Sie können einfach einen einfachen Code unter dem Risiko dieser schwerwiegenden Gründe herunterschleudern.

Dies war jedoch, bevor die Generika erfunden wurden. Jetzt können Sie das Downcasting vermeiden, indem Sie einen Typ angeben, in dem die später angegebenen Details enthalten sind.

MessageProccesor<T> Sie können die Methodenparameter und Rückgabewerte nach dem angegebenen Typ variieren, bieten jedoch weiterhin allgemeine Funktionen

Natürlich zwingt Sie niemand, OOP-Code zu schreiben, und es gibt viele Sprachfunktionen, die bereitgestellt werden, die jedoch verpönt sind, wie z. B. Reflexion.

Stellen Sie sich zusätzlich zu allen zuvor genannten eine Tag-Eigenschaft vor, die vom Typ object ist. Auf diese Weise können Sie ein Objekt Ihrer Wahl in einem anderen Objekt speichern und später bei Bedarf verwenden. Sie müssen diese Eigenschaft niederwerfen.

Im Allgemeinen ist das Nichtgebrauchen von etwas bis heute nicht immer ein Hinweis auf etwas Nutzloses ;-)

Der häufigste Einsatz von Downcasting in meiner Arbeit ist darauf zurückzuführen, dass ein Idiot das Substitutionsprinzip von Liskov verletzt.

Stellen Sie sich vor, es gibt eine Schnittstelle in einer Drittanbieter-Bibliothek.

public interface Foo
{
     void SayHello();
     void SayGoodbye();
 }

Und 2 Klassen, die es implementieren. Barund Qux. Barist gut erzogen.

public class Bar
{
    void SayHello()
    {
        Console.WriteLine(“Bar says hello.”);
    }
    void SayGoodbye()
    {
         Console.WriteLine(“Bar says goodbye”);
    }
}

Ist Quxaber nicht gut erzogen.

public class Qux
{
    void SayHello()
    {
        Console.WriteLine(“Qux says hello.”);
    }
    void SayGoodbye()
    {
        throw new NotImplementedException();
    }
}

Nun ... jetzt habe ich keine Wahl. Ich muss check und (möglicherweise) downcast eingeben, um zu vermeiden, dass mein Programm abstürzt.

Ein weiteres Beispiel aus der Praxis sind WPFs VisualTreeHelper. Es verwendet Downcast zum Casting DependencyObjectauf Visualund Visual3D. Zum Beispiel VisualTreeHelper.GetParent . Der Downcast erfolgt in VisualTreeUtils.AsVisualHelper :

private static bool AsVisualHelper(DependencyObject element, out Visual visual, out Visual3D visual3D)
{
    Visual elementAsVisual = element as Visual;

    if (elementAsVisual != null)
    {
        visual = elementAsVisual;
        visual3D = null;
        return true;
    }

    Visual3D elementAsVisual3D = element as Visual3D;

    if (elementAsVisual3D != null)
    {
        visual = null;
        visual3D = elementAsVisual3D;
        return true;
    }            

    visual = null;
    visual3D = null;
    return false;
}