CODEWITHSUNDEEP
performancelinqentity-framework
sports
sports

Reputation: 8147

Am I abusing of Linq to objects?

I think that queries with linq to objects end up very readable and nice. For example:

from person in db.Persons.ToList()
where person.MessageableBy(currentUser) ...

Where MessageableBy is a method that can't be translated into a store expression (sql)

    public bool MessageableBy(Person sender)
    {
        // Sender is system admin
        if (sender.IsSystemAdmin())
            return true;

        // Sender is domain admin of this person's domain
        if (sender.Domain.DomainId == this.Domain.DomainId && this.Domain.HasAdmin(sender))
            return true;

        foreach (Group group in this.Groups)
        {
            if (group.MessageableBy(sender)) 
                return true;
        }

        // The person is attorney of someone messageable
        if (this.IsAttorney)
        {
            foreach (Person pupil in this.Pupils)
                if (pupil.MessageableBy(sender)) 
                    return true;
        }

        return false;
    }

The problem is that I think that this is not going to scale. I'm already noticing that with a few entries in the database, so can't imagine with a large database.

So the question is: Should I mix linq to entities with linq to objects (ie: apply some of the "where" to the ICollection and some of the "where" to the .ToList() result of that? should I only use linq to entities, ending with a very large sentence?

Upvotes: 0

Views: 110

Answers (3)

Pieter Geerkens
Pieter Geerkens

Reputation: 11893

Although this simply paraphrases the statements made by earlier respondents, I believe it is important to enough to truly emphasize:

It is critical for DB application performance to perform as much calculation as possible, and particularly as much filtering and aggregation as possible, on the DB server prior to sending the resulting data to the client.

Upvotes: 0

user799755
user799755

Reputation:

I largely agree with your initial analysis. Mixing Linq to Objects and Linq to Entities is fine, but requires retrieving more data than is necessary, and therefore could lead to scaling problems down the road.

Remember to design you data model to support the critical queries. Perhaps a user could be a person, and person could have a self relationship that determines who can message who. This is just a simple thought, to inspire you to consider other ways of representing your data to allow the MessableBy method to be realized in the query itself.

In the meantime, if it isn't causing performance problems, then I would consider this issue more in terms of model design.

Upvotes: 0

AD.Net
AD.Net

Reputation: 13399

.ToList() will actually execute the query and fetch all the data in that table, which is not something you'd want unless you know for sure it'll always be few records. So yes, you should do more in the where clause before doing .ToList()

Upvotes: 2

Related Questions