Прямое приведение против оператора "как"?

string s = o as string; // 2

предпочтен, поскольку это избегает потери производительности двойного кастинга.

Если Вы уже знаете то, что вводит его, может бросить к, использовать бросок C-стиля:

var o = (string) iKnowThisIsAString; 

Примечание, которое только с броском C-стиля может Вы выполнять явное приведение типа.

, Если Вы не знаете, является ли это желаемым типом и Вы собираетесь использовать его, если это, используйте в качестве ключевое слово:

var s = o as string;
if (s != null) return s.Replace("_","-");

//or for early return:
if (s==null) return;

Примечание, что как не назовет операторов преобразования типов. Это только будет непустым, если объект не будет пустым и исходно указанного типа.

Использование ToString () для получения человекочитаемого строкового представления любого объекта, даже если это не может бросить для строкового представления.

Это действительно зависит от того, знаете ли Вы, ли o строка и что Вы хотите сделать с ним. Если Ваш комментарий означает, что o действительно действительно строка, я предпочел бы прямое (string)o бросок - это вряд ли перестанет работать.

самое большое преимущество использования прямого броска состоит в том, что, когда это перестало работать, Вы добираетесь InvalidCastException, который говорит Вам в значительной степени, что пошло не так, как надо.

С as оператор, если o не строка, s, установлен на null, который удобен, если Вы не уверены и хотите протестировать s:

string s = o as string;
if ( s == null )
{
    // well that's not good!
    gotoPlanB();
}

Однако, если Вы не выполняете тот тест, Вы будете использовать s позже и бросать NullReferenceException. Они имеют тенденцию быть более распространенными и партия тяжелее для разыскивания, как только они происходят в дикой природе, поскольку почти каждая строка разыменовывает переменную и может бросить ту. С другой стороны, при попытке бросить к типу значения (любой примитив, или структуры такой как [1 116] DateTime), необходимо использовать прямой бросок - эти as, не будет работать.

2 полезно для кастинга к производному типу.

предположим Животное:

b = a as Badger;
c = a as Cow;

if (b != null)
   b.EatSnails();
else if (c != null)
   c.EatGrass();

станет питаемым минимумом бросков.

'как' на основе '', который является ключевым словом, которое проверяет во времени выполнения, если объект polimorphycally совместим (в основном, если бросок может быть сделан), и пустой указатель возвратов, если проверка перестала работать.

Эти два эквивалентны:

Используя 'как':

string s = o as string;

Используя:

if(o is string) 
    s = o;
else
    s = null;

Наоборот, бросок c-стиля сделан также во времени выполнения, но выдает исключение, если бросок не может быть сделан.

Только для добавления важного факта:

, 'поскольку' ключевое слово только работает со ссылочными типами. Вы не можете сделать:

// I swear i is an int
int number = i as int;

В тех случаях необходимо использовать кастинг.

Поскольку ключевое слово хорошо в asp.net при использовании метода FindControl.

Hyperlink link = this.FindControl("linkid") as Hyperlink;
if (link != null)
{
     ...
}

Это означает, что можно воздействовать на переменную определенного типа, скорее тогда имеющую необходимость тогда бросать его от object как Вы, был бы с прямым броском:

object linkObj = this.FindControl("linkid");
if (link != null)
{
     Hyperlink link = (Hyperlink)linkObj;
}

Это не огромная вещь, но это сохраняет строки кода и переменного присвоения, плюс он - больше читаемое

1. string s = (string)o; Использование, когда что-то должно определенно быть другой вещью.
2. string s = o as string; Использование, когда что-то могло бы быть другая вещь.
3. string s = o.ToString(); Использование, когда Вы не заботитесь о том, что это всего лишь, Вы просто хотите использовать доступное строковое представление.

" (строка) o" приведет к InvalidCastException, поскольку нет никакого прямого броска.

"o, поскольку строка" приведет к s быть нулевой ссылкой, а не выданным исключением.

"o. ToString ()" не является составом исполнителей никакого серовато-синего вида, это - метод, это реализовано объектом, и таким образом так или иначе, каждым классом в .net, который "делает что-то" с экземпляром класса, к этому обращаются и возвращает строку.

не забывают, что для преобразования в строку, существует, также Преобразовывают. ToString (someType instanceOfThatType), где someType является одним из ряда типов, по существу базовые типы платформ.

Согласно экспериментам, проведенным на этой странице: http://www.dotnetguru2.org/sebastienros/index.php/2006/02/24/cast_vs_as

(эта страница иногда появляются ошибки "недопустимого реферера", поэтому просто обновите, если они есть)

Вывод: оператор "as" обычно быстрее, чем приведение. Иногда во много раз быстрее, иногда чуть быстрее.

Я лично воспринимаю слово «как» также более читабельно.

Так как он и быстрее, и «безопаснее» (не вызывает исключения) и, возможно, его легче читать, я рекомендую все время использовать «как».