NHibernate ISession.QueryOver（）不能推断类型，但是ISession.Get（）可以。为什么？

Question

In NHibernate, the following works perfectly fine:

Session.Get(repoType.ToString(), id))

But this:

Session.QueryOver(repoType.ToString(), func)

for some reason, does not. From the documentation, both methods take in the name of the entity as a string as the first parameter, but QueryOver complains with the following error message:

The type arguments for method 'NHibernate.ISession.QueryOver<T>(string, System.Linq.Expressions.Expression<System.Func<T>>)' cannot be inferred from the usage. Try specifying the type arguments explicitly.

I'm fairly sure that this is being caused by the first parameter to QueryOver (the entityName parameter), and not the func parameter.

Why is it that ISession.Get can infer the entity type from the given entity name but ISession.QueryOver cannot?

Answer 1

This is not an issue with the nHibernate library, it's an issue with .NET generics and Linq expressions.

NHibernate might be capable of inferring the entity type, but you have to get the code to compile first. :-)

---

The signature for the QueryOver function is as follows:

IQueryOver<T, T> QueryOver<T>(string entityName, Expression<Func<T>> alias) where T : class;

Note that a Func<T> is not the same type as a System.Linq.Expressions.Expression<T> .

In your example, I assume you have declared a Func<T> as a separate variable, and the compiler is unable to figure out what to cast it too.

Here are some variations of the call:

// Defining the second parameter explicitly as an expression.
// This works

Company companyAlias = null;
System.Linq.Expressions.Expression < Func < Company >> expression = () => companyAlias;
var q1 = this.Session.QueryOver("Company", expression);

We can let the compiler turn an in-line lambda into an expression. This works too, and the compiler infers all of the type arguments.

var q2 = this.Session.QueryOver("Company", () => companyAlias);

It will fail if we use a plain function object instead of an expression. Here, the compiler can't figure out how to make the Func<Company> fit into the generic expression. Hence the error "The type arguments cannot be inferred by the usage..."

Func<Company> func = () => companyAlias;

var q3 = this.Session.QueryOver("Company", func);

We help the compiler by explicitly stating the type. The code below will still fail, but we get a better error. "The best overload match for ... has some invalid arguments"

var q4 = this.Session.QueryOver<Company>("Company", func);

If possible, it's best to give it the type as a generic expression rather than the name. That way you avoid potential errors if you ever rename the type but forget to change the string in the function.

var q = session.QueryOver<Company>(() => companyAlias);

You don't even have to put the generic parameter in in this case.

var q = session.QueryOver(() => companyAlias);

However, I prefer to keep the generic parameter in, just for the sake of readability.