直接铸造与“作为”操作员？

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

这两者是等效的：

使用“as”：

string s = o as string;

使用“is”：

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

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

只是为了补充一个重要的事实：

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

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

在这些情况下，您必须使用铸造。

string s = (string)o; // 1

如果不是 .否则，即使 是 ，也应分配给 。ostringosonull

string s = o as string; // 2

分配给 if is not a 或 if is 。因此，不能将其与值类型一起使用（在这种情况下，运算符永远无法返回）。否则，将分配给 。nullsostringonullnullos

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

如果为 ，则会导致 NullReferenceException。将返回的任何内容分配给 ，无论类型是什么。onullo.ToString()so

---

对于大多数转换，请使用 1 - 它简单明了。我几乎从不使用 2，因为如果某些东西的类型不正确，我通常会期望发生异常。我只看到需要这种 return-null 类型的功能，以及使用错误代码（例如返回 null = error，而不是使用异常）的糟糕库。

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

这实际上取决于你是否知道是否是一个字符串，以及你想用它做什么。如果你的评论意味着这真的是一个字符串，我更喜欢直接投射 - 它不太可能失败。oo(string)o

使用直接强制转换的最大优点是，当它失败时，你会得到一个 InvalidCastException，它告诉你几乎出了什么问题。

使用运算符，如果不是字符串，则设置为 ，如果您不确定并想测试，这将很方便：asosnulls

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

但是，如果不执行该测试，则稍后将使用并引发 NullReferenceException。这些往往更常见，一旦它们在野外发生就更难追踪，因为几乎每一行都取消了对变量的引用，并可能抛出一个变量。另一方面，如果你试图强制转换为值类型（任何基元，或结构，如 DateTime），你必须使用直接强制转换 - 这将不起作用。sas

在转换为字符串的特殊情况下，每个对象都有一个 ，因此，如果第三个方法不是 null，并且您认为该方法可以执行您想要的操作，则该方法可能没问题。ToStringoToString

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

“o as string” 将导致 s 成为 null 引用，而不是抛出异常。

“o.ToString（）”本身不是任何类型的强制转换，它是由对象实现的方法，因此以某种方式，由 .net 中的每个类实现，这些类对调用它的类的实例“执行某些操作”并返回一个字符串。

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

1. string s = (string)o;当某事绝对应该是另一件事时使用。
2. string s = o as string;当某物可能是另一个时使用 东西。
3. string s = o.ToString();当你不在乎什么时使用 是的，但你只想使用 可用的字符串表示形式。

2 可用于强制转换为派生类型。

假设 a 是动物：

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

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

将以最少的石膏喂食。

如果您已经知道它可以强制转换为哪种类型，请使用 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（） 获取任何对象的人类可读字符串表示形式，即使它不能转换为字符串。

string s = o as string; // 2

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

as 关键字在使用 FindControl 方法时 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;
}

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

根据本页进行的实验：http://www.dotnetguru2.org/sebastienros/index.php/2006/02/24/cast_vs_as

（此页面有时会出现一些“非法引荐来源”错误，因此如果出现，请刷新）

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

我个人认为“as”也更具可读性。

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

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

String s = String.Concat(o);

所有给出的答案都很好，如果我可以补充一些东西： 要直接使用字符串的方法和属性（例如 ToLower），您不能编写：

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

你只能写：

((string)o).ToLower();

但你可以改写：

(o as string).ToLower();

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

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

obj.GetType().IsInstanceOfType(otherObj)

似乎他们俩在概念上是不同的。

直接铸造

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

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

感觉就像对象将被转换为其他东西。

AS 运算符

类型有直接关系。如：

• 引用类型：IS-A 关系 对象始终相同，只是引用发生了变化。
• 值类型：复制装箱和可为 null 的类型。

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

样品和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
    }

如果在应用的逻辑上下文中是唯一有效的类型，则使用直接强制转换。通过这种方法，您将获得并实现快速失败的原则。您的逻辑将受到保护，不会进一步传递无效类型或获取 NullReferenceException（如果使用运算符）。string s = (string) o;stringInvalidCastExceptionas

如果逻辑需要几种不同类型的强制转换，请选中它或使用运算符。string s = o as string;nullis

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

我想提请注意 as 运算符的以下细节：

https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/as

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