What About EDMX When EF7 Arrives?

I’m getting a lot of folks asking me about the announcement that EF7 will focus on code first and there will be no support in EF7 for designer based EF models.

I’ll give my two cents, even though I do think the EF team has been pretty clear about this in both their blog post about EF7 plans 

EF7 – New Platforms, New Data Stores

and in Rowan Miller’s TechEd talk where he devoted the last 20 minutes to early look at early bits and early thoughts about EF7

Entity Framework: Building Applications with Entity Framework 6

Here’s the scoop: EF6 and the designer will continue to be available and worked on but the big effort will go into EF7 going forward. Personally, I can’t promise it will be around 10 years from now so please don’t bang down my door in 2024.

I’ve also been asked: “should I bother learning about the EDMX since it will not be in EF7?” I firmly believe that learning a bit about modeling via the designer helps get some of the concepts across for if/when you do code first modeling.

Also don’t forget about some of the 3rd party tools that provide designer support such as LLBLGenPro, Huagati Tools,  and DevArt’s Entity Developer. I’m guessing they will be moving their tools forward, though I haven’t looked into it yet.

Capture Screenshots Directly into Camtasia Projects

I spend a lot of time in TechSmith’s Camtasia when I’m building my Pluralsight courses. I’ve been using it for years and am a huge devotee. (disclsure that I get a free licnese as a Microsoft MVP but would willingly pay for it). often decide while editing that an image would be handy. I usually have to go grab a screenshot, save that file. Then import that file into my camtasia project and then put it into my video.

I also happen to use TechSmith’s SnagIt for my screen captures (same disclosure re free license and same but I would pay for it for sure!).

I only just discovered that there are a slew of output extensions for Snagit and one of them is Camtasia.

Here is a 30 second video (that I created in Camtasia of course) of how it works.

Domain-Driven Design Fundamentals Course on Pluralsight

Steve Smith and I are excited to finally have our Domain-Driven Design Fundamentals course available on Pluralsight (http://juliel.me/PS-DDD ) . It was a long haul creating the course but we wanted it to be just right. And coordinating our schedules became tricky since we really wanted to collaborate completely on this, not just divide up the work and sew it together.

We were also grateful to have Eric Evan’s, the “father” of DDD, participate in the course by letting us interview him and use the resulting video clips where he provides thoughtful and insightful advice throughout the course.

The course has now been out for a few weeks and the reception has been great. Good ratings, great feedback in the discussions and on twitter are making us quite proud of our hard work. And it’s has been in Pluralsight’s Top 10 list (based on past 10 days viewing) in the entire library of some [I believe] 1500 courses since a few days after it was released.

If you don’t have a subscription (but really, they are only $29/month), there is a 10 day free trial on the website and I also have 30 day free trial cards I can share. Let us know what you think!


Some DDD+EF Resources

Could not fit this into a tweet in response to a request.

Here are some resources for how EF can be a partner to a Domain Driven Design world:

Video: Oredev, Fall 2013 (by me)

Video: TechEd North America, May 2014 (Vaughn Vernon)
How You Can Implement Aggregates and Domain Entities Effectively in Domain Models, with .NET

Article Series:
MSDN Magazine Data Points Column (by me) Aug, Sept & Oct 2013
Coding for Domain-Driven Design: Tips for Data-Focused Devs, Part 1
Coding for Domain-Driven Design: Tips for Data-Focused Devs, Part 2
Coding for Domain-Driven Design: Tips for Data-Focused Devs, Part 3

Domain modeling with Entity Framework Scorecard (Jimmy Bogard)

Bonus for NHibernate Converts:
And for those who are looking for this by way of moving from DDD + NH, Jimmy Bogard did a great post (with pointers to related posts) on Migrating from NHibernate to EF.

DDD Fundamentals, SOON SOON

imageSteve Smith and I have been working for quite a while on a Domain-Driven Design Fundamentals course for Pluralsight. Our schedules and some interesting, unexpected but quite welcome, learning curves and most importantly, our “go big or go home” desire to refine, clarify and polish everything made this take longer to finish than either of us imagined.

In addition, the demo app that we show and evolve throughout the course – much of which is Steve’s genius – is totally kick-ass!

We are grateful that Eric Evans participated in this by chatting with us on Skype and capturing video to include throughout the course. We also are thankful for some guidance from another DDD guru, Vaughn Vernon.

The course is about 4.5 hours long, broken up into 7 modules.

The course has been done, reviewed, edited and absolutely final…ready to be published but unfortunately, so are many other new courses on Pluralsight. So the DDD Fundamentals is in the queue to get published soon.

Believe me, Steve & I will be tweeting up a storm when this thing finally goes live so watch our blogs or twitter (I’m twitter.com/julielerman, he’s twitter.com/ardalis).

Poking around EF7’s Solution

Of course, I wanted to stop everything and fiddle around with the early bits of EF7. Here’s a look at just getting at EF7 and the source.

EF7 Assemblies on Nuget

EF7 APIs are being built nightly and available via MyGet. You can have NuGet package manager subscribe to the proper feed by adding it into the Package Sources in Visual Studio’s Options UI. I named mine ASPNET EF7 Nightly Myget, although the feed is really for all of ASP.NET. The source url is https://www.myget.org/F/aspnetvnext/api/v2.


With that set up, you can pull from that source from the package manager like so:


Note that I’m using VS2013 and it was necessary to be sure I had the latest NuGet extension installed. I didn’t at first and got an error message (indicating the exact problem about the version) when I was trying to install the packages.

Here are the EF7 assemblies after I’ve filtered on data.entity:


Notice that the assemblies aren’t all in one big entityframework.dll file. You get to pick and choose the assemblies that drive big features e.g., migrations. The rest are for various ways of storing data. If you want EF7 to store data in memory only, then just grab that package. Want to use SQL Server? Grab that package.

I chose Microsoft .Data.Entity and InMemory, but then realized I didn’t know how to use InMemory. So instead, I decided to start over by downloading the full EF7 project along with its tests because I know I can learn a lot from the tests.

A Look at the EntityFramework solution

I went to the Github page for EF7 at https://github.com/aspnet/entityframework and downloaded the ZIP file for the solution.


You’ll find that there are no project files (e.g. csproj) in the solution and you can’t just open it up right away. In fact the solution is very minimal. Instead, each project has a project.json file with information about the dependences of that project. Here, for example, is the project.json file for the functional tests project of the solution:



In the downloaded files, you’ll find a “build.cmd” file in the root folder. This calls another powershell file which will run through the projects, grab all of the necessary assemblies from NuGet and create the relevant csproj files for all of the projects. I’m sure it does plenty more as well.

After this is completed, open the solution and you’ll find that the Entity Framework source code has two sets of projects. One set targeted at Project K which supports projects in a lightweight manner via NuGet, the other targeted at .NET 4.5. If you look at the references in the K10 projects, you’ll find that they all point to assemblies that are in your project folders. In other words, every one of them is a NuGet package downloaded into your project. Even System.Runtime and System.Linq.


In the .NET 4.5 projects, you’ll find a mix of NuGet files (e.g. System.Data.Entity) and core .NET assemblies that are coming from the GAC.


The tests however are all .NET 4.5 based.

Here is an overview of what’s in the full solution: both sets of EntityFramework projects (InMemory, Entity, Migrations, Relational, SQLite and SqlServer). And a set of unit tests and functional tests for each of those projects:


The sun has come out so time to go! More to come though!

Oh, one last thing before I bolt. I found this amusing bit of test data in the tests:

customer.name = "Unikorn, The Return";

Highlights of Rowan Miller’s EF6/EF7 Talk at TechEd 2014

Yesterday afternoon, Channel 9 chose to broadcast the Entity Framework session presented by Rowan Miller, a Program Manager on the EF team at Microsoft. Rowan is an excellent presenter and the session was a 400 level, demo-heavy session. And it was awesome!

While the abstract promised an advanced demo-heavy session showing off features of EF6 (including the latest rev, EF6.1), Rowan also showed off some of the new functionality that will be coming in EF7.

Here are some of the highlights of his session.

The first part of the session dug into demos that showed off how you can combine features of EF6 to implement functionality that many developers would like to achieve in their applications.

The demos also used the recently released EF6.1 which has over 120 bug fixes plus a handful of new features. EF 6.1.1 is a patch release that is coming out soon. It is mostly bug fixes and some critical fixes to performance regressions that were introduced with EF 6.0.2.

The first of these was “soft deletes”, in other words for all intents & purposes, when you delete a record it is gone from the application. But it is not removed from the database. Rather than having to mark a record as “don’t show this to me again” and always include filtering in queries, Rowan showed how you can get Entity Framework to take care of these tasks in the background.  He combined the use of

  • Custom Conventions
  • Mapping Data Annotations to Custom Conventions
  • Command interceptors (for queries and change commands)
  • CommandTree Interceptor (in 6.1)

Here’s a slide where he laid out how he would pull off the whole thing:image



Next,Rowan demonstrated how you can enforce Entity Framework to automatically perform full text searches. This meant that first the database needed to have Full Text search implemented. Rowan used EF6’s Custom Migrations feature (a community contribution to EF6 Smile ) to ensure that EF migrations would change the database to have full text search enabled. Next was to change how EF queries are translated to SQL queries. This was a much trickier bit of code that benefited from the fact that with EF 6.1, the Mappng API was exposed so that we could code against it directly. The team was a little reluctant to expose that API only because it’s older EF code and quite a bit messier to work with than they would like. SO they do plan to clean it up but in the meantime, at least we have access to it. Smile

The final EF6 demo showed how to leverage the support for using Mocking frameworks more easily in EF6. In addition, Rowan has created his own APIs (not an official part of EF) to help even more (mocking DbSets is hard!) so he used his EntityFramework.Testing API in his demo.


And then…..EF7 (sneak peek).

So the team has started working on EF7. It is a work in progress and open-source. You can find it at github.com/aspnet/entityframework .

EF will undergo a “sea change” with this version. It is time to shed some of the 8 year old code in the APIs that is making it harder and harder for the team to evolve Entity Framework. EF6 will continue to evolve but for how long and to what degree, it’s hard to say. (My words, not Rowan’s). EF7 will absolutely introduce breaking changes. BUt the most important patterns, e.g., basic DbContext interaction, will remain in tact.

Rowan demo’d two exciting features they are working on in EF7 so far.

The first is the ability to leverage your existing knowledge of EF to interact with NoSQL databases. An important note he made was that EF will not try to whitewash the type of data store that it’s connecting to. There will be functionality that pertains to relational that may not also pertain to NoSQL and vice versa. But basic CRUD operations, change tracking etc will be familiar if you’re already used to how EF works.

The other demo was working on a Windows Phone app where the app was able to persist data on the phone using Entity Framework (to a SQLite database).

This is of course, all *very* early stuff.

Rowan was clearly very exicted to share the EF7 demos, but the EF6 demos were equally impressive.

Plus he is a natural as a presenter. It was a pleasure to watch his presentation.

You can see it yourself here:

The Channel9 page for this session is here: Entity Framework: Building Applications with Entity Framework 6