4

byte我想编写泛型类，该类旨在与和等内置类型一起使用ushort。在内部计算中，我需要将泛型类型转换为整数并返回到泛型类型。我找到了编译此类代码的方法，例如：

class Test<T> where T : struct, IConvertible
{
    public static T TestFunction(T x)
    {
        int n = Convert.ToInt32(x);
        T result = (T)Convert.ChangeType(n, typeof(T));
        return result;
    }
}

我认为，如果在计算循环中使用此类转换，可能会显着降低性能。有没有更好的方法来进行这些转换？

4

2 回答 2

2

int转换T有点棘手。我想你可以Expression在这里使用类。

Test<T>类应该看起来像这样：

class Test<T> where T : struct, IConvertible
{
    private static Func<int, T> _getInt;

    static Test()
    {
        var param = Expression.Parameter(typeof(int), "x");
        UnaryExpression body = Expression.Convert(param, typeof(T));
        _getInt = Expression.Lambda<Func<int, T>>(body, param).Compile();
    }

    public static T TestFunction(T x)
    {
        int n = Convert.ToInt32(x);
        T result = _getInt(n);
        return result;
    }
}

它在静态构造函数中为您准备_getInt = x => (T)x并稍后使用它来转换int为T.

于 2013-08-12T08:44:24.470 回答
1

经过一番思考，我很高兴感谢这个问题和一些答案，我解决了我的一个老问题：在泛型 T 上使用操作：

首先是 Cast 的示例（根据 OP 的要求）

public static class Cast<T, U>
{
    public static readonly Func<T, U> Do;

    static Cast()
    {
        var par1 = Expression.Parameter(typeof(T));

        Do = Expression.Lambda<Func<T, U>>(Expression.Convert(par1, typeof(U)), par1).Compile();
    }
}

然后是一个乘法示例：

public static class Multiply<T>
{
    public static readonly Func<T, T, T> Do;

    static Multiply()
    {
        var par1 = Expression.Parameter(typeof(T));
        var par2 = Expression.Parameter(typeof(T));

        Do = Expression.Lambda<Func<T, T, T>>(Expression.Multiply(par1, par2), par1, par2).Compile();
    }
}

使用非常简单：

int x = Conv<T, int>.Do(someTValue);

最后创建了一个静态类，其中有一个字段是一个名为的只读静态属性Do，它是一个“指向”使用表达式树构建的操作的委托。

乘法类似：

T res = Multiply<T, T>.Do(someTValue1, someTValue2);

在一般情况下，乘法比直接乘法慢 3 倍（在发布模式下，没有调试）。

从乘法开始，显然做其他操作很简单

（有趣的是，我对Expression树非常了解，但我从未想过使用静态类作为包含各种类型的“字典”。我总是做类似的事情，Dictionary<Type, Delegate>而不是让 .NET “处理”Dictionary通过泛型类专业化。）

于 2013-08-12T08:19:46.163 回答