In EF v1, it is possible to have one way navigations where you have an association between two entities but a navigation in only one of them. But the designer didn’t support this. If you deleted a navigation, the association was automatically removed.

You could, however, go into the XML and remove the navigation property manually, leaving the association, association mappings and the partner navigation property in tact.

The new designer now supports one way relationships – both for models with foreign keys and models without foreign keys.

Here is a model that does not use foreign keys. The associations, by the way, are called “independent associations” when there is no foreign key involved.

I start with a Customers property in the CustomerType entity and a CustomerType property in the Customer entity.

Delete CustomerType.Customers and association and Customer.CustomerType property are still there.

Next, I delete the CustomerType.Customer navigation property but the association/relationship still remains in tact. The navigations are no longer exposed in the classes but you the model is still valid as are the generated classes (I’m using the default code gen).

If you want the association to be gone, you have to explicitly delete it. But for this case, you could just delete the association to begin with and the navigations will automatically be removed. That is the same behavior as in EFv1.

Although the screenshots are from a model with independent associations, the behavior is the same for foreign key associations.

Why the “no-way” association? Either there is some unknown-to-me value to having the association defined in the metadata, or it is the only way the designer is able to pull off keeping the association intact as a result of removing a navigation.

I have asked about this last bit and will share what I learn.

In the meantime, now that it is more discoverable and simpler to create one way relationships, I bet more people will take advantage of it.

“Eager Deferred” is a bit of an oxymoron, but let me explain.

Example:

You have queried for customers.

For particular customers you want to get their orders AND order details.

customer.Orders.Load will only get the order entities.

But what if you wanted to do something similar to Include in there?

eg customer.Orders.Load.Include(“Details”)

That syntax is not possible. and is something Ben S added to the Entity Framework v2 Wish List started by John Papa.

Here’s how to pull it off in V1, as explained by Danny Simmons.

customer.Orders.Attach(customer.Orders.CreateSourceQuery().Include(“Address”))

It’s logical and it works, but it’s awfully convoluted. Two years of futzing with Entity Framework and 300 pages into my book and yet, here is something I have never seen or thought up before. And while it’s a neat trick, it’s still pretty hard to get to.

I much prefer the Load.Include() idea. It’s discoverable and feeds on something we already know how to do. But for now, at least I know how to do it in V1.

There’s so much in V1 and for many scenarios where you think you are stuck, whether it’s with the model or with code, as with Danny’s example, EF and EDM are robust enough that there is generally SOME way to pull it off. But it takes a good understanding of the APIs or someone like Danny sitting by your side to figure some of these things out.

Another great example is Jarek Kowalski’s code to perform transparent Lazy Loading in EF. Lack of lazy loading has been an EF showstopper for some, but it is possible to add it in.

More of this functionality will be hidden under the covers in V2 with much simpler ways to tap into it (at least I”m assuming and counting on this for V2). For now, folks (on the team and in the community) are writing extensions and code to make many tasks easier to perform. Don’t forget to check out the team’s code gallery (http://code.msdn.microsoft.com/adonetefx as well as the www.codeplex.com/EFContrib site.

Matthieu has written a very clever method extension that allows the important eager loading method, Include, to accept a lambda expression (strongly typed) rather than a string for its parameter.

I like this better than my method of ensuring that I type the strings correctly, which is to start entering the parameter without the quotes and let intellisense help me, then add the quotes after the fact.

Here is the actual documentation that covers Include (look under “Query Path” in this topic) if you’re not sure what we’re talking about.