O que é um uso adequado de downcasting?

Downcasting significa conversão de uma classe base (ou interface) para uma subclasse ou folha.

Um exemplo de downcast pode ser se você transmitir System.Objectpara outro tipo.

O downcasting é impopular, talvez um cheiro de código: a doutrina orientada a objetos é preferir, por exemplo, definir e chamar métodos virtuais ou abstratos em vez do downcasting.

• Quais são, se houver, casos de uso adequados e adequados para downcasting? Ou seja, em que circunstância (s) é apropriado escrever código que faça downcasts?
• Se sua resposta for "nenhuma", por que o downcast é suportado pelo idioma?

Aqui estão alguns usos adequados de downcasting.

E eu respeitosamente discordo veementemente de outras pessoas aqui que dizem que o uso de downcasts é definitivamente um cheiro de código, porque acredito que não há outra maneira razoável de resolver os problemas correspondentes.

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)
    }
}

Se você quiser dizer que são odores de código, precisará fornecer soluções melhores para eles (mesmo que sejam evitados devido a inconveniências). Não acredito que existam melhores soluções.

Downcasting é impopular, talvez um cheiro de código

Discordo. Downcasting é extremamente popular ; um grande número de programas do mundo real contém um ou mais downcasts. E talvez não seja um cheiro de código. Definitivamente, é um cheiro de código. É por isso que a operação de downcast deve se manifestar no texto do programa . É para que você possa notar mais facilmente o cheiro e passar a atenção da revisão do código.

em que circunstância (s) é apropriado escrever código que faça downcasts?

Em qualquer circunstância em que:

• você tem um conhecimento 100% correto de um fato sobre o tipo de tempo de execução de uma expressão que é mais específico que o tipo de expressão em tempo de compilação e
• você precisa aproveitar esse fato para usar um recurso do objeto não disponível no tipo de tempo de compilação e
• é melhor usar o tempo e o esforço para escrever o elenco do que refatorar o programa para eliminar qualquer um dos dois primeiros pontos.

Se você pode refatorar um programa de forma barata para que o tipo de tempo de execução possa ser deduzido pelo compilador ou refatorar o programa para que você não precise da capacidade do tipo mais derivado, faça-o. Os downcasts foram adicionados ao idioma nas circunstâncias em que é difícil e caro refatorar o programa.

por que o downcasting é suportado pelo idioma?

O C # foi inventado por programadores pragmáticos que têm trabalhos a fazer, para programadores pragmáticos que têm trabalhos a fazer. Os designers de C # não são puristas de OO. E o sistema do tipo C # não é perfeito; por design, subestima as restrições que podem ser colocadas no tipo de tempo de execução de uma variável.

Além disso, o downcasting é muito seguro em c #. Temos uma forte garantia de que o downcast será verificado no tempo de execução e, se não puder ser verificado, o programa fará a coisa certa e trava. Isso é maravilhoso; significa que, se seu entendimento 100% correto da semântica de tipos estiver 99,99% correto, seu programa funcionará 99,99% do tempo e trava o resto do tempo, em vez de se comportar de forma imprevisível e corromper os dados do usuário em 0,01% .

EXERCÍCIO: Há pelo menos uma maneira de produzir um downcast em C # sem usar um operador de conversão explícito. Você consegue pensar em tais cenários? Como esses também são odores de código em potencial, que fatores de design você acha que foram para o design de um recurso que poderia produzir uma falha de downcast sem ter um manifesto convertido no código?

Manipuladores de eventos geralmente têm a assinatura MethodName(object sender, EventArgs e). Em alguns casos, é possível manipular o evento sem considerar o tipo sender, ou mesmo sem usá sender-lo, mas em outros senderdeve ser convertido para um tipo mais específico para manipular o evento.

Por exemplo, você pode ter dois TextBoxse deseja usar um único representante para manipular um evento de cada um deles. Em seguida, você precisaria converter senderpara a TextBoxpara poder acessar as propriedades necessárias para manipular o evento:

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

Sim, neste exemplo, você pode criar sua própria subclasse, a TextBoxqual fez isso internamente. Nem sempre é prático ou possível, no entanto.

Você precisa fazer downcasting quando algo lhe der um supertipo e precisar lidar com isso de maneira diferente, dependendo do subtipo.

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);

Não, isso não cheira bem. Em um mundo perfeito Donation, teria um método abstrato getValuee cada subtipo de implementação teria uma implementação apropriada.

Mas e se essas classes forem de uma biblioteca que você não pode ou não deseja alterar? Então não há outra opção.

Para adicionar à resposta de Eric Lippert, já que não posso comentar ...

Muitas vezes, você pode evitar downcasting refatorando uma API para usar genéricos. Mas os genéricos não foram adicionados ao idioma até a versão 2.0 . Portanto, mesmo que seu próprio código não precise suportar versões de idiomas antigos, você poderá usar classes herdadas que não são parametrizadas. Por exemplo, algumas classes podem ser definidas para transportar uma carga útil do tipo Object, que você é forçado a converter no tipo que realmente é.

Há uma troca entre linguagens estáticas e dinamicamente tipadas. A digitação estática fornece ao compilador muitas informações para poder oferecer garantias bastante fortes sobre a segurança de (partes de) programas. Isso tem um custo, no entanto, porque você não apenas precisa saber que seu programa está correto, mas também deve escrever o código apropriado para convencer o compilador de que esse é o caso. Em outras palavras, fazer reivindicações é mais fácil do que prová-las.

Existem construções "inseguras" que ajudam a fazer afirmações não comprovadas para o compilador. Por exemplo, chamadas incondicionais para Nullable.Value, downcasts incondicionais, dynamicobjetos etc. Eles permitem que você afirme uma reivindicação ("Eu afirmo que o objeto aé String, se estiver errado, lance um InvalidCastException") sem a necessidade de provar. Isso pode ser útil nos casos em que provar que é significativamente mais difícil do que valer a pena.

Abusar disso é arriscado, e é exatamente por isso que a notação explícita de downcast existe e é obrigatória; é sal sintático destinado a chamar a atenção para uma operação insegura. O idioma poderia ter sido implementado com downcasting implícito (onde o tipo inferido é inequívoco), mas isso ocultaria essa operação insegura, o que não é desejável.

O downcasting é considerado ruim por alguns motivos. Penso principalmente porque é anti-OOP.

OOP realmente gostaria se você nunca tivesse que se abaixar, pois sua "razão de ser" é que o polimorfismo significa que você não precisa ir

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

você apenas faz

x.DoThing()

e o código automaticamente faz a coisa certa.

Existem algumas razões 'difíceis' para não fazer downcast:

• Em C ++, é lento.
• Você recebe um erro de tempo de execução se escolher o tipo errado.

Mas a alternativa ao downcasting em alguns cenários pode ser bastante feia.

O exemplo clássico é o processamento de mensagens, no qual você não deseja adicionar a função de processamento ao objeto, mas a mantém no processador de mensagens. Em seguida, tenho uma tonelada de MessageBaseClassem uma matriz para processar, mas também preciso de cada uma por subtipo para o processamento correto.

Você pode usar o Double Dispatch para solucionar o problema ( https://en.wikipedia.org/wiki/Double_dispatch ) ... Mas isso também tem seus problemas. Ou você pode simplesmente fazer o downcast por algum código simples, correndo o risco desses motivos difíceis.

Mas isso foi antes da criação dos genéricos. Agora você pode evitar o downcasting fornecendo um tipo em que os detalhes especificados posteriormente.

MessageProccesor<T> pode variar seus parâmetros de método e retornar valores pelo tipo especificado, mas ainda fornecer funcionalidade genérica

É claro que ninguém está forçando você a escrever código OOP e há muitos recursos de linguagem que são fornecidos, mas que são mal vistos, como reflexão.

Além de tudo o que foi dito anteriormente, imagine uma propriedade Tag que seja do tipo objeto. Ele fornece uma maneira de armazenar um objeto de sua escolha em outro objeto para uso posterior conforme necessário. Você precisa fazer o downcast dessa propriedade.

Em geral, não usar algo até hoje nem sempre é uma indicação de algo inútil ;-)

O uso mais comum de downcasting no meu trabalho é devido a algum idiota que quebra o princípio da substituição de Liskov.

Imagine que há uma interface em alguma biblioteca de terceiros.

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

E 2 classes que o implementam. Bare Qux. Baré bem comportado.

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

Mas Quxnão é bem comportado.

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

Bem ... agora não tenho escolha. Eu tenho que digitar check e (possivelmente) downcast para evitar que meu programa pare.

Outro exemplo do mundo real são os WPFs VisualTreeHelper. Ele usa downcast para transmitir DependencyObjectpara Visuale Visual3D. Por exemplo, VisualTreeHelper.GetParent . O downcast acontece em 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;
}