Loading behaviour of EF v1?

another Entity Framework (ADO.NET) question from me. I'm using EF1 (no choice there) and have a MySQL database as a backend.

A simple question I can't really find a satisfying answer for:

What exactly do I have to do for loading? IE., when I have an entity and want to enumerate through its children, say I have the Entity "Group" and it has a child "User", and I want to do "from n in g.Users where n.UserID = 4 select n", I first have to call g.Users.Load();

This is a bit annoying, because when I do a query against a non-loaded collection, I would expect the EF to load it automatically - AT LEAST throw some exception, not simply return 0 results?

Another case of me having to take care of loading: I have a query:

from n in Users where n.Group.Name == "bla" select n

For some reason it fails, giving a null pointer for n.Group, even though n.GroupID (the key for the group) is correctly set. Also, when I before do Server.Groups.Load() (Groups are children of one Server), it works.

Is t开发者_如何学运维here any exact policy about when to call Load() of which collection?

Thank you again, Michael

There is no lazy loading in the first version of entity framework. Any time you want to access something you have not previously loaded, be it a reference to a single object or a collection of objects, you will either have to explicitly tell it to load that reference. The Include() option (first from Rup above) is going to try to load all the data you want in one large query and processing call, the result being that Include() performs slowly. The other method (2nd from Rup above), checking and then loading unloaded references, performed much faster and allowed us to limit loads to what we needed.

Basically our policy was to load only what you had to in the initial query, minimizing performance impact. Then we would check and load the reference later when we wanted to access a referenced entity or entity collection. This resulted in more queries to the database, but they were faster and we were only loading the ancillary data when we needed it, instead of pre-loading everything we could potentially need. It was possible that the same property would get checked as couple times in a function, but it would only have been loaded once and we could be sure we were only loading it because we were using it.

Do you mean ObjectQuery.Include, e.g.

var g = from g in MyDb.Groups.Include("Users") where g.Id = 123 select g;
from n in g.Users where n.UserID = 4 select n

from n in Users.Include("Group") where n.Group.Name == "bla" select n

You can also wrap Load()s in a check if you're worried about over-using them,

if (g.CanLoadReferences() && !g.Users.IsLoaded)
{
    g.Users.Load();
}

(apologies for any silly syntax slips here - I use the other LINQ syntax and EF4 now)

This works when we run against MS SQL server, it could be a limitation in the MySQL Adapter.

Are you using the latest version 6.2.3? See: http://www.mysql.com/downloads/connector/net