这不是对问题的回答，而是对问题代码示例的注释:

通常你不需要强制转换一个对象，例如IMyInterface到MyClass。接口的伟大之处在于，如果你把一个对象作为实现接口的输入，那么你就不需要关心你得到的是什么类型的对象。

如果你将IMyInterface转换为MyClass，那么你已经假设你得到了一个MyClass类型的对象，使用IMyInterface是没有意义的，因为如果你用其他实现IMyInterface的类来填充你的代码，它会破坏你的代码……

现在，我的建议是:如果你的接口设计得很好，你可以避免大量的类型转换。

这不是对问题的回答，而是对问题代码示例的注释:

通常你不需要强制转换一个对象，例如IMyInterface到MyClass。接口的伟大之处在于，如果你把一个对象作为实现接口的输入，那么你就不需要关心你得到的是什么类型的对象。

如果你将IMyInterface转换为MyClass，那么你已经假设你得到了一个MyClass类型的对象，使用IMyInterface是没有意义的，因为如果你用其他实现IMyInterface的类来填充你的代码，它会破坏你的代码……

现在，我的建议是:如果你的接口设计得很好，你可以避免大量的类型转换。

这取决于，你想检查null后使用"as"或你更喜欢你的应用程序抛出一个异常?

我的经验法则是，如果我总是期望变量在我想要的时候是我期望的类型，我就使用强制转换。如果变量可能不会强制转换为我想要的，并且我准备从使用as处理空值，那么我将使用as。

这是另一个答案，带有一些IL比较。考虑这个类:

public class MyClass
{
    public static void Main()
    {
        // Call the 2 methods
    }

    public void DirectCast(Object obj)
    {
        if ( obj is MyClass)
        { 
            MyClass myclass = (MyClass) obj; 
            Console.WriteLine(obj);
        } 
    } 


    public void UsesAs(object obj) 
    { 
        MyClass myclass = obj as MyClass; 
        if (myclass != null) 
        { 
            Console.WriteLine(obj);
        } 
    }
}

现在看看每种方法产生的IL。即使操作码对您没有任何意义，您也可以看到一个主要的区别-在DirectCast方法中，isinst被调用后是castclass。所以基本上是两次调用而不是一次。

.method public hidebysig instance void  DirectCast(object obj) cil managed
{
  // Code size       22 (0x16)
  .maxstack  8
  IL_0000:  ldarg.1
  IL_0001:  isinst     MyClass
  IL_0006:  brfalse.s  IL_0015
  IL_0008:  ldarg.1
  IL_0009:  castclass  MyClass
  IL_000e:  pop
  IL_000f:  ldarg.1
  IL_0010:  call       void [mscorlib]System.Console::WriteLine(object)
  IL_0015:  ret
} // end of method MyClass::DirectCast

.method public hidebysig instance void  UsesAs(object obj) cil managed
{
  // Code size       17 (0x11)
  .maxstack  1
  .locals init (class MyClass V_0)
  IL_0000:  ldarg.1
  IL_0001:  isinst     MyClass
  IL_0006:  stloc.0
  IL_0007:  ldloc.0
  IL_0008:  brfalse.s  IL_0010
  IL_000a:  ldarg.1
  IL_000b:  call       void [mscorlib]System.Console::WriteLine(object)
  IL_0010:  ret
} // end of method MyClass::UsesAs

isinst关键字与castclass的对比

这篇博文对这两种方法进行了比较。他的总结是:

在直接比较中，isinst比castclass快(尽管只有一点点) 当必须执行检查以确保转换成功时，isinst明显比castclass快 不应该使用isinst和castclass的组合，因为这比最快的“安全”转换慢得多(慢12%以上)

我个人总是使用a，因为它易于阅读，并且是。net开发团队(或者Jeffrey Richter)推荐的。

as操作符只能用于引用类型，不能重载，如果操作失败，它将返回null。它永远不会抛出异常。

强制转换可以用于任何兼容的类型，它可以重载，如果操作失败，它将抛出异常。

使用哪一种取决于具体情况。首先，这是一个是否要对失败的转换抛出异常的问题。

除了这里已经暴露的所有内容，我刚刚发现了一个我认为值得注意的实际差异，在显式选角之间

var x = (T) ...

相对于使用as操作符。

下面是例子:

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine(GenericCaster<string>(12345));
        Console.WriteLine(GenericCaster<object>(new { a = 100, b = "string" }) ?? "null");
        Console.WriteLine(GenericCaster<double>(20.4));

        //prints:
        //12345
        //null
        //20.4

        Console.WriteLine(GenericCaster2<string>(12345));
        Console.WriteLine(GenericCaster2<object>(new { a = 100, b = "string" }) ?? "null");

        //will not compile -> 20.4 does not comply due to the type constraint "T : class"
        //Console.WriteLine(GenericCaster2<double>(20.4));
    }

    static T GenericCaster<T>(object value, T defaultValue = default(T))
    {
        T castedValue;
        try
        {
            castedValue = (T) Convert.ChangeType(value, typeof(T));
        }
        catch (Exception)
        {
            castedValue = defaultValue;
        }

        return castedValue;
    }

    static T GenericCaster2<T>(object value, T defaultValue = default(T)) where T : class
    {
        T castedValue;
        try
        {
            castedValue = Convert.ChangeType(value, typeof(T)) as T;
        }
        catch (Exception)
        {
            castedValue = defaultValue;
        }

        return castedValue;
    }
}

底线:GenericCaster2不能用于结构类型。GenericCaster意志。