C＃中：对于数字通用接口 [英] C#: Generic Interface for Numbers

问题描述

我试图执行一些通用号码独立操作数的类型。不过，据我所知，没有办法使用泛型做到这一点。的第一个想法是过滤传入类型的一个，其中的语句，但所有的数字类型的闭合的，因此，不适用于一般的过滤器。此外，仿制药不允许标准的数字运算（另外，移位等），所以唯一的解决方案，我能想出是重新编写每个方法不一般。 ？任何其他的想法。

有关参考，下面是我最初尝试的代码：

 私人const int的BYTE_SIZE = 8; 
 
私人const int的UINT16_SIZE = 16; 
 
私人const int的UINT32_SIZE = 32; 
 
私人const int的UINT64_SIZE = 64; 
 
公共静态的byte [] ToBytes（UINT16 [] pnaValues​​）
 {
返回ToSmaller<字节，UINT16>（pnaValues​​，BYTE_SIZE，UINT16_SIZE）; 
} 
 
公共静态的byte [] ToBytes（UInt32的[] pnaValues​​）
 {
返回ToSmaller<字节，UInt32的>（pnaValues​​，BYTE_SIZE，UINT32_SIZE）; 
} 
 
 .... 
 
公共静态UINT16 [] ToUInt16s（字节[] pnaValues​​）
 {
返回ToLarger< UINT16 ，字节>（pnaValues​​，UINT16_SIZE，BYTE_SIZE）; 
} 
 
公共静态UINT16 [] ToUInt16s（UInt32的[] pnaValues​​）
 {
返回ToSmaller< UINT16，UInt32的>（pnaValues​​，UINT16_SIZE，UINT32_SIZE）; 
} 
 
 ... 
 
公共静态UINT64 [] ToUInt64s（UInt32的[] pnaValues​​）
 {
返回ToLarger< UINT64， UInt32的>（pnaValues​​，UINT64_SIZE，UINT32_SIZE）; 
} 
 
私有静态TLarger [] ToLarger< TLarger，TSmaller>（TSmaller [] pnaSmaller，INT pnLargerSize，诠释pnSmallerSize）
式TLarger：字节，UINT16，UInt32的，UINT64 
式TSmaller：字节，UINT16，UInt32的，UINT64 
 {
 TLarger [] lnaRetVal = NULL; 
 INT lnSmallerPerLarger = pnLargerSize / pnSmallerSize; 
 
 System.Diagnostics.Debug.Assert（（pnLargerSize％pnSmallerSize）== 0）; 
 
如果（pnaSmaller！= NULL）
 {
 System.Diagnostics.Debug.Assert（（pnaSmaller％lnSmallerPerLarger）== 0）; 
 
 lnaRetVal =新TLarger [pnaSmaller.Length / lnSmallerPerLarger] 
 
的for（int i = 0; I< lnaRetVal.Length;我++）
 {
 lnaRetVal [I] = 0; 
 
表示（中间体J = 0; J&下; lnSmallerPerLarger; J ++）
 {
 lnaRetVal [I] =（lnaRetVal [1]  - ;&下; pnLargerSize）+ pnaSmaller [我* lnSmallerPerLarger + J]。 
} 
} 
} 
 
返回lnaRetVal; 
} 
 
私有静态TSmaller [] ToSmaller< TSmaller，TLarger>（TLarger [] pnaLarger，INT pnSmallerSize，诠释pnLargerSize）
式TSmaller：字节，UINT16，UInt32的，UINT64 
式TLarger：字节，UINT16，UInt32的，UINT64 
 {
 TSmaller [] lnaRetVal = NULL; 
 INT lnSmallerPerLarger = pnLargerSize / pnSmallerSize; 
 
 System.Diagnostics.Debug.Assert（（pnLargerSize％pnSmallerSize）== 0）; 
 
如果（pnaSmaller！= NULL）
 {
 lnaRetVal =新TSmaller [pnaLarger.Length * lnSmallerPerLarger]。 
 
的for（int i = 0; I< lnaRetVal.Length;我++）
 {
为（INT J = 0; J< lnSmallerPerLarger; J ++）
 {
 lnaRetVal [我* lnSmallerPerLarger +（lnSmallerPerLarger  -  1  -  j）条] 
 = pnaLarger [Ⅰ]≥> （J * pnLargerSize）; 
} 
} 
} 
 
返回lnaRetVal; 
} 
  

解决方案

有算术没有通用接口操作由数值类型实现的。 通用运营商可能会帮助解决你的问题。

I am trying to perform some generic number manipulation independent of the number type. However, I know of no way to use generics to do this. The first idea was to filter the incoming types with a where statement, but all of the number types are closed and are, therefore, not valid for a generic filter. Also, the generics don't allow standard numeric operations (addition, shift, etc), so the only solution I can come up with is to re-write each method non-generically. Any other ideas?

For reference, following is the code that I initially tried:

    private const int BYTE_SIZE = 8;

    private const int UINT16_SIZE = 16;

    private const int UINT32_SIZE = 32;

    private const int UINT64_SIZE = 64;

    public static byte[] ToBytes(UInt16[] pnaValues)
    {
        return ToSmaller<byte, UInt16>(pnaValues, BYTE_SIZE, UINT16_SIZE);
    }

    public static byte[] ToBytes(UInt32[] pnaValues)
    {
        return ToSmaller<byte, UInt32>(pnaValues, BYTE_SIZE, UINT32_SIZE);
    }

    ....

    public static UInt16[] ToUInt16s(byte[] pnaValues)
    {
        return ToLarger<UInt16, byte>(pnaValues, UINT16_SIZE, BYTE_SIZE);
    }

    public static UInt16[] ToUInt16s(UInt32[] pnaValues)
    {
        return ToSmaller<UInt16, UInt32>(pnaValues, UINT16_SIZE, UINT32_SIZE);
    }

    ...

    public static UInt64[] ToUInt64s(UInt32[] pnaValues)
    {
        return ToLarger<UInt64, UInt32>(pnaValues, UINT64_SIZE, UINT32_SIZE);
    }

    private static TLarger[] ToLarger<TLarger, TSmaller>(TSmaller[] pnaSmaller, int pnLargerSize, int pnSmallerSize)
        where TLarger : byte, UInt16, UInt32, UInt64
        where TSmaller : byte, UInt16, UInt32, UInt64
    {
        TLarger[] lnaRetVal = null;
        int lnSmallerPerLarger = pnLargerSize / pnSmallerSize;

        System.Diagnostics.Debug.Assert((pnLargerSize % pnSmallerSize) == 0);

        if (pnaSmaller != null)
        {
            System.Diagnostics.Debug.Assert((pnaSmaller % lnSmallerPerLarger) == 0);

            lnaRetVal = new TLarger[pnaSmaller.Length / lnSmallerPerLarger];

            for (int i = 0; i < lnaRetVal.Length; i++)
            {
                lnaRetVal[i] = 0;

                for (int j = 0; j < lnSmallerPerLarger; j++)
                {
                    lnaRetVal[i] = (lnaRetVal[i] << pnLargerSize) + pnaSmaller[i * lnSmallerPerLarger + j];
                }
            }
        }

        return lnaRetVal;
    }

    private static TSmaller[] ToSmaller<TSmaller, TLarger>(TLarger[] pnaLarger, int pnSmallerSize, int pnLargerSize)
        where TSmaller : byte, UInt16, UInt32, UInt64
        where TLarger : byte, UInt16, UInt32, UInt64
    {
        TSmaller[] lnaRetVal = null;
        int lnSmallerPerLarger = pnLargerSize / pnSmallerSize;

        System.Diagnostics.Debug.Assert((pnLargerSize % pnSmallerSize) == 0);

        if (pnaSmaller != null)
        {
            lnaRetVal = new TSmaller[pnaLarger.Length * lnSmallerPerLarger];

            for (int i = 0; i < lnaRetVal.Length; i++)
            {
                for (int j = 0; j < lnSmallerPerLarger; j++)
                {
                    lnaRetVal[i * lnSmallerPerLarger + (lnSmallerPerLarger - 1 - j)]
                        = pnaLarger[i] >> (j * pnLargerSize);
                }
            }
        }

        return lnaRetVal;
    }

解决方案

There's no common interface for arithmetic operations implemented by numeric types. Generic operators might help solving your problem.

这篇关于C＃中：对于数字通用接口的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！