直接铸造与“ as”运算符？

考虑以下代码：

void Handler(object o, EventArgs e)
{
   // I swear o is a string
   string s = (string)o; // 1
   //-OR-
   string s = o as string; // 2
   // -OR-
   string s = o.ToString(); // 3
}

三种类型的转换之间有什么区别（好吧，第三个类型不是转换，但您有意图）。应该首选哪一个？

string s = (string)o; // 1

如果不是，则抛出InvalidCastException。否则，将分配给，即使是。ostringosonull

string s = o as string; // 2

分配null给sif o不是a string或if ois null。因此，您不能将其与值类型一起使用（null在这种情况下，运算符永远不会返回）。否则，分配o给s。

string s = o.ToString(); // 3

导致一个NullReferenceException异常，如果o是null。o.ToString()将返回值赋给s，无论是哪种类型o。

大多数转换使用1-简单明了。我倾向于几乎从不使用2，因为如果某些类型不正确，我通常希望发生异常。我只看到这种返回null类型的功能需要使用错误代码（例如，返回null =错误，而不是使用异常）的错误设计的库。

3不是强制转换，而只是方法调用。在需要非字符串对象的字符串表示形式时使用它。

1. string s = (string)o;使用时要的东西 肯定是另一件事。
2. string s = o as string;当某事可能是另一回事时使用。
3. string s = o.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。这些往往是比较常见和很多难以追查，一旦他们在野外发生了，因为几乎每行取消引用变量，可能会抛出一个。另一方面，如果要强制转换为值类型（任何原始类型或诸如DateTime之类的结构），则必须使用直接强制转换- as无法使用。

在转换为字符串的特殊情况下，每个对象都有一个ToString，因此您的第三个方法如果o不为null 可能没问题，并且您认为该ToString方法可以完成您想要的事情。

如果您已经知道它可以转换为哪种类型，请使用C样式的转换：

var o = (string) iKnowThisIsAString; 

请注意，只有使用C样式强制转换，您才能执行显式类型强制。

如果您不知道它是否是所需的类型，并且打算使用它，请使用as关键字：

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

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

注意，as不会调用任何类型转换运算符。仅当对象不为null且本身是指定类型的对象时，它才会为非null。

使用ToString（）获取任何对象的人类可读的字符串表示形式，即使它不能转换为字符串也是如此。

当您使用FindControl方法时，as关键字在asp.net中很好。

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

这意味着您可以对类型化的变量进行操作，而不必object像直接强制转换那样将其强制转换为：

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

这不是一件大事，但它节省了代码行和变量赋值，而且可读性强

“ as”基于“ is”，这是一个关键字，它在运行时检查对象是否在政治上兼容（基本上可以进行强制转换），如果检查失败，则返回null。

这两个等效：

使用'as'：

string s = o as string;

使用“是”：

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

相反，c样式强制转换也是在运行时进行的，但是如果无法强制转换，则会引发异常。

仅添加一个重要事实：

“ as”关键字仅适用于引用类型。您不能：

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

在这种情况下，您必须使用投射。

2对于强制转换为派生类型很有用。

假设a是动物：

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

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

将得到一个用最少的铸件送入。

根据在此页面上运行的实验：http : //www.dotnetguru2.org/sebastienros/index.php/2006/02/24/cast_vs_as

（此页面有时会显示一些“非法引荐来源网址”错误，因此请刷新一下）

结论是，“ as”运算符通常比强制转换更快。有时快很多倍，有时快一点。

我个人认为“ as”也更易读。

因此，由于它既更快又更“安全”（不会抛出异常），并且可能更易于阅读，所以我建议始终使用“ as”。

“（string）o”将导致InvalidCastException，因为没有直接强制转换。

“ o as string”将导致s为空引用，而不是引发异常。

“ o.ToString（）”本身并不是一种强制转换，它是一种由对象实现的方法，因此由.net中的每个类以某种方式对.NET的实例“做某事”实现调用它的类并返回一个字符串。

不要忘记，要转换为字符串，还有Convert.ToString（someType instanceOfThatType），其中someType是一组类型之一，本质上是框架的基本类型。

如果我可能要添加一些内容，那么所有给出的答案都是好的：要直接使用字符串的方法和属性（例如ToLower），您不能编写：

(string)o.ToLower(); // won't compile

您只能写：

((string)o).ToLower();

但您可以改为：

(o as string).ToLower();

该as选项更具可读性（至少在我看来）。

string s = o as string; // 2

首选，因为它避免了双重铸造的性能损失。

看来他们两个在概念上是不同的。

直接铸造

类型不必严格相关。它有各种口味。

• 自定义隐式/显式强制转换：通常创建一个新对象。
• 值类型隐式：复制而不会丢失信息。
• 值类型显式：复制和信息可能会丢失。
• IS-A关系：更改引用类型，否则引发异常。
• 相同类型： “铸造是多余的”。

感觉该对象将被转换成其他东西。

AS运营商

类型有直接关系。如：

• 引用类型：IS-A关系对象总是相同的，只是引用发生了变化。
• 值类型：复制拳击和可为空的类型。

感觉就像您将以不同的方式处理对象。

样品和IL

    class TypeA
    {
        public int value;
    }

    class TypeB
    {
        public int number;

        public static explicit operator TypeB(TypeA v)
        {
            return new TypeB() { number = v.value };
        }
    }

    class TypeC : TypeB { }
    interface IFoo { }
    class TypeD : TypeA, IFoo { }

    void Run()
    {
        TypeA customTypeA = new TypeD() { value = 10 };
        long longValue = long.MaxValue;
        int intValue = int.MaxValue;

        // Casting 
        TypeB typeB = (TypeB)customTypeA; // custom explicit casting -- IL:  call class ConsoleApp1.Program/TypeB ConsoleApp1.Program/TypeB::op_Explicit(class ConsoleApp1.Program/TypeA)
        IFoo foo = (IFoo)customTypeA; // is-a reference -- IL: castclass  ConsoleApp1.Program/IFoo

        int loseValue = (int)longValue; // explicit -- IL: conv.i4
        long dontLose = intValue; // implict -- IL: conv.i8

        // AS 
        int? wraps = intValue as int?; // nullable wrapper -- IL:  call instance void valuetype [System.Runtime]System.Nullable`1<int32>::.ctor(!0)
        object o1 = intValue as object; // box -- IL: box [System.Runtime]System.Int32
        TypeD d1 = customTypeA as TypeD; // reference conversion -- IL: isinst ConsoleApp1.Program/TypeD
        IFoo f1 = customTypeA as IFoo; // reference conversion -- IL: isinst ConsoleApp1.Program/IFoo

        //TypeC d = customTypeA as TypeC; // wouldn't compile
    }

我想引起注意as运算符的以下细节：

https://docs.microsoft.com/zh-cn/dotnet/csharp/language-reference/keywords/as

请注意，as运算符仅执行参考转换，可为空的转换和装箱转换。as运算符不能执行其他转换，例如用户定义的转换，而应使用强制转换表达式来执行。

当试图获取任何可能为空的任何类型的字符串表示形式时，我喜欢下面的代码行。它紧凑，可以调用ToString（），并且可以正确处理null。如果o为null，则s将包含String.Empty。

String s = String.Concat(o);

由于没有人提到它，因此关键字最接近Java的instanceOf是：

obj.GetType().IsInstanceOfType(otherObj)

string s = (string) o;如果在您应用的逻辑上下文中string是唯一有效的类型，请使用直接强制转换。使用这种方法，您将获得InvalidCastException并实现Fail-fast的原理。您的逻辑将受到保护，以免进一步传递无效类型，如果使用了as运算符，则将获得NullReferenceException 。

如果逻辑期望几种不同类型的类型，string s = o as string;并进行检查null或使用is运算符。

C＃7.0中出现了新的很酷的功能，以简化转换，并且检查是否为模式匹配：

if(o is string s)
{
  // Use string variable s
}

or

switch (o)
{
  case int i:
     // Use int variable i
     break;
  case string s:
     // Use string variable s
     break;
 }

C＃支持以下两种类型的类型转换（广播）形式：

|

（简历

•在给定表达式中将v的静态类型转换为c

•仅当v的动态类型为c或c的子类型时才可能

•如果不是，则抛出InvalidCastException

|

v作为C

•（c）v的非致命变体

•因此，在给定表达式中将v的静态类型转换为c

•如果v的动态类型不是c或c的子类型，则返回null