如何使用可查询的 linq 从哈希集中有条件地选择项目？

Question

Hi I am new to C# and found this code from Internet:

public class InMemoryObjectSet<T>
    : IObjectSet<T> where T : class
{
    readonly HashSet<T> _set;
    readonly IQueryable<T> _queryableSet;

    public InMemoryObjectSet(IEnumerable<T> entities)
    {
        _set = new HashSet<T>();
        foreach (var entity in entities)
        {
            _set.Add(entity);
        }
        _queryableSet = _set.AsQueryable();
    }

    public Expression Expression
    {
        get { return _queryableSet.Expression; }
    }

    public IQueryProvider Provider
    {
        get { return _queryableSet.Provider; }
    }

    public IEnumerator<T> GetEnumerator()
    {
        return _set.GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    /* Ignore Add, Delete operations */
}

I am trying to find an element in InMemoryObjectSet with condition name is 'xx'. Of course I can use IEnumerator to loop through but I just wonder if it is possible to use linq-ish way:

var inMemoryItems = new InMemoryObjectSet<Customer>();
System.Linq.Expressions.Expression<Customer> exp = (x => x.Name == "xx");
var findItem = inMemoryItems.Provider.CreateQuery<Customer>(exp);

Error was:

Cannot convert lambda expression to type 'Customer' because it is not a delegate type

Can anybody please help?

Answer 1

You want to create an Expression that can be used to filter your collection of Customers .

Your error is that the signature of your expression is not correct.

It took me a while to see the purpose of your InMemoryObjectSet<T> . HashSet already implements IEnumerable`, and thus could already handle all LINQ statements you want.

But apparently you want a class that implements IQueryable<T> , so you could handle your InMemorySet object AsQueryable

If you want to filter out certain elements of type TSource from an IQueryable you need an expression of the following type:

Expression<Func<TSource, bool>> expr = ...

Once you've created your expression, you can filter your IObjectSet<TSource> to an IQueryable<TSource> that contains only the elements that match your expression.

An IObjectSet<TSource> implements IQueryable<TSource>. An IQueryable<TSource>. An IQueryable` hides where the collection you are about to query is located, and how the elements in the collection are accessed.

The collection could be in a database, a file, the internet, or your InMemoryObjectSet.

Because of this information hiding, you don't really have to know where your collection of items your query is located, and how it is accessed (SQL? other methods?)

Every IQueryable contains an Expression and a Provider . The Expression is usually filled by you using LINQ statements. It is the task of the 'Provider' to translate the Expression into a format the underlying collection understands and send it to this underlying collection.

For a database the Provider will translate the Expression into SQL, for an InMemorySet the translation will be simpler, it will translate the expression in an IEnumerable to access the underlying HashSet.

Seeing this, you should not access the Provider . You should only create the Expression and use executioner methods like ToList() , First() , Any() , Count() , to execute the Expression and get the result.

Back to your question. Proper usage would be: (in baby steps, so you can see all underlying types)

InMemorySet<Customer> customerCollection = new InMemorySet<Customer>();
IQueryable<Customer> customers = customerCollection;

From here you don't know anymore whether your customers are in a database a file, an InMemorySet , or whatever. Because of this information hiding the following code works on any of these collections

Get all customers with name XX, using proper LINQ:

IQueryable<Cusomter> xxCustomers = customers.Where(customer => customer.Name == XX);

Use ToList() or similar to execute the query

Alternatively: create an Expression and use this in your filter function:

string XX = ...
Expression<Func<Customer, bool>> expr = customer => customer.Name == XX;
IQueryable<Customer> result1 = customers.Where(expr);

ToList() will order the Provider of result1 to execute the expression.

A really low level method would be to tell the Provider to access

// (2) Use the Provider
IQueryProvider provider = customers.Provider;
object query2 = provider.Execute(customers.Expression)

But once again: don't do this, you'll loose the information hiding, causing that it isn't guaranteed anymore that your code works on any IQueryable