关于记忆化实施的2个问题

Question

我有一个这样的类：

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) 和 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)

等等，但显然它根本无法很好地扩展。

Answer 1

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

最好的选择是：

1. 为任意数量的参数制作代码变体，最多可达某个大值（例如 10 或 20？），就像 System.Func 会。

2. 使用Object作为键（使用Delegate作为函数），而不是泛型类型。这会降低类型安全性并导致速度急剧下降，只有当调用 DynamicInvoke 的成本超过函数速度时才应使用它。

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

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

   自动记忆（别名 F、T...）（T args）
   {
       自动键=元组(args); //将args打包成一个
       静态 typeof(F(args))[typeof(key)] 缓存； //字典
       返回缓存中的密钥？缓存[键] : (缓存[键] = F(args));
   }
   

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

   结果 = memoize!(func)(args); //使用参数调用记忆的“func”
   

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