C# Func的奇怪语法<；T、 Z>；作为参数，它为什么工作？

所以我已经用了一段时间了，我在弄乱它的时候偶然发现了它的语法。但我仍然不知道它到底为什么起作用，有人能给我解释一下吗？这是如何分解的

public T LoadData(Func<Z, T> func, Z arg) where T: class
{
  T data = func(arg);

  return data;
}

public T LoadData(Func<Z, T> func) where T: class
{
  return LoadData<object, T>(arg => func(), null); // <--- Why does the arg => func() part work? It basically ignores the parameter when it gets passed in for some reason...
}

public T LoadData（Func Func，Z arg），其中T:class
{
T数据=func（arg）；
返回数据；
}
公共T LoadData（Func Func），其中T:class
{
返回LoadData（arg=>func（），null）；//func（）部分工作？由于某种原因传入时，它基本上会忽略参数。。。
}

我是这样用的：

public IEnumerable<CategoryTypes> GetCategories()
{
  return LoadData(CategoryProvider.GetCategoriesByGroupId, 12);
}

public int LoadData(Func<int, void> func, int arg)

public IEnumerable GetCategories（）
{
返回LoadData（CategoryProvider.GetCategoriesByGroupId，12）；
}

或

public IEnumerable GetStatesLookup（）
{
返回LoadData（StatesProvider.GetStates）；
}

PS：这是伪代码，我使用它的真正原因比上面的例子要复杂一些

更新以修复我在此处键入此内容时意外反转的泛型。。。

---

更新2：修复了意外定义arg a T而不是Z的问题，这是因为您正在创建一个满足

Func

的新lambda，这是因为您正在创建一个满足

Func

的新lambda，它正在另一个

Func

中包装

Func

。新的

Func

所做的唯一事情就是调用旧的

Func

，而不考虑

arg

---

您可以用

func

简单地交换

arg=>func（）

，或者

arg=>func（arg）

它将

func

包装在另一个

func

中。新的

Func

所做的唯一事情就是调用旧的

Func

，而不考虑

arg

---

您可以用

func

或

arg=>func（arg）

简单地交换

arg=>func（）

，方法

LoadData

是

T

的泛型，其中

T

必须是

类。但是，
T
作为传递给它的
Func
的单个参数类型进一步传递。最后，
Z
用作
Func
的通用返回类型

因此，简而言之，传入的
Func
必须接收与调用
LoadData
时定义的类型相同的类型。然后，它返回一个不同的类型，这当然是在您将
Func
发送到
LoadData
时定义的

所以，这就是为什么这样做的原因：

LoadData(CategoryProvider.GetCategoriesByGroupId, 12);

本例中的
T
是
int
，您传入的
Func
接收一个类型为
int
的参数。它返回什么，我不知道，但这并不重要——它被用作
Z

该调用可能静态地如下所示：

public IEnumerable<CategoryTypes> GetCategories()
{
  return LoadData(CategoryProvider.GetCategoriesByGroupId, 12);
}

public int LoadData(Func<int, void> func, int arg)

public int-LoadData（Func-Func，int-arg）

为了解决第二组伪代码，我不相信即使是编译，也不相信您有这样一个真实的具体示例。您尚未满足
t
的要求，并且
void
在那里无效。这是一个完美的例子，说明了为什么伪代码不是这里一个问题的好候选。
方法
LoadData
是
T
的泛型，其中
T
必须是
类。但是，
T
作为传递给它的
Func
的单个参数类型进一步传递。最后，
Z
用作
Func
的通用返回类型

因此，简而言之，传入的
Func
必须接收与调用
LoadData
时定义的类型相同的类型。然后，它返回一个不同的类型，这当然是在您将
Func
发送到
LoadData
时定义的

所以，这就是为什么这样做的原因：

LoadData(CategoryProvider.GetCategoriesByGroupId, 12);

本例中的
T
是
int
，您传入的
Func
接收一个类型为
int
的参数。它返回什么，我不知道，但这并不重要——它被用作
Z

该调用可能静态地如下所示：

public IEnumerable<CategoryTypes> GetCategories()
{
  return LoadData(CategoryProvider.GetCategoriesByGroupId, 12);
}

public int LoadData(Func<int, void> func, int arg)

public int-LoadData（Func-Func，int-arg）

为了解决第二组伪代码，我不相信即使是编译，也不相信您有这样一个真实的具体示例。您尚未满足
t
的要求，并且
void
在那里无效。这是一个很好的例子，说明了为什么伪代码不是一个很好的候选问题。
它似乎是将一个不带参数的函数“转换”为一个带参数的函数。第二个重载中的
null
可以是任何值，因为它只传递到忽略其参数的函数中

但是，显示的代码没有意义。在第一个重载中，您有：

T data = func(arg);

然而
func
的返回类型是
Z
，而不是
T
。因此，只有当
Z
是
T
时，这才有效

然后在第二个重载中，
func
在没有参数的情况下被调用，但它仍然是一个
func
，这意味着它必须接受一个
T
参数

如果类型参数被交换（
Z
作为参数类型，
T
作为返回类型），并且第二个重载没有使用
Z
，则更有意义：

public T LoadData(Func<Z,T> func, Z arg) where T: class
{
  T data = func(arg);

  return data;
}

public T LoadData(Func<T> func) where T: class
{
  return LoadData<object, T>(arg => func(), null);
}

public T LoadData（Func Func，Z arg），其中T:class
{
T数据=func（arg）；
返回数据；
}
公共T LoadData（Func Func），其中T:class
{
返回LoadData（arg=>func（），null）；
}
这似乎是在将不带参数的函数“转换”为带参数的函数。第二个重载中的
null
可以是任何值，因为它只传递到忽略其参数的函数中

但是，显示的代码没有意义。在第一个重载中，您有：

T data = func(arg);

但是
func
的返回类型是
Z
，而不是<