3

进一步阅读后编辑，修改问题更具体。

根据微软文档：

如果提供的表达式为非 null，则 is 表达式的计算结果为 true，并且提供的对象可以转换为提供的类型而不会引发异常。否则，表达式的计算结果为 false。

这是下面的问题。

var test = (Int32)(Int16)1; // Non-null and does not cause an exception.
var test2 = (Int16)1 is Int32; // Evaluates false.

该文档还指出：

请注意，is 运算符仅考虑引用转换、装箱转换和拆箱转换。不考虑其他转换，例如用户定义的转换。

因此，我假设它在上面不起作用，因为它是用户定义的转换。

我将如何检查某些东西是否可以转换为另一种类型，包括非参考/装箱/拆箱转换？

注意：我在为适用于所有类型的 CastToOrDefault 扩展编写单元测试时发现了这个问题，包括非引用类型（与 as 相比）。

基于 Mike Precup 的链接代码重构的答案

我清理了他的答案，因为我觉得它是用旧风格写的。另外，尽管速度较慢，但​​当每个列表只是另一个列表的子集时，拥有一个包含许多重复值的表感觉有点不稳定。所以，我改为使表递归。注意：如果值为 null，ThrowIfNull 只会抛出 ArgumentNullException。

private static readonly Dictionary<Type, IEnumerable<Type>> PrimitiveTypeTable = new Dictionary<Type, IEnumerable<Type>>
{
    { typeof(decimal), new[] { typeof(long), typeof(ulong) } },
    { typeof(double), new[] { typeof(float) } },
    { typeof(float), new[] { typeof(long), typeof(ulong) } },
    { typeof(ulong), new[] { typeof(uint) } },
    { typeof(long), new[] { typeof(int), typeof(uint) } },
    { typeof(uint), new[] { typeof(byte), typeof(ushort) } },
    { typeof(int), new[] { typeof(sbyte), typeof(short), typeof(ushort) } },
    { typeof(ushort), new[] { typeof(byte), typeof(char) } },
    { typeof(short), new[] { typeof(byte) } }
};

private static bool IsPrimitiveCastableTo(this Type fromType, Type toType)
{
    var keyTypes = new Queue<Type>(new[] { toType });
    while (keyTypes.Any())
    {
        var key = keyTypes.Dequeue();
        if (key == fromType) { return true; }
        if (PrimitiveTypeTable.ContainsKey(key)) { PrimitiveTypeTable[key].ToList().ForEach(keyTypes.Enqueue); }
    }
    return false;
}

/// <summary>
/// Determines if this type is castable to the toType.
/// This method does more than the is-operator and
/// allows for primitives and implicit/explicit conversions to be compared properly.
/// http://stackoverflow.com/a/18256885/294804
/// </summary>
/// <param name="fromType">The type to cast from.</param>
/// <param name="toType">The type to be casted to.</param>
/// <returns>True if fromType can be casted to toType. False otherwise.</returns>
/// <exception cref="ArgumentNullException">Thrown if either type is null.</exception>
public static bool IsCastableTo(this Type fromType, Type toType)
{
    // http://stackoverflow.com/a/10416231/294804
    return toType.ThrowIfNull().IsAssignableFrom(fromType.ThrowIfNull()) ||
        fromType.IsPrimitiveCastableTo(toType) ||
        fromType.GetMethods(BindingFlags.Public | BindingFlags.Static).Any(m =>
                m.ReturnType == toType && m.Name == "op_Implicit" || m.Name == "op_Explicit");
}
4

2 回答 2

3

同样来自您链接的 MSDN 页面：

请注意，is 运算符仅考虑引用转换、装箱转换和拆箱转换。不考虑其他转换，例如用户定义的转换。

由于为Int16andInt32类型定义的隐式转换不是引用转换、装箱转换或拆箱转换，因此is计算结果为 false。

如果您想知道为什么它不是引用转换，请注意隐式引用转换页面中的以下内容：

引用转换，无论是隐式的还是显式的，都不会改变被转换对象的引用身份。换句话说，虽然引用转换可能会改变引用的类型，但它永远不会改变被引用对象的类型或值。

由于正在更改类型，并且它不仅仅是转换为超类，因此不被视为引用转换。

编辑：要回答您编辑的第二个问题，请查看此页面。我将复制代码以供参考：

static class TypeExtensions { 
    static Dictionary<Type, List<Type>> dict = new Dictionary<Type, List<Type>>() {
        { typeof(decimal), new List<Type> { typeof(sbyte), typeof(byte), typeof(short), typeof(ushort), typeof(int), typeof(uint), typeof(long), typeof(ulong), typeof(char) } },
        { typeof(double), new List<Type> { typeof(sbyte), typeof(byte), typeof(short), typeof(ushort), typeof(int), typeof(uint), typeof(long), typeof(ulong), typeof(char), typeof(float) } },
        { typeof(float), new List<Type> { typeof(sbyte), typeof(byte), typeof(short), typeof(ushort), typeof(int), typeof(uint), typeof(long), typeof(ulong), typeof(char) } },
        { typeof(ulong), new List<Type> { typeof(byte), typeof(ushort), typeof(uint), typeof(char) } },
        { typeof(long), new List<Type> { typeof(sbyte), typeof(byte), typeof(short), typeof(ushort), typeof(int), typeof(uint), typeof(char) } },
        { typeof(uint), new List<Type> { typeof(byte), typeof(ushort), typeof(char) } },
        { typeof(int), new List<Type> { typeof(sbyte), typeof(byte), typeof(short), typeof(ushort), typeof(char) } },
        { typeof(ushort), new List<Type> { typeof(byte), typeof(char) } },
        { typeof(short), new List<Type> { typeof(byte) } }
    };
    public static bool IsCastableTo(this Type from, Type to) { 
        if (to.IsAssignableFrom(from)) { 
            return true; 
        }
        if (dict.ContainsKey(to) && dict[to].Contains(from)) {
            return true;
        }
        bool castable = from.GetMethods(BindingFlags.Public | BindingFlags.Static) 
                        .Any( 
                            m => m.ReturnType == to &&  
                            m.Name == "op_Implicit" ||  
                            m.Name == "op_Explicit" 
                        ); 
        return castable; 
    } 
}

该代码使用反射来检查是否存在任何隐式或显式强制转换。但是，反射方法不适用于基元，因此必须手动进行检查，因此Dictionary可能会进行基元转换。

于 2013-08-15T16:12:13.207 回答
0

根据 MSDN 还 -

如果已知表达式始终为真或始终为假，则 is 关键字会导致编译时警告，但通常会在运行时评估类型兼容性。

在警告中很容易看出——

警告

@Mike已经指出为什么它评估为false.

于 2013-08-15T16:15:39.767 回答