类属性的 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 和 TProperty 之间建立隐式关系示例/实现 1.

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

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

虽然这将允许在表达式中使用任意对象作为结果，但它确实允许如实现 2 中所述的属性表达。

Answer 1

首先，您的第一个示例不正确，并且不会按给定方式编译。 除了方法上缺少 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 2

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

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

因为您首先声明一个实例：

var sc = new SomeClass<MyDateClass>();

它告诉编译器 T 是 MyDateClass。 然后，当您调用该方法时：

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

编译器知道T是MyDateClass，因此T.Year必须是int。 这些信息足以将 SomeMethod 解析为 SomeMethod。

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

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

不幸的是，它试图仅使用一个来调用 SomeMethod类型参数（ 位）。 由于它不存在，它会抱怨并说你需要 2 个类型参数。

相反，如果您像第一个示例那样调用它：

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

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

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

或者，告诉编译器dt是什么（这就是您在第一个示例中通过新建SomeClass所做的事情） ;)：

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

编辑和更新：

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

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

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

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

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

Answer 3

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

可能还有些令人困惑的是，在第一个示例中，您有两个名为 T 的类型参数 - 一个位于类型上，另一个位于方法上。 它们实际上是完全独立的......为了相同，将第一个示例重写为：

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

这现在是相同的 T : class

Answer 4

不要输入具体细节，请查看 埃里克·利珀特。 我想它会回答你想问的问题。

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