类属性的 Lambda 表达式

Question

有人可以解释为什么以下两个示例中的第一个有效而另一个无效吗？更具体地说，在第一个示例中，T 和 TProperty 之间的关系是如何创建的？

//Example 1  
class SomeClass<T> where T : class
{
    void SomeMethod<TProperty>( Expression<Func<T,TProperty>> expression ){ ... }
}

//Example 2  
class SomeClass
{
    void SomeMethod<T,TProperty>( Expression<Func<T,TProperty>> expression ) 
         where T : class{ ... }
}

鉴于这两个示例，我希望以下实现会起作用，但第二个不会。

//Implementation w/ Example 1  
var sc = new SomeClass<MyDateClass>();
sc.SomeMethod( dt => dt.Year );

//Implementation w/ Example 2
var sc = new SomeClass();
sc.SomeMethod<MyDateClass>( dt => dt.Year );

我难以理解的是第一个示例/实现如何在执行 SomeMethod 时忽略 TProperty 泛型类型，但第二个示例/实现不能以及如何在 T 之间建立隐式关系以及示例/实现 1 中的 TProperty。

解决方案 更改示例 2 中方法的签名如下：

void SomeMethod<T>( Expression<Func<T,Object>> expression ){ ... }

虽然这将允许在表达式中使用任意对象，因此它确实允许如实现 2 中所述的属性连接。

Answer 1

您允许编译器推断类型参数。这适用于案例 1：

class SomeClass<T> where T : class {
    void SomeMethod<TProperty>( Expression<Func<T,TProperty>> expression ){ ... }
}

因为你首先声明了一个实例：

var sc = new SomeClass<MyDateClass>();

告诉编译器T is MyDateClass。然后，当你调用方法时：

sc.SomeMethod( dt => dt.Year );

编译器知道T is MyDateClass，所以T.Year 必须是一个int。这些信息足以将SomeMethod 解析为SomeMethod<MyDateClass, int>。

然而，您的第二个示例是明确说明类型参数 - 告诉编译器不推断它：

sc.SomeMethod<MyDateClass>( dt => dt.Year );

不幸的是，它试图用一个类型参数（<MyDateClass> 位）调用SomeMethod。由于那不存在，它会抱怨并说您需要 2 个类型参数。

如果您像第一个示例一样调用它：

sc.SomeMethod( dt => dt.Year );

编译器会抱怨，告诉您它无法推断类型参数 - 根本没有足够的信息来确定 dt 是什么。因此，您可以明确声明 both 类型参数：

sc.SomeMethod<MyDateClass, int>( dt => dt.Year );

或者，告诉编译器 dt 是什么（这是您在第一个示例中通过新 SomeClass<MyDateClass> 所做的）：

sc.SomeMethod((MyDateClass dt) => dt.Year );

编辑和更新：

编译器在第一个示例中如此有效地执行魔术？假设 TProperty 应该是 int 因为 .Year 是 int？这将回答我的问题，但不能说它令人满意。

并不是真正的魔法，而是一系列的小步骤。举例说明：

1. sc 是 SomeClass<MyDateClass> 类型，使得 T = MyDateClass
2. SomeMethod 使用参数dt => dt.Year 调用。
3. dt 必须是 T（这就是 SomeMethod 的定义方式），对于 sc 实例，它必须是 MyDateClass。
4. dt.Year 必须是一个 int，因为 MyDateClass.Year 被声明为一个 int。
5. 由于dt => dt.Year总是返回一个int，expression的返回必须是int。因此TProperty = int。
6. 这使得参数expression 变为SomeMethod、Expression<Func<MyDateClass,int>>。回想一下T = MyDateClass（第 1 步）和TProperty = int（第 5 步）。
7. 现在我们已经计算出所有类型参数，使得SomeMethod<T, TProperty> = SomeMethod<MyDateClass, int>。

[B]但是在类级别指定 T 和在方法级别指定有什么区别？ SomeClass<SomeType> 与 SomeMethod<SomeType>... 在这两种情况下，T 都是已知的，不是吗？

是的，T 在这两种情况下都是已知的。问题是SomeMethod<SomeType> 调用的方法只有一个类型参数。在示例 2 中，有 2 个类型参数。您可以让编译器为该方法推断 所有 类型参数，或 none 个。你不能只传递 1 并让它推断另一个 (TProperty)。所以，如果你要显式声明T，那么你也必须显式声明TProperty。

Answer 2

首先，您的第一个示例不正确，并且不会按照给定的方式编译。除了方法上缺少的public 之外，您还定义了两次T - 一次在类上，一次在方法上。这本身并不是错误（尽管您会收到警告），但是在编译方法调用时，您会收到与您描述的错误相同的错误，例如 #2。所以，我假设实际的代码是这样的：

//Example 1  
class SomeClass<T> where T : class
{
  public void SomeMethod<TProperty>(Expression<Func<T,TProperty>> expression) {}
}

此外，在您对SomeMethod 的调用中，您的两个示例都“忽略”（即推断）TProperty 的实际类型。您的第二个示例明确指定了T 的类型，是的，但不是TProperty。

在第一个示例中也没有建立隐式关系。当您使用T=MyDateClass 实例化SomeClass<> 时，该实例化的SomeMethod 的签名有效地变为：

void SomeMethod<TProperty>(Expression<Func<MyDateClass, TProperty>> expression)

所以此时 lambda 的参数类型是已知的，因此您不必指定它。表达式 lambda 的返回类型被推断为 => 右侧的表达式类型，这将是 TProperty 的推断类型。

在第二个例子中，因为T在实例化类时没有显式指定，并且由于无法从方法参数中推断出来，所以必须显式指定。指定后，TProperty 的推断方式与示例 #1 完全相同。

Answer 3

请查看Eric Lippert 的帖子，而不是输入具体信息。我想它会回答你想问的问题。

我知道它很长而且做作，但我认为这是回答你的最佳选择。

Answer 4

据我所知，问题只是 DateTime 不是一个类...您将 T 作为 DateTime 传递（无论是隐式还是显式）。

在第一个示例中，您有两个名为T 的类型参数可能有点令人困惑——一个在类型上，一个在方法上。它们实际上是完全分开的......为了相同，将第一个示例重写为：

//Example 1  
class SomeClass<T> where T : class
{
    void SomeMethod<TProperty>( Expression<Func<T,TProperty>> expression ){ ... }
}

现在是一样的T : class