在 C# 中检查盒装原始整数类型的数值的最快方法 [关闭]

Question

我需要编写一个具有以下语义的方法：

/// <summary>
/// Checks if <paramref name="x"/> is a boxed instance of a primitive integral type
/// whose numerical value equals to <paramref name="y"/>.
/// </summary>
/// <param name="x">An object reference. Can be <c>null</c>.</param>
/// <param name="y">A numerical value of type <see cref="ulong"/> to compare with.</param>
/// <returns>
/// <c>true</c> if <paramref name="x"/> refers to a boxed instance of type 
/// <see cref="sbyte"/>, <see cref="short"/>, <see cref="int"/>, <see cref="long"/>, 
/// <see cref="byte"/>, <see cref="ushort"/>, <see cref="uint"/>, or <see cref="ulong"/>, 
/// whose numerical value equals to the numerical value of <paramref name="y"/>; otherwise, <c>false</c>.
/// </returns>
/// <remarks>
/// <para>
/// This method checks only for numeric equality, even if its arguments are of different runtime types
/// (e.g. <c>2L</c> is considered to be equal to <c>2UL</c>).
/// </para>
/// <para>
/// This method returns <c>false</c> if <paramref name="x"/> is <c>null</c>
/// or refers to an instance of a reference type or a boxed instance of a value type except
/// the primitive integral types listed above (e.g. it returns <c>false</c> if <paramref name="x"/>
/// refers to a boxed instance of an <c>enum</c> type, <see cref="bool"/>, <see cref="char"/>, <see cref="IntPtr"/>,
/// <see cref="UIntPtr"/>, <see cref="float"/>, <see cref="double"/>, <see cref="decimal"/>, or <see cref="BigInteger"/>).
/// </para>
/// <para>
/// This method should not throw any exceptions, or cause any observable side-effects
/// (e.g. invoke a method that could modify the state of an object referenced by <paramref name="x"/>). 
/// </para>
/// </remarks>
[Pure]
public static bool NumericalEquals(object x, ulong y)

实施应尽可能快（假设输入数据中没有预期的偏向参数x 的某些类型或值），并且不应使用unsafe 代码或P/Invoke。当然，在最快的实现中，我更喜欢最简单、最短的。

我的解决方法如下：

public static bool NumericalEquals(object x, ulong y)
{
    if (x is sbyte)
    {
        sbyte z = (sbyte)x;
        return z >= 0 && y == (ulong)z;
    }

    if (x is short)
    {
        short z = (short)x;
        return z >= 0 && y == (ulong)z;
    }

    if (x is int)
    {
        int z = (int)x;
        return z >= 0 && y == (ulong)z;
    }

    if (x is long)
    {
        long z = (long)x;
        return z >= 0 && y == (ulong)z;
    }

    if (x is byte)
    {
        return y == (byte)x;
    }

    if (x is ushort)
    {
        return y == (ushort)x;
    }

    if (x is uint)
    {
        return y == (uint)x;
    }

    if (x is ulong)
    {
        return y == (ulong)x;
    }

    return false;
}

您能提出更好的方法吗？

Answer 1

我没有测试过性能，但它更短：

public static bool NumericalEquals(object x, ulong y)
{
    var unsigned = (x as byte?) ?? (x as ushort?) ?? (x as uint?) ?? (x as ulong?);
    if (unsigned.HasValue)
    {
        return (unsigned.Value == y);
    }

    var signed = (x as sbyte?) ?? (x as short?) ?? (x as int?) ?? (x as long?);
    return (signed.HasValue) && (signed.Value >= 0) && ((ulong) signed.Value == y);
}

在最坏的情况下，会有 3 个演员表（比如 object 到 sbyte? 到 long? 然后值到 ulong），我不谈论 Nullable<T> ab使用，所以它可能比你的解决方案最慢。

[编辑]

我忘了还有一个好处：没有is 测试。你最坏的情况是 1 is 和 2 演员。所以也许表演可以足够好。

[编辑 2]

您也可以考虑使用快速消除测试来提高平均成本：

public static bool NumericalEquals(object x, ulong y)
{
    if (x.GetHashCode() != y.GetHashCode()) return false;

    ...
}

Answer 2

由于每个整数原始类型都是密封的，您的参考实现执行的 is 操作由 JIT 编译，以简单地在对象 x 的类型的 RuntimeTypeHandle 之间进行相等比较（可能获得通过一个或两个指针取消引用）和特定整数类型的句柄（可能实现为内联文字或引用固定内存位置的单个 mov 指令）。如果不利用有关方法输入分布的信息，即使不是不可能，也很难改进初始实现。

Answer 3

在原始问题的限制下，我肯定会测试的当前实现的替代方案如下。根据代表原始类型的 .NET Framework 类使用的 Type.GetTypeCodeImpl 的实现，通过在 2 个虚拟调用的结果上用 switch 替换多达 5 个类型检查（加上一个用于处理枚举），可以证明此操作更快.它使用TypeCode 枚举包含每个原始整数类型的成员这一事实。

public static bool NumericalEquals(object x, ulong y)
{
  if (x == null)
    return false;

  Type type = x.GetType();
  if (type.IsEnum)
    return false;

  switch (Type.GetTypeCode(type))
  {
  case TypeCode.Byte:
    return (byte)x == y;

  ...other cases here

  default:
    return false;
  }
}

您可以通过将块包装在try/catch 中来避免对IsEnum 的调用，以处理只有在提供盒装枚举作为输入时才会引发的异常。这可能会以较慢的false 盒装枚举结果为代价来提高预期案例的性能。