The document discusses Entity Framework (EF) and code first modeling. It describes the role of entities as conceptual models that map to physical databases. It introduces the entity data model (EDM) as a client-side class model mapped to the database via EF conventions. It describes the DbContext class as representing a unit of work and repository pattern to query and save data. DbSet properties are added to expose database tables. Navigation properties allow modeling relationships. Loading strategies like lazy, eager, and explicit loading are discussed. The document shows how to generate a model from an existing database and make modifications via data annotations. It provides examples of CRUD operations using EF and LINQ queries. Finally, it outlines creating an empty code first model by

1. Entity Framework
(EF)
Eng. Mahmoud Ouf
Lecture 2
mmouf@2017

2. Role of Entities
Entities are a conceptual model of a physical database that maps to your
business domain.
This model is termed an entity data model (EDM).
The EDM is a client-side set of classes that are mapped to a physical
database by Entity Framework convention and configuration.
The entities did not map directly to the database schema in so far as
naming conventions go.
You are free to restructure your entity classes to fit your needs, and the
EF runtime will map your unique names to the correct database schema.
mmouf@2017

3. The Role of the DbContext Class
The DbContext class represents a combination of the Unit of Work and
Repository patterns that can be used to query from a database and group
together changes that will be written back as a single unit of work.
DbContext provides a number of core services to child classes,
including
 The ability to save all changes (which results in a database update),
 Tweak the connection string, delete objects, call stored procedures,
 Handle other fundamental details
Create a class that derives from DbContext for your specific domain.
In the constructor, pass the name of the connection string for this
context class to the base class
mmouf@2017

4. The Role of DbSet<T>
To add tables into your context, you add a DbSet<T> for each table in
your object model.
To enable lazy loading, the properties in the context need to be virtual.
Ex: public virtual DbSet<Customer> Customers { get; set; }
Each DbSet<T> provides a number of core services to each collection,
such as creating, deleting, and finding records in the represented table.
mmouf@2017

5. The Role Navigation Properties
As the name suggests, navigation properties allow you to capture JOIN
operations in the Entity Framework programming model
To account for these foreign key relationships, each class in your model
contains virtual properties that connect your classes together
Ex: public virtual ICollection<Order> Orders { get; set; }
mmouf@2017

6. Lazy, Eager, and Explicit Loading
There are three ways that EF loads data into models. Lazy and Eager
fetching are based on settings on the context, and the third, Explicit, is
developer controlled.
Lazy Loading
The virtual modified allows EF to lazy load the data. This means that EF
loads the bare minimum for each object and then retrieves additional
details when properties are asked for in code.
Eager Loading
Sometimes you want to load all related records.
mmouf@2017

7. Lazy, Eager, and Explicit Loading
Explicit Loading
Explicit loading loads a collection or class that is referenced by a
navigation property.
By default, it is set to Lazy Loading and we can re-enable it by:
context.Configuration.LazyLoadingEnabled = true;
To use Eager loading, set the LazyLoadingEnabled = false;
To use Explicit loading, use the Load method
mmouf@2017

8. Code First from Existing Database
Generating the Model
1. Create the solution for new application
2. (R.C.)Project=> Add New Item =>Select ADO.NET Entity Data
Model
3. Then choose Add. This will launch the “ADO.NET Entity Data
Model” Wizard
4. The wizard has 4 template:
1. EF Designer from Database
2. Empty EF Designer Model
3. Empty Code First Model
4. Code First from Database
5. Choose “Code First From Database”
mmouf@2017

9. Code First from Existing Database
new classes in your project:
one for each table that you selected in the wizard
one named ……Entities (the same name that you entered in the first
step of the wizard).
By default, the names of your entities will be based on the original
database object names; however, the names of entities in your
conceptual model can be anything you choose.
You can change the entity name, as well as property names of the entity,
by using special .NET attributes referred to as data annotations.
You will use data annotations to make some modifications to your
model.
mmouf@2017

10. Code First from Existing Database
Data annotations:
Data annotations are series of attributes decorating the class and properties in
the class
They instruct EF how to build your tables and properties when generating the
database.
They also instruct EF how to map the data from the database to your model
classes.
At the class level, the Table attribute specifies what table the class maps to.
At the property level, there are two attributes in use.
The Key attribute, this specifies the primary key for the table.
The StringLength attribute, which specifies the string length when generating
the DDL for the field. This attribute is also used in validations,
mmouf@2017

11. Code First from Existing Database
Changing the default mapping
The [Table("Inventory")] attribute specifies that the class maps to the
Inventory table. With this attribute in place, we can change the name of
the class to anything we want.
Change the class name (and the constructor) to Car.
In addition to the Table attribute, EF also uses the Column attribute.
By adding the [Column("PetName")] attribute to the PetName property,
we can change the name of the property to CarNickName.
mmouf@2017

12. Code First from Existing Database
Insert a Record (example)
private static int AddNewRecord()
{
// Add record to the Inventory table of the AutoLot database.
using (var context = new AutoLotEntities())
{
// Hard-code data for a new record, for testing.
var car = new Car() { Make = "Yugo", Color = "Brown",
CarNickName="Brownie"};
context.Cars.Add(car);
context.SaveChanges();
}
return car.CarId;
}
mmouf@2017

13. Code First from Existing Database
Selecting Record (example)
private static void PrintAllInventory()
{
using (var context = new AutoLotEntities())
{
foreach (Car c in context.Cars)
{
Console.WriteLine(“Name: “+ c.CarNickName);
}
}
}
mmouf@2017

14. Code First from Existing Database
Query with LINQ (example)
private static void PrintAllInventory()
{
using (var context = new AutoLotEntities())
{
foreach (Car c in context.Cars.Where(c => c.Make == "BMW"))
{
WriteLine(c);
}
}
}
mmouf@2017

15. Code First from Existing Database
Deleting Record (example)
private static void RemoveRecord(int carId)
{
// Find a car to delete by primary key.
using (var context = new AutoLotEntities())
{
Car carToDelete = context.Cars.Find(carId);
if (carToDelete != null)
{
context.Cars.Remove(carToDelete);
context.SaveChanges();
}
}
}
mmouf@2017

16. Code First from Existing Database
Updating Record (example)
private static void UpdateRecord(int carId)
{
using (var context = new AutoLotEntities())
{
Car carToUpdate = context.Cars.Find(carId);
if (carToUpdate != null)
{
carToUpdate.Color = "Blue";
context.SaveChanges();
}
}
}
mmouf@2017

17. Empty Code First Model
Create the solution for new application
(R.C.)Project=> Manage NuGet Packages
From “Browse” tab, select “Entity Framework” then “Install”
Add the Model classes (class that will be mapped to a table)
mmouf@2017

18. Empty Code First Model
Add the Model classes
Add files named: Customer.cs, Inventory.cs, Order.cs
In the Inventory.cs, change the class to “public partial”
Add the following namespaces (for using Data Annotation):
• System.ComponentModel.DataAnnotations
• System.ComponentModel.DataAnnotations.Schema
mmouf@2017

19. Empty Code First Model
Inventory.cs
public partial class Inventory
{
public int CarId { get; set; }
public string Make { get; set; }
public string Color { get; set; }
public string PetName { get; set; }
}
Then add the Data Annotation
mmouf@2017

20. Empty Code First Model
Inventory.cs
[Table("Inventory")]
public partial class Inventory
{
[Key]
public int CarId { get; set; }
[StringLength(50)]
public string Make { get; set; }
[StringLength(50)]
public string Color { get; set; }
[StringLength(50)]
public string PetName { get; set; }
}
mmouf@2017

21. Empty Code First Model
Add the navigation properties
[Table("Inventory")]
public partial class Inventory
{
[Key]
public int CarId { get; set; }
[StringLength(50)]
public string Make { get; set; }
[StringLength(50)]
public string Color { get; set; }
[StringLength(50)]
public string PetName { get; set; }
public virtual ICollection<Order> Orders { get; set; } = new HashSet<Order>();
}
mmouf@2017

22. Empty Code First Model
Customer.cs
public partial class Customer
{
[Key]
public int CustId { get; set; }
[StringLength(50)]
public string FirstName { get; set; }
[StringLength(50)]
public string LastName { get; set; }
[NotMapped]
public string FullName => FirstName + " " + LastName;
public virtual ICollection<Order> Orders { get; set; } = new HashSet<Order>();
}
mmouf@2017

23. Empty Code First Model
Order.cs
public partial class Order
{
[Key, Required, DatabaseGenerated(DatabaseGeneratedOption.Identity)]
public int OrderId { get; set; }
[Required]
public int CustId { get; set; }
[Required]
public int CarId { get; set; }
[ForeignKey("CustId")]
public virtual Customer Customer { get; set; }
[ForeignKey("CarId")]
public virtual Inventory Car { get; set; }
}
mmouf@2017

24. Empty Code First Model
Adding the DbContext
(R.C.)The Project=> Add=> New Item=> ADO.NET Entity Data Model
Select “Empty Code First Model”
Update the *.config file and EF connection string
<add name="AutoLotConnection" connectionString="data
source=.SQLEXPRESS2014;initial catalog=AutoLot2;integrated
security=True;MultipleActiveResultSets=True;App=EntityFramework"
providerName="System.Data.SqlClient" />
mmouf@2017

25. Empty Code First Model
The DbContext file
The constructor for your derived DbContext class passes the name of the
connection string to the base DbContext class.
Open the .cs:
add the connection string to the constructor
add a DbSet for each of the model classes.
• public virtual DbSet<Customer> Customers { get; set; }
• public virtual DbSet<Inventory> Inventory { get; set; }
• public virtual DbSet<Order> Orders { get; set; }
mmouf@2017