Code First Approach using Entity Framework 4.1, Inversion of Control, Unity Framework, Repository & Unit of Work Pattern and MVC3 Razor View

1. CodeFirstData layer :

2. CodeFirstEntities layer:

3. CodeFirstServices layer:

4. MVCPortal layer:

1. Model / Viewmodel:

2. Views :

3. Controllers :

                                                                            ( fig3 )

100. DataBase Factory:

500. RepositoryBase – The Generic Entity Repository base class :
     
     
     
     
     
     Above is the repository base class that contains all the methods to be implemented for CRUD DB operations, we can define more of our generic methods here, for now considering our application, these are eough for proper understanding of the working.
     E. Unit of Work
     The Unit of Work pattern maintains a list of objects affected by a business transaction and coordinates the writing out of changes and the resolution of concurrency problems.We create a class for handling Unit of Work pattern,
     Interface :
     
     
     
     
     
     Class :
     
     
     
     
     
     
     
     The Commit method written in of the UnitOfWork will call the commit method of our Context class and it will execute the SaveChanges method of DbContext class.
     II ) Repository :
     In this article, we will be primarily focus on the persistence against Student entity . Let’s create a repository for handling CRUD operations for Student
     using derive from a generic Repository EntityRepositoryBase.
     Repository class for Student :
     Interface :
     
     Class :
     
     
     
      

1. We start with home Controller, as it is the default controller set in global.asax to be called first.

When the Index action of the controller is called we redirect it to our Student Controller,which straight away returns view to show listy of students if exist,since its first time we are creating the controller,it shows an empty list, the controller method of Student fetches student list from database , but first it creates the database, thus acheiving our objective.
1. We create Student Controller, We define actions in the controller for each operation we want to perform as follows,

3. We Create Views for every Action,Its easy if we right click the controller action and create view,It automatically create a view with a Default folder named in the name of Constructor,So we can create all the views for our operations, and our solution looks like,
   
   4. Now we are ready with our application to be executed,keep your fingers crossed and see the magic, I have used _layout as master page to give some meaningful look and feel to my application,U can customize the same.When u run the application by pressing F5, We get redirected to the Index view of Student Controller,which shows list of students,since we are running it first time,we dont have existing list, and our application shows,
   
   
   
   
   
   
   
   5. No wonder , just have a look at your DataBase, My case I am using Sql Server 2008,
      
      
      
      
      
      I got a Database created automativcally with the name CodeFirstApp having Student Table, Now you can cross verify the table with your entity,its the same.So we have hit the target and our database is successfully created.
      6. Further Operations :
      You can now test the application and perform further CRUD operations in the application and see the DataBase getting updated.e.g. Create Student,
      
      
      
      
      
      after Submit by pressing Create, we get,
      
      
      
      
      
      therefore one student created.
      We can edit the same student by pressing edit link , we get the view,
      
      
      
      
      
      Likewise we can see the details of already created student,
      
      
      
      
      
      and delete the student will redirect to ,
      
      
      
      
      
      I had created 3 students in the same manner, You can create more and play with the application.
      
      
      
      Risk Factor : There is also a Risk Factor in implementing EntityFramework, If we do any change in the entity, like deleting,changing property,The context will drop and recreate the database, which may clearly lead to loss of your existing data.To avoid this critical situation, we code some more, we call SetInitializer method of DataBase class and set it to null in our dataBase Factory Class.
      usingSystem.Data.Entity;
      namespaceCodeFirstData.DBInteractions
      {
      publicclassDBFactory: Disposable, IDBFactory
      {
      publicDBFactory()
      {
      Database.SetInitializer<CodeFirstContext>(null);
      }
      privateCodeFirstContextdataContext;
      publicCodeFirstContextGet()
      {
      returndataContext ?? (dataContext = newCodeFirstContext());
      }
      protectedoverridevoidDisposeCore()
      {
      if(dataContext != null)
      dataContext.Dispose();
      }
      }
      }
      Database class is from namespace System.Data.Entity, whcih provides such feature.
      Conclusion :
      In this article we discussed about creating an application using EntityFramework 4.1 Code First Approach, We used Inversion of control and Dependency Injection to Resolve Dependency between layers.We used MVC 3 razor view engine as our UI and integrated the layers to acheive our objective.The application was a description of simple CRUD operations on Database.We learned how to use Repository Pattern,Unit of Work pattern and Unity Framework.You can download the codebase and further enhance/extend it according to your need.Happy Coding.
      
      
      Learn Complete MVC Step by Step:

      • Part1: Introduction to MVC architecture and Separation of Concerns. 
      • Part 2: Creating MVC Application from scratch and connecting it with database using LINQ to SQL. 
      • Part 3: Connecting the MVC Application with the help of EntityFramework DB-First approach. 
      • Part 4: Connecting the MVC Application with the help of EntityFramework Code-First approach. 
      • Part 5: Implementing Repository Pattern in MVC Application with EntityFramework. 
      • Part 6: Implementing a Generic Repository Pattern and Unit Of Work pattern in MVC Application with EntityFramework.  

      
      

      Articles : http://www.codeproject.com/script/Articles/BlogFeedList.aspx?amid=7869570