Що таке правильне використання каналу?

Даудаустинг означає передачу з базового класу (або інтерфейсу) на підклас або клас класу.

Прикладом пониження може бути, якщо ви переходите System.Objectна інший тип.

Downcasting непопулярний, можливо, кодовий запах. Об'єктно-орієнтована доктрина - це віддати перевагу, наприклад, визначенню та виклику віртуальних чи абстрактних методів замість того, щоб придушувати.

• Які, якщо такі є, хороші та правильні випадки використання для приходу вниз? Тобто, за яких обставин (ив) доцільно писати код, який знищує?
• Якщо ваша відповідь - "ні", то чому підтримка мовою підтримується мовою?

Ось кілька належних способів використання каналу.

І я з повагою жорстоко не погоджуюся з іншими тут, які кажуть, що використання downcast - це, безумовно, кодовий запах, тому що я вважаю, що немає іншого розумного способу вирішення відповідних проблем.

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

Якщо ви збираєтеся сказати, що це кодові запахи, вам потрібно надати кращі рішення для них (навіть якщо їх уникнути через незручності). Я не вірю, що кращі рішення існують.

Даунсинг - це непопулярний, можливо, кодовий запах

Я не погоджуюсь. Downcasting надзвичайно популярний ; величезна кількість реальних програм містять один або декілька знижень. І це не можливо кодовий запах. Це, безумовно, кодовий запах. Ось чому операція пониження моменту вимагає виявлення в тексті програми . Це так, що ви можете легше помітити запах і витратити на нього перегляд коду.

за яких обставин [и] доцільно писати код, який знищує?

За будь-яких обставин, коли:

• у вас є 100% правильне знання факту про тип вираження, який є більш конкретним, ніж тип виразу часу компіляції, і
• вам потрібно скористатися цим фактом, щоб використати можливості об'єкта, недоступного для типу компіляції, і
• краще написати час та зусилля для написання ролі, ніж рефактор програми, щоб усунути будь-який із перших двох пунктів.

Якщо ви можете дешево переробити програму, щоб компілятор міг визначити або тип виконання, або переробити програму, щоб вам не потрібні можливості більш похідного типу, тоді зробіть це. Зниження мови було додано до мови для тих обставин, коли важко і дорого таким чином переробити програму.

чому підтримка мовлення підтримується мовою?

C # був винайдений прагматичними програмістами, які мають працювати, для прагматичних програмістів, які мають працювати. Дизайнери C # не є пуристами OO. І система типу C # не є досконалою; за допомогою проекту він недооцінює обмеження, які можуть бути розміщені на типі виконання змінної.

Крім того, посилання вниз # є дуже безпечним у C #. Ми маємо тверду гарантію, що вихідний режим буде перевірений під час виконання, і якщо його не вдасться перевірити, програма зробить правильно і вийде з ладу. Це чудово; це означає, що якщо ваше 100% правильне розуміння семантики типів виявляється правильним на 99,99%, то ваша програма працює 99,99% часу і решту часу припиняє роботу, замість того, щоб вести себе непередбачувано і пошкоджувати дані користувачів 0,01% часу .

Вправа: Існує щонайменше один спосіб створити пониження в C # без використання явного оператора лиття. Чи можете ви придумати будь-який подібний сценарій? Оскільки це також потенційні запахи коду, які дизайнерські фактори, на вашу думку, увійшли в розробку функції, яка могла б призвести до аварійного поломки, не маючи явного відтворення в коді?

Обробники подій зазвичай мають підпис MethodName(object sender, EventArgs e). В деяких випадках можна поводитися з подією, не враховуючи, який тип senderє, або навіть не використовуючи його senderвзагалі, але в інших senderпотрібно передати більш конкретний тип для обробки події.

Наприклад, у вас може бути два TextBoxs, і ви хочете використовувати одного делегата для обробки події з кожного з них. Тоді вам потрібно буде senderперейти на TextBoxтак, щоб ви мали доступ до необхідних властивостей для обробки події:

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

Так, у цьому прикладі ви можете створити власний підклас, TextBoxякий робив це всередині країни. Хоча це не завжди практично або можливо.

Вам потрібен пониження рівня, коли щось дає супертип і вам потрібно по-різному поводитися з ним, залежно від підтипу.

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

Ні, це не пахне добре. У досконалому світі Donationбув би абстрактний метод, getValueі кожен реалізуючий підтип мав би відповідну реалізацію.

Але що робити, якщо ці класи з бібліотеки, яку ви не можете або не хочете змінювати? Тоді іншого варіанту немає.

Щоб додати відповідь Еріка Ліпперта, оскільки я не можу коментувати ...

Часто ви можете уникнути зриву каналів, перетворюючи API на використання генеричних даних. Але дженерики не були додані до мови до версії 2.0 . Тож навіть якщо ваш власний код не потребує підтримки старовинних мовних версій, ви можете опинитися за допомогою застарілих класів, які не параметризовані. Наприклад, якийсь клас може бути визначений для перенесення корисного навантаження типу Object, який ви змушені передати тому типу, яким ви насправді є.

Існує компроміс між статичними та динамічно набраними мовами. Статичний типізація дає компілятору багато інформації, щоб можна було зробити досить міцні гарантії щодо безпеки (частин) програм. Однак це досягає великих витрат, тому що ви не тільки повинні знати, що ваша програма правильна, але ви повинні написати відповідний код, щоб переконати компілятора, що це так. Іншими словами, пред'являти претензії простіше, ніж доводити їх.

Існують "небезпечні" конструкції, які допомагають зробити недоведені твердження компілятору. Наприклад, безумовні дзвінки до Nullable.Value, безумовних похибок, dynamicоб'єктів тощо. Вони дозволяють стверджувати претензію ("Я стверджую, що об'єкт a- це String, якщо я помиляюся, кидаю InvalidCastException"), не потребуючи доказу. Це може бути корисно у випадках, коли довести це значно важче, ніж варто.

Зловживання цим є ризикованим, саме тому явна нотація знищення існує і є обов'язковою; його синтаксична сіль покликана привернути увагу до небезпечної операції. Мова могла бути реалізована за допомогою неявного зменшення мовлення (де висновок типу однозначний), але це приховувало б цю небезпечну операцію, що не бажано.

Пониження мов вважається поганим з кількох причин. В першу чергу я думаю, тому що це анти-OOP.

OOP дуже хотілося б, якби вам ніколи не доводилося зводити з ладу, оскільки його "raison-d'etre" полягає в тому, що поліморфізм означає, що вам не доведеться їхати

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

ти просто робиш

x.DoThing()

і код автоматично магічно робить все правильно.

Є деякі "важкі" причини, щоб не збивати з ладу:

• У С ++ це повільно.
• Якщо ви вибрали неправильний тип, ви отримаєте помилку виконання.

Але альтернатива збитковість в деяких сценаріях може бути досить потворною.

Класичний приклад - обробка повідомлень, де ви не хочете додавати функцію обробки до об’єкта, а зберігати її в процесорі повідомлень. Тоді я маю тонну MessageBaseClassмасиву для обробки, але мені також потрібна кожна підтип для правильної обробки.

Ви можете скористатися функцією Double Dispatch, щоб подолати проблему ( https://en.wikipedia.org/wiki/Double_dispatch ) ... Але це також має свої проблеми. Або ви можете просто спуститися за якийсь простий код, ризикуючи з цих важких причин.

Але це було до того, як були винайдені дженерики. Тепер ви можете уникнути зриву, надавши тип, де деталі вказані пізніше.

MessageProccesor<T> може змінювати параметри методу та повертати значення за вказаним типом, але все ж забезпечувати загальну функціональність

Звичайно, ніхто не змушує вас писати код OOP, і є багато мовних функцій, які надаються, але нахмурилися, як-от рефлексія.

Крім усього сказаного раніше, уявіть властивість Tag, яка є об'єктом типу. Він надає спосіб зберігати обраний вами об'єкт в іншому об'єкті для подальшого використання у міру необхідності. Вам потрібно скинути цю власність.

Взагалі, не використовувати щось до сьогоднішнього дня - це не завжди ознака чогось марного ;-)

Найчастіше використання мовлення в моїй роботі пояснюється тим, що якийсь ідіот порушує принцип заміщення Ліскова.

Уявіть, що в якомусь сторонній lib є інтерфейс.

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

І 2 класи, які його реалізують. Barі Qux. Barдобре поводиться.

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

Але Quxпогано поводиться.

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

Ну ... зараз у мене немає вибору. Я маю набрати перевірку та (можливо) згорнуту роботу, щоб уникнути припинення моєї програми.

Інший приклад у реальному світі - WPF VisualTreeHelper. Він використовує downcast для DependencyObjectпередачі на Visualта Visual3D. Наприклад, VisualTreeHelper.GetParent . Зниження відбувається в 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;
}