Чи має сенс використовувати "як" замість актового фільму, навіть якщо немає нульової перевірки? [зачинено]

У блогах про розробку, прикладах коду в Інтернеті та (останнім часом) навіть книзі, я постійно спотикаюся про такий код:

var y = x as T;
y.SomeMethod();

або, що ще гірше:

(x as T).SomeMethod();

Це не має для мене сенсу. Якщо ви впевнені, що xце тип T, ви повинні використовувати прямий склад :(T)x . Якщо ви не впевнені, можете скористатися, asале потрібно перевірити, nullперш ніж виконати якусь операцію. Все, що вищезазначений код робить - це перетворити (корисний) InvalidCastExceptionна (марний) NullReferenceException.

Я єдиний, хто думає, що це кричуще зловживання as ключовим словом? Або я пропустив щось очевидне, і зазначена вище модель насправді має сенс?

Ваше розуміння вірно. Це звучить як намагання мікрооптимізувати для мене. Ви повинні використовувати звичайний ролик, коли впевнені у своєму роді. Окрім створення більш розумного винятку, воно також швидко провалюється. Якщо ви помиляєтесь у своєму припущенні про тип, ваша програма вийде з ладу негайно, і ви зможете побачити причину відмови негайно, а не чекати NullReferenceExceptionчи ArgumentNullExceptionабо навіть логічну помилку десь у майбутньому. Взагалі asвираз, за ​​яким nullдесь не слід перевіряти, - це запах коду.

З іншого боку, якщо ви не впевнені в складі кадру і очікуєте, що він не вдасться, вам слід скористатися asзамість звичайного амплуа, обгорнутого try-catchблоком. Крім того, asрекомендується використовувати для перевірки типу, за якою слідує виступ. Замість:

if (x is SomeType)
   ((SomeType)x).SomeMethod();

яка генерує isinstінструкцію для isключового слова, і acastclass інструкцію для акторського складу (ефективно виконуючи двічі), слід використовувати:

var v = x as SomeType;
if (v != null)
    v.SomeMethod();

Це генерує лише isinst інструкцію. Колишній метод має потенційний недолік у багатопотокових програмах, оскільки умова перегонів може спричинити зміну свого типу змінної після того, як isперевірка була успішною та не вдалася на лінію передачі . Останній метод не схильний до цієї помилки.

_{Наступне рішення: не рекомендується використовувати у виробничому коді. Якщо ви справді ненавидите таку фундаментальну конструкцію в C #, ви можете розглянути можливість переходу на VB чи іншу мову.}

У випадку, якщо хтось відчайдушно ненавидить синтаксис литого, він / вона може написати метод розширення, щоб імітувати гру:

public static T To<T>(this object o) { // Name it as you like: As, Cast, To, ...
    return (T)o;
}

і використовувати акуратний [?] синтаксис:

obj.To<SomeType>().SomeMethod()

IMHO, asпросто має сенс у поєднанні з nullчеком:

var y = x as T;
if (y != null)
    y.SomeMethod();

Використання "as" не застосовує конверсії, визначені користувачем, тоді як команда використовує їх, де це доречно. Це може бути важливою відмінністю в деяких випадках.

Я трохи про це написав тут:

http://blogs.msdn.com/ericlippert/archive/2009/10/08/what-s-the-difference-between-as-and-cast-operators.aspx

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

Однак є тонка різниця. (x як T). Що б не говорило () я знаю, не тільки те, що x може бути перетворено на T, але, крім того, це робить лише посилання на конверсії або розпакування, і, тим більше, що x не є нульовим. Це передає іншу інформацію, ніж ((T) x). Що б не було (), і, можливо, саме так має намір автор коду.

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

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

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

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

Прямий склад вимагає пари дужок більше, ніж asключове слово. Так що навіть у тому випадку, коли ви на 100% впевнені, що таке тип, це зменшує зорову загрозу.

Однак погодився на виняток. Але принаймні для мене більшість застосувань asзводиться, щоб перевірити їх nullзгодом, що мені здається кращим, ніж ловити виняток.

99% часу, коли я використовую "як", - це коли я не впевнений, що таке фактичний тип об'єкта

var x = obj as T;
if(x != null){
 //x was type T!
}

і я не хочу вловлювати явні винятки з кастингу і не робити два рази, використовуючи "є":

//I don't like this
if(obj is T){
  var x = (T)obj; 
}

Це просто тому, що людям подобається те, як це виглядає, це дуже легко читається.

Дозвольте зіткнутися з цим: оператор лиття / перетворення на мовах, схожих на C, є досить жахливим, читабельним. Мені б хотілося, щоб краще, якщо C # прийняв синтаксис Javascript:

object o = 1;
int i = int(o);

Або визначте toоператора, еквівалент лиття as:

object o = 1;
int i = o to int;

Людям asтак подобається, бо це змушує їх відчувати себе захищеними від винятків ... Як гарантія на коробці. Хлопець покладає фантазійну гарантію на коробку, тому що хоче, щоб ви відчували все тепло і підсмажене всередині. Ви думаєте, що помістите цю маленьку коробку під подушку вночі, Фея гарантії може зійти і залишити чверть, я прав Тед?

Повернення до теми ... при використанні прямого амплуа є можливість недійсного винятку з амплуа. Тож люди застосовують asяк покришне рішення до всіх своїх потреб в кастингу, оскільки as(само по собі) ніколи не кине виняток. Але найцікавіше про це - у прикладі, який ви дали(x as T).SomeMethod(); ви торгуєте недійсним винятком лиття для нульового виключення. Що обтяжує справжню проблему, коли ви бачите виняток.

Я, як правило, не asнадто використовую . Я віддаю перевагу isтесту, тому що для мене він виглядає більш читабельним і має більше сенсу, ніж спробувати склад і перевірити наявність нуля.

Це повинно бути одним з моїх найкращих поглядів .

D&E Stroustrup та / або якесь повідомлення в блозі, якого я зараз не можу знайти, обговорює поняття toоператора, який би вирішив точку, зроблену https://stackoverflow.com/users/73070/johannes-rossel (тобто той самий синтаксис, що asі зDirectCast семантикою ).

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

Шкода, що "розумні" програмісти (часто автори книг (Juval Lowy IIRC)) обходять це шляхом зловживань asтаким чином (C ++ не пропонує as, мабуть, з цієї причини).

Навіть VB має більше узгодженості з однорідною синтаксис , який змушує вас вибрати TryCastабо DirectCastі зробити свій розум !

Я вважаю, що asключове слово можна вважати більш елегантною на вигляд версією dynamic_castC ++.

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

Одна з причин використання "як":

T t = obj as T;
 //some other thread changes obj to another type...
if (t != null) action(t); //still works

Замість (неправильний код):

if (obj is T)
{
     //bang, some other thread changes obj to another type...
     action((T)obj); //InvalidCastException
}