Question

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

如果提供的表达式是，则表达式的计算结果为true 非null，并且可以将提供的对象强制转换为提供的类型不会引发异常抛出。否则，表达式评估为假。

以下是问题。

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

Answer 1

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

请注意，is运算符仅考虑引用转换，装箱转换和取消装箱转换。其他转换（例如用户定义的转化）不予考虑。

由于为Int16和Int32类型定义的隐式强制转换不是引用转换，装箱转换或取消装箱转换，is的计算结果为false。

如果您想知道为什么它不是参考转换，请在implicit reference conversions页面上注明以下内容：

隐式或显式的引用转换永远不会更改要转换的对象的引用标识。换句话说，虽然引用转换可能会更改引用的类型，但它永远不会更改所引用对象的类型或值。

由于类型正在被更改，并且它不仅仅是对超类的强制转换，因此它不被视为参考转换。

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

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

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

Answer 2

根据MSDN也 -

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

在警告中很容易看出 -

Warning

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

C＃ - 是运算符 - 检查所有可用转换的可投射性

我如何检查某些内容是否可以转换为其他类型，包括非引用/装箱/拆箱转换？

根据Mike Precup的链接代码重构答案

2 个答案: