C# 如何确定Int32实际上可从Int16赋值

我有几个PropertyInfo对象，它们表示目标对象的属性。以及一组类似的PropertyInfo对象，它们表示源对象的属性

如果名称和类型匹配，“我的代码”会将属性值从源分配到目标。但有些类型是可分配的，但并不完全匹配。其中一种情况是Int16类型的源属性，但在目标端，相同名称的属性是Int32类型。我用这个

换句话说，下面返回的是false，而我真的希望它给我一个“true”

typeof(Int32).IsAssignableFrom(typeof(Int16))

我读过其他一些帖子，这些帖子暗示我，IsAssignableFrom不是我所需要的。在我开始编写一个长的switch case代码之前，我正在检查是否有更简单的方法。

Int32 int和Int16 short是结构。结构不允许继承。因此，IsAssignableFrom不起作用，因为short不从int继承。但将short指定给int不会有问题。

Int32 int和Int16 short是结构。结构不允许继承。因此，IsAssignableFrom不起作用，因为short不从int继承。但将short指定给int是没有问题的。

从Int16到Int32的隐式转换是C语言的功能，而不是CLR或.NET的功能，因此从技术上讲，它们在运行时是不可分配的，尽管公平地说，IsAssignableFrom将告诉您，对象可以从任何值类型进行赋值，即使您在技术上需要进行装箱转换

除了像这样大声鸣叫开关外，我知道没有现成的方法可以做到这一点：

public static bool HasImplicitConversion( Type source, Type destination )
{
    var sourceCode = Type.GetTypeCode( source );
    var destinationCode = Type.GetTypeCode( destination );
    switch( sourceCode )
    {
        case TypeCode.SByte:
            switch( destinationCode )
            {
                case TypeCode.Int16:
                case TypeCode.Int32:
                case TypeCode.Int64:
                case TypeCode.Single:
                case TypeCode.Double:
                case TypeCode.Decimal:
                    return true;
            }
            return false;
        case TypeCode.Byte:
            switch( destinationCode )
            {
                case TypeCode.Int16:
                case TypeCode.UInt16:
                case TypeCode.Int32:
                case TypeCode.UInt32:
                case TypeCode.Int64:
                case TypeCode.UInt64:
                case TypeCode.Single:
                case TypeCode.Double:
                case TypeCode.Decimal:
                    return true;
            }
            return false;
        case TypeCode.Int16:
            switch( destinationCode )
            {
                case TypeCode.Int32:
                case TypeCode.Int64:
                case TypeCode.Single:
                case TypeCode.Double:
                case TypeCode.Decimal:
                    return true;
            }
            return false;
        case TypeCode.UInt16:
            switch( destinationCode )
            {
                case TypeCode.Int32:
                case TypeCode.UInt32:
                case TypeCode.Int64:
                case TypeCode.UInt64:
                case TypeCode.Single:
                case TypeCode.Double:
                case TypeCode.Decimal:
                    return true;
            }
            return false;
        case TypeCode.Int32:
            switch( destinationCode )
            {
                case TypeCode.Int64:
                case TypeCode.Single:
                case TypeCode.Double:
                case TypeCode.Decimal:
                    return true;
            }
            return false;
        case TypeCode.UInt32:
            switch( destinationCode )
            {
                case TypeCode.UInt32:
                case TypeCode.UInt64:
                case TypeCode.Single:
                case TypeCode.Double:
                case TypeCode.Decimal:
                    return true;
            }
            return false;
        case TypeCode.Int64:
        case TypeCode.UInt64:
            switch( destinationCode )
            {
                case TypeCode.Single:
                case TypeCode.Double:
                case TypeCode.Decimal:
                    return true;
            }
            return false;
        case TypeCode.Char:
            switch( destinationCode )
            {
                case TypeCode.UInt16:
                case TypeCode.Int32:
                case TypeCode.UInt32:
                case TypeCode.Int64:
                case TypeCode.UInt64:
                case TypeCode.Single:
                case TypeCode.Double:
                case TypeCode.Decimal:
                    return true;
            }
            return false;
        case TypeCode.Single:
            return ( destinationCode == TypeCode.Double );
    }
    return false;
}

从Int16到Int32的隐式转换是一种C语言功能，而不是CLR或.NET的功能，因此它们在技术上是不可在运行时分配的，尽管公平地说，IsAssignableFrom会告诉您对象可以从任何值类型分配，即使您在技术上需要装箱转换来完成

除了像这样大声鸣叫开关外，我知道没有现成的方法可以做到这一点：

public static bool HasImplicitConversion( Type source, Type destination )
{
    var sourceCode = Type.GetTypeCode( source );
    var destinationCode = Type.GetTypeCode( destination );
    switch( sourceCode )
    {
        case TypeCode.SByte:
            switch( destinationCode )
            {
                case TypeCode.Int16:
                case TypeCode.Int32:
                case TypeCode.Int64:
                case TypeCode.Single:
                case TypeCode.Double:
                case TypeCode.Decimal:
                    return true;
            }
            return false;
        case TypeCode.Byte:
            switch( destinationCode )
            {
                case TypeCode.Int16:
                case TypeCode.UInt16:
                case TypeCode.Int32:
                case TypeCode.UInt32:
                case TypeCode.Int64:
                case TypeCode.UInt64:
                case TypeCode.Single:
                case TypeCode.Double:
                case TypeCode.Decimal:
                    return true;
            }
            return false;
        case TypeCode.Int16:
            switch( destinationCode )
            {
                case TypeCode.Int32:
                case TypeCode.Int64:
                case TypeCode.Single:
                case TypeCode.Double:
                case TypeCode.Decimal:
                    return true;
            }
            return false;
        case TypeCode.UInt16:
            switch( destinationCode )
            {
                case TypeCode.Int32:
                case TypeCode.UInt32:
                case TypeCode.Int64:
                case TypeCode.UInt64:
                case TypeCode.Single:
                case TypeCode.Double:
                case TypeCode.Decimal:
                    return true;
            }
            return false;
        case TypeCode.Int32:
            switch( destinationCode )
            {
                case TypeCode.Int64:
                case TypeCode.Single:
                case TypeCode.Double:
                case TypeCode.Decimal:
                    return true;
            }
            return false;
        case TypeCode.UInt32:
            switch( destinationCode )
            {
                case TypeCode.UInt32:
                case TypeCode.UInt64:
                case TypeCode.Single:
                case TypeCode.Double:
                case TypeCode.Decimal:
                    return true;
            }
            return false;
        case TypeCode.Int64:
        case TypeCode.UInt64:
            switch( destinationCode )
            {
                case TypeCode.Single:
                case TypeCode.Double:
                case TypeCode.Decimal:
                    return true;
            }
            return false;
        case TypeCode.Char:
            switch( destinationCode )
            {
                case TypeCode.UInt16:
                case TypeCode.Int32:
                case TypeCode.UInt32:
                case TypeCode.Int64:
                case TypeCode.UInt64:
                case TypeCode.Single:
                case TypeCode.Double:
                case TypeCode.Decimal:
                    return true;
            }
            return false;
        case TypeCode.Single:
            return ( destinationCode == TypeCode.Double );
    }
    return false;
}

---

我的代码正在动态测试可分配性并执行分配。我需要找到一种方法，从Int16分配到Int32，这不是一个真正的答案。这只是关于这个问题的更多细节。试着使用Convert并检查fot IConvertable接口。我想这是这个接口的名称。我的代码正在动态测试可分配性并执行分配。我需要找到一种方法，从Int16分配到Int32，这不是一个真正的答案。这只是关于这个问题的更多细节。试着使用Convert并检查fot IConvertable接口。我想这是这个接口的名称。你打算处理多少情况？如果有帮助的话。@Guvante不会太多。Int32、Int16和可能是整数到整数的两倍。您要处理多少个案例？如果有帮助的话。@Guvante不会太多。Int32、Int16和可以是整数到双精度