2

我有这样的课：

Public NotInheritable Class F
    Private Sub New()
    End Sub
    Public Shared Function Mize(Of TResult)(ByVal f As System.Func(Of TResult)) As System.Func(Of TResult)
        Dim is_new = True
        Dim result As TResult
        Return Function()
                   If is_new Then
                       result = f()
                   End If
                   Return result
               End Function
    End Function
    Public Shared Function Mize(Of T, TResult)(ByVal f As System.Func(Of T, TResult)) As System.Func(Of T, TResult)
        Dim is_new_s = New System.Collections.Generic.List(Of Boolean)
        Dim inputs = New System.Collections.Generic.List(Of T)
        Dim d = New System.Collections.Generic.Dictionary(Of T, TResult)

        Return Function(arg1 As T)
                   If d.ContainsKey(arg1) Then
                       Return d.Item(arg1)
                   Else
                       Dim result = f(arg1)
                       d.Add(arg1, result)
                       Return result
                   End If
               End Function
    End Function End Class

我想知道

1）这是否违反了静态类不应该有状态的短语？

2）我怎样才能修改函数，使它们可以接受任何函数（而不是我上面只适用于F(TResult)and的情况F(T, TResult)。我的意思是我可以创建另一个函数，即：

Function Mize(Of T, T2, TResult)(ByVal f As System.Func(Of T, T2, TResult))
                                                 As System.Func(Of T, T2, TResult)

等等，但显然它根本不能很好地扩展。

4

1 回答 1

2

由于泛型在 .NET 中的工作方式，不可能用任何采用任意数量泛型参数的 .NET 语言编写泛型函数。

您最好的选择是：

  1. 为任意数量的参数（最大为 10 或 20？）创建代码变体，就像System.Func<TResult, T1, T2, T3, ...>.

  2. 使用Objects 作为键（和Delegates 作为函数），而不是泛型类型。这将降低类型安全性并可能导致显着减速，并且只有在调用成本超过函数速度时才应使用它DynamicInvoke。

  3. 使用支持模板的不同语言，如 C++、D 或 Scheme（这不是一个非常简单的选择，但我还是提到了它）。

    例如，在某些语言中，记忆很容易，例如 D：

    auto memoize(alias F, T...)(T args)
{
    auto key = tuple(args); //Pack args into one
    static typeof(F(args))[typeof(key)] cache; //Dictionary
    return key in cache ? cache[key] : (cache[key] = F(args));
}

    可以很容易地使用，例如：

    result = memoize!(func)(args);  //Calls a memoized 'func' with args

不，您的示例不违反状态原则，因为您的静态类不保持状态！（您实际上每次都在捕获一个局部变量，而不是重用以前的任何东西。）不过，我的确实如此。

于 2011-05-07T20:52:36.297 回答