c#中检查盒装原语整型数值的最快方法

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

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

你能提出一个更好的方法吗?

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

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

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