我有以下代码：
private T CreateInstance<T>(object obj) // where T : ISomeInterface, class
{
...
if (!typeof(T).IsAssignableFrom(obj.GetType())) { throw ..; }
return (T)obj;
}
T result = obj as T;
if (result == null) { throw ..; }
return result;
如果 (!(bar is T)) { throw ..; } 这段代码的意思是如果 bar 不是类型 T，则抛出异常。
或者，如果您不需要自己的异常消息，最简单的方法就是执行以下操作：
return (T)obj;
另一种变体：
private T CreateInstance<T>(object obj) where T : ISomeInterface // as OP mentioned above
{
...
T result = obj as T;
if (result == null)
{ throw ..; }
else
return result;
}
当T是引用类型或可空类型时，您可以在那里使用as运算符代码替代原始代码。
as是C#中推荐的转换方式（请参见Bill Wagner的Effective C#第3项）。
来自system.type.isassignablefrom：
[返回]true，如果c和当前Type表示相同的类型，或者当前Type在c的继承层次结构中，或者当前Type是c实现的接口，或者c是泛型类型参数并且当前Type表示c的约束之一。如果没有这些条件为真或c为空，则返回false。
从C#规范的7.10.11节中：
在E as T形式的操作中，E必须是一个表达式，T必须是引用类型、已知为引用类型的类型参数或可空类型
因此，您可以看到它们进行了类似的检查。
if (obj is T)
{
return (T)obj;
}
else
throw new ...
编辑 通过减少括号的数量，我最初意思是指反向检查：即
if (obj is T)
if (!(obj is T))
if (obj is T)
{
return (T)obj;
}
throw new ...
或者
if (obj is T)
{
return (T)obj;
}
else
{
throw new ...
}
throw 语句后插入另一行代码似乎是有点合理的。 - Joel Muellerwhere T : class 允许您使用 as T 语句。private T CreateInstance<T>(object obj) where T : class
{
if (!(obj is T)) { throw new ArgumentException("..."); }
return obj as T;
}
或者
private T CreateInstance<T>(object obj)
{
if (!(obj is T)) { throw new ArgumentException("..."); }
return (T)obj;
}
is或as之外，一切都正确。双重操作没有意义。 - abatishchevT result = obj as T; if (result != null ) { } else { }。就像@Orsol的答案一样。或者你的答案——如果没有: class约束。 - abatishchev您可能正在寻找使用语法expression is type的is关键字。
文档将其描述为执行所需检查的内容：
如果满足以下两个条件，则is表达式的结果为true：
• expression不为null。
• expression可以强制转换为type。也就是说，形如(type)(expression)的强制转换表达式将会成功完成而不会抛出异常。
编辑然而，如果您只是想在尝试转换之前确定是否可以转换，那么as关键字可能是最好的解决方案，正如您在帖子中所描述的那样。
以下代码将执行相同的功能...
try
{
T result = (T)obj;
return result;
}
catch (InvalidCastException ex)
{
// throw your own exception or deal with it in some other way.
}
你喜欢哪种方法就用哪种方法...
此场景使用了IsAssignableFrom：
foreach (PropertyInfo property in GetType().GetProperties())
{
if (typeof(SubPresenter).IsAssignableFrom(property.PropertyType))
{//Do Sth.}
}
这是给喜欢玩数字游戏的开发者们准备的（谁不喜欢呢！）。
下面是一个 IsAssignableFrom 与 As 的性能比较测试。当然，这只有在你有实例的情况下才会生效。
测试结果（一百万次尝试）：
IsAssignableFrom：经过146毫秒
AsOperator：经过7毫秒
[TestMethod]
public void IsAssignableFromVsAsPerformanceTest()
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
int attempts = 1000000;
string value = "This is a test";
for (int attempt = 0; attempt < attempts; attempt++) {
bool isConvertible = typeof(IConvertible).IsAssignableFrom(value.GetType());
}
stopwatch.Stop();
Console.WriteLine("IsAssignableFrom: {0} ms elapsed", stopwatch.ElapsedMilliseconds);
stopwatch.Restart();
for (int attempt = 0; attempt < attempts; attempt++) {
bool isConvertible = value as string != null;
}
stopwatch.Stop();
Console.WriteLine("AsOperator: {0} ms elapsed", stopwatch.ElapsedMilliseconds);
}
这可能是为了处理转换构造函数允许操作的情况，但显然IsAssignableFrom也无法处理。我没有看到任何可以处理这种情况的东西。所以我不知道如何检查这种情况：
class Program
{
static void Main(string[] args)
{
B bValue = new B(123);
Console.WriteLine(typeof(A).IsAssignableFrom(bValue.GetType()));
//Console.WriteLine(bValue is A);
//Console.WriteLine(bValue as A == null);
A aValue = bValue;
Console.WriteLine(aValue.ToString());
}
}
class A
{
string value;
public A(string value)
{
this.value = value;
}
public override string ToString()
{
return value;
}
}
class B
{
int value;
public B(int value)
{
this.value = value;
}
public static implicit operator A(B value)
{
return new A(value.value.ToString());
}
}
(T)obj将抛出异常。 - Anton Tykhyy