{"id":1657,"date":"2013-06-20T00:00:00","date_gmt":"2013-06-20T00:00:00","guid":{"rendered":"https:\/\/test.simple-talk.com\/uncategorized\/different-approaches-of-entity-framework\/"},"modified":"2021-05-17T18:36:06","modified_gmt":"2021-05-17T18:36:06","slug":"different-approaches-of-entity-framework","status":"publish","type":"post","link":"https:\/\/www.red-gate.com\/simple-talk\/development\/dotnet-development\/different-approaches-of-entity-framework\/","title":{"rendered":"Different Approaches of Entity Framework"},"content":{"rendered":"
\n

\tIn this article I will be describing the three approaches to using Entity Framework (EF) – Model First, Database First and Code First. <\/p>\n

\tI will illustrate how to use these techniques using Entity Framework 5.0, which has several performance improvements and new features which will be highlighted as part of the sample implementation. I will then go on to explain the relative advantages of each approach when designing the database. <\/p>\n

Model First <\/h2>\n

\tIn the Model First approach, the database model is created first using the ORM designer in Visual Studio. Once the model consisting of entities and relationships has been designed, the physical database will be generated from the model. <\/p>\n

Walk through – Creation of Model First<\/h3>\n

\tIn order to create the model, you should create an empty ASP.Net project in Visual Studio and add a new ADO.Net Entity Data Model, which for this example we’ll call ModelSample. <\/p>\n

\t\"1823-0464802d-37b6-4c60-bead-532facdfe9a\"<\/p>\n

\tFigure 1: Add ADO.Net Entity Data Model <\/p>\n

\tThis will open the Entity Data Model Wizard. Select the Empty Model<\/em> from the Model Contents<\/em> selection. <\/p>\n

\t\"1823-edde9c0c-5505-4b9c-8a88-f158dd3f1ca\"<\/p>\n

\tFigure 2: Choose Model Contents <\/p>\n

\tThis loads the entity data model designer. Add Entities from the toolbox to our entity data model designer. Link the entities using the ‘Association from<\/em>‘<\/em> Toolbox to complete the model design. \"1823-67a883f0-a020-44bb-a1c4-070d02e4737\"<\/p>\n

\tFigure 3: Sample designer with entities <\/p>\n

\tNew feature:<\/u> Entity Color. As you can see in the above diagram, we can color the entities appropriately for better understanding and grouping. In our sample, leave<\/strong>-related entities are colored with orange, organization details<\/strong> in purple and the employee details<\/strong> in blue. <\/p>\n

\tOnce the entity model design is completed, generate the database from the model using the ‘Generate <\/em>Database from Model<\/em>‘ context menu. Right-click on the designer to invoke the Context menu, then select the ‘Generate Database from Model<\/em>‘<\/em><\/em>option. <\/p>\n

\t\"1823-b906dac2-e9c9-49eb-bacf-929f4cbdf12\"<\/p>\n

\tFigure 4:Generate Database from Model <\/p>\n

\tSelect an existing database connection or create a new connection to create the sample database from the Model. For this sample, I have used SQLExpress with the SampleDB database connection. <\/p>\n

\t\"1823-f0a97b95-e264-41d2-a2ad-ed85ab8e3b1\"<\/p>\n

\tFigure 5: Choose Data Connection <\/p>\n

\tThis will generate the DDL statements, and the generated script will be added to the solution as a script file. <\/p>\n

\t\"1823-50b9810c-0263-49a4-af90-2dcdac53b1b\"<\/p>\n

\tFigure 6: Specify DDL file name <\/p>\n

\tThe script file generated in the previous step will be opened in Visual Studio. Click ‘Execute<\/em>‘<\/em><\/em>in order to create the database using the generated script. <\/p>\n

\t\"1823-36861ecb-f624-475c-a5e1-65724174280\"<\/p>\n

\tFigure 7: Execute Script <\/p>\n

\tNow, the database with all tables and relationships is created in the database server. For working with the new database, generate the code using the Code Generation Strategy; set this value as “default”. <\/p>\n

\t\"1823-74841862-b32b-468e-b1e2-9c73b624f10\"<\/p>\n

\tFigure 8: code Generation Strategy <\/p>\n

\tThis will generate the entity framework code and database context classes corresponding to the defined model. We can use these new classes from the business layer to perform various database operations. Verify the code generated under the Modelname.Designer.cs file. <\/p>\n

\t\"1823-2c07a2c8-70da-4dd4-9272-72793e7fbdc\"<\/p>\n

\tFigure 9: Designer Code <\/p>\n

\tWe can sync the Model with the database either way using the context menu options – ‘Generate Database from Model<\/em>‘ or ‘Update Model from Database<\/em>‘. You can modify the model and then invoke the ‘Generate database from Model<\/em>‘<\/em> context menu option to update the database schema. Any modification in database schema can get updated to the model using the ‘Update Model from Database<\/em>‘ context menu option. <\/p>\n

\t New feature:<\/u> Multiple-diagrams per single Model. <\/p>\n

\tAnother new feature introduced in EF 5.0 is to allow the use of multiple diagrams for a single model. We can move selected entities to another diagram in order to reduce the complexity of the main diagram. Select the entities by holding shift key and select the “Move to new diagram<\/em>” option from the context menu. <\/p>\n

\t\"1823-3f5fec17-f1bf-421a-a9ab-b8fe2f0ee6c\"<\/p>\n

\tFigure 10: Move to new diagram <\/p>\n

\tLet us move the entities related to leave<\/strong> to another diagram. This will create a new diagram with selected entities; in our case Leave<\/strong> and Leavedetail.<\/strong> <\/p>\n

\t\"1823-3f876a07-e7d2-4f3d-a802-a18c92727fd\"<\/p>\n

\tFigure 11: Multiple diagram for single Model <\/p>\n

\tAs you can see, the relationship between the LeaveDetail<\/strong> entity and the Employee entity has been removed. We can use the new ORM feature to include the related entities in the second diagram by keeping one copy of the same in the first diagram for better readability. We can include the related entities in the second diagram using “Include Related<\/em>” option. This will create a copy of all the related entities in the second diagram. Select the Leavedetai<\/strong>l entity, right-click and select the option “Include Related<\/em><\/strong>” to include the employee entities in the second diagram. <\/p>\n

\t\"1823-49b3d727-222e-412b-8840-327ca2a4afa\"<\/p>\n

\tFigure 12: Include Related <\/p>\n

\t\"1823-1d0fbbe4-647e-4a55-a218-04319d67111\"<\/p>\n

\tFigure 13: Multi-diagram with Include Related <\/p>\n

Database First<\/h2>\n

\tThe next approach supported by the Entity Framework is the database-first approach. In the database first approach, we are creating the entity framework from an existing database. We use all other functionality, such as the model\/database sync and the code generation, in the same way we used them in the Model First approach. <\/p>\n

\tCreate the ADO.Net Entity Data model using the ‘Generate from Databas<\/em>e’<\/em> option. <\/p>\n

\t\"1823-a4516dbd-2382-44f4-9730-52c8b5b2330\"<\/p>\n

\tFigure 14: Choose Model Content <\/p>\n

\tSelect an existing connection or new connection from the ‘choose data connection<\/em>‘<\/em> window. We are using the sampleDB<\/strong> that we created as part of our Model First sample. Now, select the database objects suitable for your project such as Tables, Views and Stored procedures, functions from the ‘Choose your D<\/em>atabase <\/em>O<\/em>bjects<\/em>‘ window. <\/p>\n

\t\"1823-3ca3c42d-af86-4e80-9f37-5dd177233c4\"<\/p>\n

\tFigure 15: Choose database objects <\/p>\n

\tThis will generate the designer with selected entities and associations as shown below. <\/p>\n

\t\"1823-97659c32-d86a-4900-9429-daccea8fa68\"<\/p>\n

\tFigure 16: Entity data model designer <\/p>\n

\tCreate the code using the ‘Code Generation Strategy<\/em>‘<\/em> property, and perform the sync between the database and model in the same way that the Model-first approach works. Any sync back to the database will recreate the database and the existing data will be lost. <\/p>\n

\tNew feature:<\/u> There is now support for Table-valued functions. Before using the SampleDB<\/strong> in the database-first approach, we have added a Table-valued function called UpdateLeave<\/strong> to the database. You’ll notice that the new Table-valued function is added under the Complex Type region inside the Designer.cs file. Support for the Table-valued function has been added as part of Entity Framework 5.0 and is available for the database-first approach only. <\/p>\n

\tNew feature:<\/u> Enum properties. Support for enum<\/strong> properties are added as part of Entity Framework 5.0. Add one Integer property, say Relationship<\/strong> to the entity. Right-click on the property and select the “Convert to Enum<\/em>” option from the context menu. <\/p>\n

\t\"1823-4e094ec4-c534-425e-a20e-52224b9226d\"<\/p>\n

\tFigure 17: Convert to Enum <\/p>\n

\tAdd the enumeration members and values in the ‘Add Enum Type<\/em>‘<\/em> window. <\/p>\n

\t\"1823-fe75a605-09ba-40b0-83e2-da2abb25f85\"<\/p>\n

\tFigure 18: Add Enum Type <\/p>\n

\tInstead of adding each value, we can refer an external type using the ‘Reference external type<\/em>‘<\/em> option. <\/p>\n

\tHere is the generated code for the new Enum added inside the Designer.cs file <\/p>\n

[EdmEnumTypeAttribute(NamespaceName=\"SampleDBModel\", id=\"Relationship\"\")]\n   [DataContractAttribute()]\n   public enum Relationship : int\n   {\n      \/\/\/<summary>\n      \/\/\/No Metadata Documentation available.\n      \/\/\/<\/summary>\n      [EnumMemberAttribute()]\n      Mother=1,\n\t\n      \/\/\/<summary>\n      \/\/\/No Metadata Documentation available.\n      \/\/\/<\/summary>\n      [EnumMemberAttribute()]\n      Father=2,\n\t\n      \/\/\/<summary>\n      \/\/\/No Metadata Documentation available.\n      \/\/\/<\/summary>\n      [EnumMemberAttribute()]\n      Spouse=3,\n\t\n      \/\/\/<summary>\n      \/\/\/No Metadat aDocumentation available.\n      \/\/\/<\/summary>\n      [EnumMemberAttribute()]\n      Child=4\n   }<\/pre>\n
 \tNew feature:<\/u> Support for Geography and Geometry types. Support for the DBGeography and DBGeometry types are added as part of Entity Framework 5.0. <\/p>\n
 \t\"1823-39a8ac8c-b74e-4bc5-805c-3c2a9887258\"<\/p>\n
 \tFigure 19: Geometry & Geography supports <\/p>\n
Code First<\/h2>\n
 \tIn Code-First Approach, we create the classes first and then generate the database from the classes directly. In code first, we won’t use the Entity Designer (for editing .edmx files) at all. <\/p>\n
 \tFirst, create the classes which represent the database table. For this walkthrough I am using the Category and Product classes. <\/p>\n
public class Category\n   {\n      public int CategoryId { get; set; }\n      public string Category { get; set; }\n      public string Description { get; set; }\n   }\n\n   public class Product\n   {\n      public int ProductId { get; set; }\n      public string ProductName { get; set; }\n      public float Price { get; set; }\n      public int CategoryId { get;set;}\n   }<\/pre>\n
 \tNow, define the custom DbContext class derived from DbContext, which defines the classes that need to be converted to database tables. Here, we have defined both category and Product classes to represent as a table. <\/p>\n
public class SampleContext : DbContext\n   {\n      public DbSet<Category> Categories { get; set; }\n      public DbSet<Product> Products { get; set; }\n   }<\/pre>\n
 \tFor performing the CRUD operations, define the data access class with proper methods. Here, we are defining only the SELECT operation, but we’ll need to define different methods for UPDATE, DELETE and SELECT options. <\/p>\n
public class SampleDataAccess\n   {\n      SampleContext  context = new SampleContext();\n      public List<Product> GetProducts()\n      {\n         return (from p in context.Products select p).ToList();\n      }\n   }<\/pre>\n
 \tAdd the connection string to the web.config for accessing the database at run time. <\/p>\n
<add id=\"SampleContext\"\"\n   connectionString=\"datasource=.\\sqlexpress;IntegratedSecurity=SSPI;database=SampleDB\"\n   providerName=\"System.Data.SqlClient\"\/><\/pre>\n
 \tBuild the solution before adding the UI control, GridView, to display the data from the database. Then, add a data source which will point to the SampleDataAccess<\/span> class. Select ‘Object<\/em>‘ from the ‘Choose a Data Source Type<\/em>‘ menu and specify an id for the data source. <\/p>\n
 \t\"1823-bfe4be82-f457-4775-8757-ade353495c2\"<\/p>\n
 \tFigure 20: Choose a Data source type <\/p>\n
 \tSelect the SampleDataAccess<\/strong> class from the list. If it is not displayed here, then the solution may not be built properly. <\/p>\n
 \t\"1823-672c04e1-668f-4793-8078-6d6847c6de7\"<\/p>\n
 \tFigure 21: Choose business object <\/p>\n
 \tSet the methods for the CRUD operation. We have only one method selected called GetProducts()<\/strong>. <\/p>\n
 \t\"1823-8641832a-3da7-4bb6-b47d-24dd2678ebb\"<\/p>\n
 \tFigure 22: Define data methods <\/p>\n
 \tWe can define the Update, Delete and Insert methods in the same way. Here are the tables available under the SampleDB<\/strong> database before running the application. <\/p>\n
 \t\"1823-221320d7-3356-4b8f-a3db-5665046e582\"<\/p>\n
 \tFigure 23: SampleDB before running app <\/p>\n
 \tNow, run the application, which will display a blank page. You’ll see that the new Categories and Products tables are added in the SampleDB database after running the application. <\/p>\n
 \t\"1823-81b5a661-bdae-4372-978e-da1ef195a3b\"<\/p>\n
 \tFigure 24: SampleDB after running the app <\/p>\n
 \tTo try this out, we’ll insert few records to the database and run the application again. <\/p>\n
 \t\"1823-09d6ae1f-0cca-45c7-aa82-6c0250c26c0\"<\/p>\n
 \tFigure 25: Code First output <\/p>\n
Comparing the Model First, Database First and Code First approaches<\/h2>\n
 \tSo when should one choose one method over the others? Here is a simple comparison of the advantages all three approaches. <\/p>\n
Model First: <\/h3>\n