That being said, your construct is dangerous from a defered execution perspective in that it is easy for the expression tree to evaluate each of the variables you are adding in on your loop as a reference back to the same underlying value. Because of this, VB actually provides a compiler warning to keep you from using variables like this inside of your loops. Instead, create a local place holder and refer to that when using foreach loops. It doesn’t factor as much if you use indexed arrays as you did in your example. However, if you use a local variable, both LINQ to SQL and EF will perform the same way and you avoid the potential for defered execution errors. See if the following modification to your code works with EF for you.

using( var data = new LinqToEntities() )
{
var names = new[] { “Alice”, “Bob”, “Dummy” };

for( var i = 0; i < names.Length; ++i )
{
string Name = names[i};
var customers = from c in data.Customers
where c.Name == Name
select c;

// Do something with the customers found.
}
}

I don’t really know if I’d call these examples of the EF “failures”. Understanding that the EF was developed by the ADO team and L2S by the language team, it was probably inevitable that these inconsistencies would crop up.

What I think is the real shame here is that MS seems to want to “obsolete” L2S in favor of the EF. Why? Instead, why not bring both under the purview of the ADO team, cross-port the best concepts from both projects, iron out the inconsistencies with things like deferred loading, and keep both? I do believe the EF has its place, but as the article points out, L2S is an awesome, lightweight framework that is probably better suited to the majority of non enterprise-level projects.

I see no reason why I should abandon NHibernate for the Entity Framework and I can’t see how Entity Framework will ever be able to catch up when I haven’t heard anyone (outside of the EF team) say anything good about it.

Imagine where we would be now if they EF team had instead spent their time improving NHibernate or LINQ to SQL instead of building EF?

I was one of those, like many others, who thought the EF was going to be really, really revolutionary. While I always kinda understood that L2S was the “dime-bag” to get us all hooked on LINQ and therefore buy straight into the EF, what I have come to realize in the course of this current project is that for probably 90% of projects, the Entity Framework is the equivalent of watering a houseplant with a firehose. Just too much. In these cases, L2S is just the kind of lightweight, easy-to-handle framework you need.

To be fair, the lack of support for implicit deferred loading is not such a big deal. A lot of folks actually prefer the EF way; having gripes with the way L2S does it, saying that they don’t like the fact the L2S issues db calls behind the scenes — though I would answer that really, why should you *care* when the data gets fetched, as long as it does? But ultimately, implicit vs. explicit deferred loading is kind of a potato-potahto thing. There are good arguments for both. I, however, do agree that it’d be nice if they would just pick one direction and go with it.

I wholeheartedly agree with the rest of your points though. I suppose the only consolation is that Microsoft seems pretty committed to the EF and that it should improve over time. We shall see.

Product chai = db.Products.Where(p => p.ProductName == “Chai”).Single();
chai.CategoryID = 1;
db.SubmitChanges();

Will not work, if CategoryID is a foreign key into the category table. Instead, in order to set the category of an object, you must actually waste time with another database call to retrieve the category object, and then set it:

Product chai = db.Products.Where(p => p.ProductName == “Chai”).First();
Category beverages = db.Categories.Where(c => c.CategoryName == “Beverages”).First();
chai.Category = beverages;

Unbelievable.

There are many blogs out there which seem to show that the SQL queries that EF generates are remarkably slower than L2S queries as well. I haven’t tried this out for myself, but it wouldn’t surprise me. If MS decides that L2S is dead, we may just have to reverse engineer it and make it ourselves. EF is a complete joke.