如何在 C# 中检查（通用）数字类型是整数类型还是非整数类型？

Question

我有一个泛型类型T。使用Marc's Operator class我可以对其进行计算。

是否可以仅通过计算来检测类型是integral 还是nonintegral 类型？

也许有更好的解决方案？我更愿意支持任何可能的类型，所以我想防止硬编码哪些类型是整数/非整数。

背景信息

我发现自己的情况是我想将double 转换为T，但将T 的最接近值四舍五入到double 值。

int a = (int)2.6 产生2，而我希望它产生3，但不知道类型（在本例中为int）。也可以是double，在这种情况下，我希望结果是2.6。

Answer 1

你试过Convert.ChangeType吗？比如：

Convert.ChangeType(1.9d, typeof (T))

它适用于我认为的所有数字类型（只要第一个参数是 iConvertible 并且类型是受支持的类型，我相信所有基本数字都应该是）。

重要的是要提到这将调用类似 double.ToInt32 的东西，它会舍入值而不是截断（我相信银行家会四舍五入）。

我在一个小的 LinqPad 程序中对此进行了测试，它可以满足我的需求：

void Main()
{
    var foo = RetNum<decimal>();
    foo.Dump();
}

public static T RetNum<T>()
{
    return (T)Convert.ChangeType(1.9d, typeof (T));
}

Answer 2

这是一个方法，它可以确定存储在通用数字类型中的特定值是否是一个没有硬编码的整数。经过测试在 .NET 4 上为我工作。正确处理所有内置数字类型（如底部的 MSDN 链接中定义），但 BigInteger 除外，它不实现 IConvertible。

        public static bool? IsInteger<T>(T testNumber) where T : IConvertible
        {
            // returns null if T is non-numeric
            bool? isInt = null;
            try
            {
                isInt = testNumber.ToUInt64(CultureInfo.InvariantCulture) == testNumber.ToDouble(CultureInfo.InvariantCulture);
            }
            catch (OverflowException)
            {
                // casting a negative int will cause this exception
                try
                {
                    isInt = testNumber.ToInt64(CultureInfo.InvariantCulture) == testNumber.ToDouble(CultureInfo.InvariantCulture);
                }
                catch
                {
                    // throw depending on desired behavior
                }
            }
            catch
            {
                // throw depending on desired behavior
            }
            return isInt;
        }

这是一个确定特定类型是否为整数类型的方法。

    public static bool? IsIntegerType<T>() where T : IConvertible
    {
        bool? isInt = null;
        try
        {
            isInt = Math.Round((double)Convert.ChangeType((T)Convert.ChangeType(0.1d, typeof(T)),typeof(double)), 1) != .1d;
            // if you don't round it and T is float you'll get the wrong result
        }
        catch
        {   
            // T is a non numeric type, or something went wrong with the activator
        }
        return isInt;
    }

Convert.ChangeType 是在两种通用数字类型之间进行舍入转换的方法。但是出于兴趣和好奇，这里有一种将泛型数字类型转换为int 的方法，可以将其扩展为返回泛型类型而不会有太大困难。

    public static int GetInt32<T>(T target) where T : IConvertible
    {
        bool? isInt = IsInteger<T>(target);
        if (isInt == null) throw new ArgumentException(); // put an appropriate message in
        else if (isInt == true)
        {
            try
            {
                int i = target.ToInt32(CultureInfo.InvariantCulture);
                return i;
            }
            catch
            {   // exceeded size of int32
                throw new OverflowException(); // put an appropriate message in
            }
        }
        else
        {
            try
            {
                double d = target.ToDouble(CultureInfo.InvariantCulture);
                return (int)Math.Round(d);
            }
            catch
            {   // exceeded size of int32
                throw new OverflowException(); // put an appropriate message in
            }
        }
    }

我的结果：

        double d = 1.9;
        byte b = 1;
        sbyte sb = 1;
        float f = 2.0f;
        short s = 1;
        int i = -3;
        UInt16 ui = 44;
        ulong ul = ulong.MaxValue;
        bool? dd = IsInteger<double>(d); // false
        bool? dt = IsInteger<DateTime>(DateTime.Now); // null
        bool? db = IsInteger<byte>(b); // true
        bool? dsb = IsInteger<sbyte>(sb); // true
        bool? df = IsInteger<float>(f); // true
        bool? ds = IsInteger<short>(s); // true
        bool? di = IsInteger<int>(i); // true
        bool? dui = IsInteger<UInt16>(ui); // true
        bool? dul = IsInteger<ulong>(ul); // true
        int converted = GetInt32<double>(d); // coverted==2
        bool? isd = IsIntegerType<double>(); // false
        bool? isi = IsIntegerType<int>(); // true

此外，this MSDN page 有一些示例代码可能会有所帮助。具体来说，它包括一个被认为是数字类型的列表。

Answer 3

我不是 100% 确定你在问什么，但是：

要检查它是否是一个完整的类型，请使用：if (obj is float || obj is double)，或if typeof(T) == typeof(float) || typeof(T) == typeof(double))

要检查它是否是一个整数值，将其转换为双精度，然后执行if(value == Math.Round(value))

当然，这是假设您首先有一个数字。我相信您使用的 Operator 类支持 DateTime 之类的东西。让你的泛型方法有一个泛型约束where T : IConvertible 会更好吗？这样就会有明确的ToDouble 和ToInteger 方法。

编辑：

我想我明白了：你有两个局部变量，double d; T num;。您想将 d 转换为类型 T，但如果 T 是整数类型，则进行适当的舍入。对吗？

假设这是正确的，这就是我要做的：

public void SomeMethod<T>()
{
    double d;
    // I think I got all the floating-point types. There's only a few, so we can test for them explicitly.
    if(typeof(T) != typeof(double) && typeof(T) != typeof(float) && typeof(T) != typeof(Decimal))
    {
        d = Math.Round(d);
    }
    T converted = Convert.ChangeType(d, typeof(T));
}

Answer 4

Chris's answer 为我提到的场景提供了一个可能的解决方案，但出于性能原因，我仍在尝试回答实际问题。

假设（未经测试）是，Convert.ChangeType 比 Math.Round() 慢得多。理想情况下，我可以检查一次给定类型是否为整数，然后有条件地调用Math.Round() 以获得比不断调用Convert.ChangeType() 更有效的解决方案。

我正在尝试以下实现：

1. 将3、2 和1 都转换为所需的未知类型。 （假设可以从 int 转换为数字类型，无论如何这应该始终是可能的。）
2. 如果是3 / 2 == 1，它是一个整数类型。否则，它是非整数类型。

此解决方案不依赖于知道类型，仅使用转换和计算。