Entity Framework 6

https://learn.microsoft.com/en-us/ef/ef6
Admin
Entity Framework 6 (EF6) is a mature object-relational mapper (O/RM) for .NET that enables...
Tokens:250,271
Snippets:1,906
Trust Score:10
Update:6 hours ago
Show doc for...
Tokens:
Raw
### install.ps1 for SQL Compact provider

Source: https://learn.microsoft.com/en-us/ef/ef6/fundamentals/providers/provider-model

Example install.ps1 script that uses Add-EFDefaultConnectionFactory and Add-EFProvider to register the SQL Compact provider in the project's configuration file. These commands are intended to be called from the NuGet install script.

```powershell
param($installPath, $toolsPath, $package, $project)
Add-EFDefaultConnectionFactory $project 'System.Data.Entity.Infrastructure.SqlCeConnectionFactory, EntityFramework' -ConstructorArguments 'System.Data.SqlServerCe.4.0'
Add-EFProvider $project 'System.Data.SqlServerCe.4.0' 'System.Data.Entity.SqlServerCompact.SqlCeProviderServices, EntityFramework.SqlServerCompact'
```

--------------------------------

### Install Latest EntityFramework Preview

Source: https://learn.microsoft.com/en-us/ef/ef6/fundamentals/install

Run this command to install the latest prerelease version of EntityFramework. If no prerelease versions are available, the latest fully supported version is installed.

```powershell
Install-Package EntityFramework -Pre
```

--------------------------------

### Example Blog Entity Class

Source: https://learn.microsoft.com/en-us/ef/ef6/modeling/code-first/fluent/cud-stored-procedures

The Blog class used as an example for demonstrating stored procedure configuration.

```csharp
public class Blog  
{  
  public int BlogId { get; set; }  
  public string Name { get; set; }  
  public string Url { get; set; }  
}
```

--------------------------------

### Using ChangeTracker.Entries to inspect tracked entities

Source: https://learn.microsoft.com/en-us/ef/ef6/querying/local-data

This example loads blogs, authors, and readers into the context, makes changes, and then uses ChangeTracker.Entries() to display the state of all tracked entities, find modified entities, get information about tracked blogs, and find all people implementing IPerson. It requires the Author, Reader, and IPerson classes defined in the following snippet.

```csharp
using (var context = new BloggingContext())
{
    // Load some entities into the context
    context.Blogs.Load();
    context.Authors.Load();
    context.Readers.Load();

    // Make some changes
    context.Blogs.Find(1).Title = "The New ADO.NET Blog";
    context.Blogs.Remove(context.Blogs.Find(2));
    context.Authors.Add(new Author { Name = "Jane Doe" });
    context.Readers.Find(1).Username = "johndoe1987";

    // Look at the state of all entities in the context
    Console.WriteLine("All tracked entities: ");
    foreach (var entry in context.ChangeTracker.Entries())
    {
        Console.WriteLine(
            "Found entity of type {0} with state {1}",
            ObjectContext.GetObjectType(entry.Entity.GetType()).Name,
            entry.State);
    }

    // Find modified entities of any type
    Console.WriteLine("\nAll modified entities: ");
    foreach (var entry in context.ChangeTracker.Entries()
                              .Where(e => e.State == EntityState.Modified))
    {
        Console.WriteLine(
            "Found entity of type {0} with state {1}",
            ObjectContext.GetObjectType(entry.Entity.GetType()).Name,
            entry.State);
    }

    // Get some information about just the tracked blogs
    Console.WriteLine("\nTracked blogs: ");
    foreach (var entry in context.ChangeTracker.Entries<Blog>())
    {
        Console.WriteLine(
            "Found Blog {0}: {1} with original Name {2}",
            entry.Entity.BlogId,  
            entry.Entity.Name,
            entry.Property(p => p.Name).OriginalValue);
    }

    // Find all people (author or reader)
    Console.WriteLine("\nPeople: ");
    foreach (var entry in context.ChangeTracker.Entries<IPerson>())
    {
        Console.WriteLine("Found Person {0}", entry.Entity.Name);
    }
}
```

--------------------------------

### Install EntityFramework via Package Manager Console

Source: https://learn.microsoft.com/en-us/ef/ef6/fundamentals/install

Run this command in the Package Manager Console to install the latest fully supported EntityFramework NuGet package.

```powershell
Install-Package EntityFramework
```

--------------------------------

### Expected output from ChangeTracker.Entries example

Source: https://learn.microsoft.com/en-us/ef/ef6/querying/local-data

This is the output produced by running the change tracking example with the given database data. It shows the state of all tracked entities, modified entities, tracked blogs with original names, and people found.

```text
All tracked entities:
Found entity of type Blog with state Modified
Found entity of type Blog with state Deleted
Found entity of type Blog with state Unchanged
Found entity of type Author with state Unchanged
Found entity of type Author with state Added
Found entity of type Reader with state Modified

All modified entities:
Found entity of type Blog with state Modified
Found entity of type Reader with state Modified

Tracked blogs:
Found Blog 1: The New ADO.NET Blog with original Name ADO.NET Blog
Found Blog 2: The Visual Studio Blog with original Name The Visual Studio Blog
Found Blog 3: .NET Framework Blog with original Name .NET Framework Blog

People:
Found Person John Doe
Found Person Joe Bloggs
Found Person Jane Doe
```

--------------------------------

### Install native images for EF6 SQL Server provider

Source: https://learn.microsoft.com/en-us/ef/ef6/fundamentals/performance/ngen

Run these commands in an administrator Command Prompt to generate native images for EntityFramework.SqlServer.dll. This also installs native images for the main EF runtime assembly because NGen.exe detects EntityFramework.dll as a direct dependency in the same directory.

```batch
cd <Solution directory>\packages\EntityFramework.6.0.2\lib\net45
%WINDIR%\Microsoft.NET\Framework\v4.0.30319\ngen install EntityFramework.SqlServer.dll
%WINDIR%\Microsoft.NET\Framework64\v4.0.30319\ngen install EntityFramework.SqlServer.dll
```

--------------------------------

### Implement Main method to insert and query Blogs

Source: https://learn.microsoft.com/en-us/ef/ef6/modeling/code-first/workflows/existing-database

Creates a BloggingContext, prompts for a blog name, saves a new Blog, then queries and displays all Blogs ordered by Name. Run the application to test it.

```csharp
class Program
{
    static void Main(string[] args)
    {
        using (var db = new BloggingContext())
        {
            // Create and save a new Blog
            Console.Write("Enter a name for a new Blog: ");
            var name = Console.ReadLine();

            var blog = new Blog { Name = name };
            db.Blogs.Add(blog);
            db.SaveChanges();

            // Display all Blogs from the database
            var query = from b in db.Blogs
                        orderby b.Name
                        select b;

            Console.WriteLine("All blogs in the database:");
            foreach (var item in query)
            {
                Console.WriteLine(item.Name);
            }

            Console.WriteLine("Press any key to exit...");
            Console.ReadKey();
        }
    }
}
```

--------------------------------

### Pass parameters to stored procedure with DbSet.SqlQuery

Source: https://learn.microsoft.com/en-us/ef/ef6/querying/raw-sql

Pass parameters to a stored procedure using positional parameters like @p0. The example calls dbo.GetBlogById with a parameter and uses Single() to get one result.

```csharp
using (var context = new BloggingContext())
{
    var blogId = 1;

    var blogs = context.Blogs.SqlQuery("dbo.GetBlogById @p0", blogId).Single();
}
```

--------------------------------

### Sample console output after running the application

Source: https://learn.microsoft.com/en-us/ef/ef6/modeling/code-first/workflows/existing-database

Expected output when running the application: prompts for a blog name, then displays all blogs in alphabetical order, and waits for a key press.

```text
Enter a name for a new Blog: ADO.NET Blog
All blogs in the database:
.NET Framework Blog
ADO.NET Blog
The Visual Studio Blog
Press any key to exit...
```

--------------------------------

### Install native image for 64-bit architecture

Source: https://learn.microsoft.com/en-us/ef/ef6/fundamentals/performance/ngen

Run this command in an administrator Command Prompt to generate a native image for 64-bit architecture. Replace <Assembly name> with the assembly name.

```cmd
%WINDIR%\Microsoft.NET\Framework64\v4.0.30319\ngen install <Assembly name>  
```

--------------------------------

### Using an external transaction with Database.UseTransaction

Source: https://learn.microsoft.com/en-us/ef/ef6/saving/transactions

Complete example that starts a transaction on an existing SqlConnection, executes a SQL command, then uses the same transaction with a DbContext via Database.UseTransaction. The contextOwnsConnection flag is false, and the transaction is committed manually.

```csharp
using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Data.SqlClient;
using System.Linq;
using System.Transactions;

namespace TransactionsExamples
{
     class TransactionsExample
     {
        static void UsingExternalTransaction()
        {
            using (var conn = new SqlConnection("..."))
            {
               conn.Open();

               using (var sqlTxn = conn.BeginTransaction(System.Data.IsolationLevel.Snapshot))
               {
                   var sqlCommand = new SqlCommand();
                   sqlCommand.Connection = conn;
                   sqlCommand.Transaction = sqlTxn;
                   sqlCommand.CommandText =
                       @"UPDATE Blogs SET Rating = 5" +
                        " WHERE Name LIKE '%Entity Framework%'";
                   sqlCommand.ExecuteNonQuery();

                   using (var context =  
                     new BloggingContext(conn, contextOwnsConnection: false))
                    {
                        context.Database.UseTransaction(sqlTxn);

                        var query =  context.Posts.Where(p => p.Blog.Rating >= 5);
                        foreach (var post in query)
                        {
                            post.Title += "[Cool Blog]";
                        }
                       context.SaveChanges();
                    }

                    sqlTxn.Commit();
                }
            }
        }
    }
}
```

--------------------------------

### Program.cs - Main method using BlogContext

Source: https://learn.microsoft.com/en-us/ef/ef6/modeling/code-first/migrations/automatic

Updates Program.cs to use the BlogContext for data access, adding a blog and printing all blogs. Running the application creates the MigrationsAutomaticCodeDemo.BlogContext database.

```csharp
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;

    namespace MigrationsAutomaticDemo
    {
        class Program
        {
            static void Main(string[] args)
            {
                using (var db = new BlogContext())
                {
                    db.Blogs.Add(new Blog { Name = "Another Blog " });
                    db.SaveChanges();

                    foreach (var blog in db.Blogs)
                    {
                        Console.WriteLine(blog.Name);
                    }
                }

                Console.WriteLine("Press any key to exit...");
                Console.ReadKey();
            }
        }
    }
```

--------------------------------

### Install native image for 32-bit architecture

Source: https://learn.microsoft.com/en-us/ef/ef6/fundamentals/performance/ngen

Run this command in an administrator Command Prompt to generate a native image for 32-bit architecture. Replace <Assembly name> with the assembly name.

```cmd
%WINDIR%\Microsoft.NET\Framework\v4.0.30319\ngen install <Assembly name>  
```

--------------------------------

### SQL script to create Blogs and Posts tables and insert sample data

Source: https://learn.microsoft.com/en-us/ef/ef6/fundamentals/disconnected-entities/self-tracking-entities/walkthrough

This SQL script creates the Blogs and Posts tables with primary and foreign key constraints, and inserts sample data. It is used to set up the STESample database for the walkthrough. The script includes IDENTITY_INSERT for the Blogs table and inserts two posts.

```sql
    CREATE TABLE [dbo].[Blogs] (
        [BlogId] INT IDENTITY (1, 1) NOT NULL,
        [Name] NVARCHAR (200) NULL,
        [Url]  NVARCHAR (200) NULL,
        CONSTRAINT [PK_dbo.Blogs] PRIMARY KEY CLUSTERED ([BlogId] ASC)
    );

    CREATE TABLE [dbo].[Posts] (
        [PostId] INT IDENTITY (1, 1) NOT NULL,
        [Title] NVARCHAR (200) NULL,
        [Content] NTEXT NULL,
        [BlogId] INT NOT NULL,
        CONSTRAINT [PK_dbo.Posts] PRIMARY KEY CLUSTERED ([PostId] ASC),
        CONSTRAINT [FK_dbo.Posts_dbo.Blogs_BlogId] FOREIGN KEY ([BlogId]) REFERENCES [dbo].[Blogs] ([BlogId]) ON DELETE CASCADE
    );

    SET IDENTITY_INSERT [dbo].[Blogs] ON
    INSERT INTO [dbo].[Blogs] ([BlogId], [Name], [Url]) VALUES (1, N'ADO.NET Blog', N'blogs.msdn.com/adonet')
    SET IDENTITY_INSERT [dbo].[Blogs] OFF
    INSERT INTO [dbo].[Posts] ([Title], [Content], [BlogId]) VALUES (N'Intro to EF', N'Interesting stuff...', 1)
    INSERT INTO [dbo].[Posts] ([Title], [Content], [BlogId]) VALUES (N'What is New', N'More interesting stuff...', 1)

```

--------------------------------

### Example of a proxy type name

Source: https://learn.microsoft.com/en-us/ef/ef6/fundamentals/proxies

Proxy types have names like System.Data.Entity.DynamicProxies.Blog_5E43C6C196972BF0754973E48C9C941092D86818CD94005E9A759B70BF6E48E6. This is shown as an example of the naming pattern.

```text
System.Data.Entity.DynamicProxies.Blog_5E43C6C196972BF0754973E48C9C941092D86818CD94005E9A759B70BF6E48E6
```

--------------------------------

### Define initial model classes with ProductContext and entities

Source: https://learn.microsoft.com/en-us/ef/ef6/modeling/code-first/conventions/custom

Defines the initial model used to demonstrate custom conventions. Includes ProductContext with a database initializer that drops and recreates the database when the model changes, and Product and ProductCategory entities with properties including Key, Name, Price, ReleaseDate, and navigation properties.

```csharp
    using System;
    using System.Collections.Generic;
    using System.Data.Entity;
    using System.Linq;

    public class ProductContext : DbContext
    {
        static ProductContext()
        {
            Database.SetInitializer(new DropCreateDatabaseIfModelChanges<ProductContext>());
        }

        public DbSet<Product> Products { get; set; }
    }

    public class Product
    {
        public int Key { get; set; }
        public string Name { get; set; }
        public decimal? Price { get; set; }
        public DateTime? ReleaseDate { get; set; }
        public ProductCategory Category { get; set; }
    }

    public class ProductCategory
    {
        public int Key { get; set; }
        public string Name { get; set; }
        public List<Product> Products { get; set; }
    }
```

--------------------------------

### Install Specific EntityFramework Version

Source: https://learn.microsoft.com/en-us/ef/ef6/fundamentals/install

Use this command to install a specific version of the EntityFramework NuGet package. Replace <number> with the version number, e.g., 6.2.0 for EF 6.2.

```powershell
Install-Package EntityFramework -Version <number>
```

--------------------------------

### MSL Alias Element Example

Source: https://learn.microsoft.com/en-us/ef/ef6/modeling/designer/advanced/edmx/msl-spec

Shows an Alias element defining alias 'c' for the conceptual model namespace 'SchoolModel'. The example includes the full Mapping element with EntityContainerMapping and EntitySetMapping elements to illustrate usage.

```xml
 <Mapping Space="C-S"
          xmlns="https://schemas.microsoft.com/ado/2009/11/mapping/cs">
   <Alias Key="c" Value="SchoolModel"/>
   <EntityContainerMapping StorageEntityContainer="SchoolModelStoreContainer"
                           CdmEntityContainer="SchoolModelEntities">
     <EntitySetMapping Name="Courses">
       <EntityTypeMapping TypeName="c.Course">
         <MappingFragment StoreEntitySet="Course">
           <ScalarProperty Name="CourseID" ColumnName="CourseID" />
           <ScalarProperty Name="Title" ColumnName="Title" />
           <ScalarProperty Name="Credits" ColumnName="Credits" />
           <ScalarProperty Name="DepartmentID" ColumnName="DepartmentID" />
         </MappingFragment>
       </EntityTypeMapping>
     </EntitySetMapping>
     <EntitySetMapping Name="Departments">
       <EntityTypeMapping TypeName="c.Department">
         <MappingFragment StoreEntitySet="Department">
           <ScalarProperty Name="DepartmentID" ColumnName="DepartmentID" />
           <ScalarProperty Name="Name" ColumnName="Name" />
           <ScalarProperty Name="Budget" ColumnName="Budget" />
           <ScalarProperty Name="StartDate" ColumnName="StartDate" />
           <ScalarProperty Name="Administrator" ColumnName="Administrator" />
         </MappingFragment>
       </EntityTypeMapping>
     </EntitySetMapping>
   </EntityContainerMapping>
 </Mapping>
```

--------------------------------

### Create a proxy instance with DbSet.Create

Source: https://learn.microsoft.com/en-us/ef/ef6/fundamentals/proxies

Use context.Blogs.Create() to explicitly create a proxy instance, enabling lazy loading and change tracking. The Create method does not add or attach the entity to the context.

```csharp
using (var context = new BloggingContext())
{
    var blog = context.Blogs.Create();
}
```

--------------------------------

### DeleteFunction in AssociationSetMapping Example

Source: https://learn.microsoft.com/en-us/ef/ef6/modeling/designer/advanced/edmx/msl-spec

Shows the DeleteFunction element mapping the delete function of the CourseInstructor association to the DeleteCourseInstructor stored procedure. The stored procedure must be declared in the storage model. The example also includes the InsertFunction mapping for context.

```XML
 <AssociationSetMapping Name="CourseInstructor"
                        TypeName="SchoolModel.CourseInstructor"
                        StoreEntitySet="CourseInstructor">
   <EndProperty Name="Person">
     <ScalarProperty Name="PersonID" ColumnName="PersonID" />
   </EndProperty>
   <EndProperty Name="Course">
     <ScalarProperty Name="CourseID" ColumnName="CourseID" />
   </EndProperty>
   <ModificationFunctionMapping>
     <InsertFunction FunctionName="SchoolModel.Store.InsertCourseInstructor" >   
       <EndProperty Name="Course">
         <ScalarProperty Name="CourseID" ParameterName="courseId"/>
       </EndProperty>
       <EndProperty Name="Person">
         <ScalarProperty Name="PersonID" ParameterName="instructorId"/>
       </EndProperty>
     </InsertFunction>
     <DeleteFunction FunctionName="SchoolModel.Store.DeleteCourseInstructor">
       <EndProperty Name="Course">
         <ScalarProperty Name="CourseID" ParameterName="courseId"/>
       </EndProperty>
       <EndProperty Name="Person">
         <ScalarProperty Name="PersonID" ParameterName="instructorId"/>
       </EndProperty>
     </DeleteFunction>
   </ModificationFunctionMapping>
 </AssociationSetMapping>
```

--------------------------------

### BlogService with AddBlog, GetAllBlogs, and GetAllBlogsAsync

Source: https://learn.microsoft.com/en-us/ef/ef6/fundamentals/testing/writing-test-doubles

The service under test. It uses an IBloggingContext to add blogs and retrieve them ordered by name, with both synchronous and asynchronous query methods.

```csharp
using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;
using System.Threading.Tasks;

namespace TestingDemo
{
    public class BlogService
    {
        private IBloggingContext _context;

        public BlogService(IBloggingContext context)
        {
            _context = context;
        }

        public Blog AddBlog(string name, string url)
        {
            var blog = new Blog { Name = name, Url = url };
            _context.Blogs.Add(blog);
            _context.SaveChanges();

            return blog;
        }

        public List<Blog> GetAllBlogs()
        {
            var query = from b in _context.Blogs
                        orderby b.Name
                        select b;

            return query.ToList();
        }

        public async Task<List<Blog>> GetAllBlogsAsync()
        {
            var query = from b in _context.Blogs
                        orderby b.Name
                        select b;

            return await query.ToListAsync();
        }
    }
}
```

--------------------------------

### Override general convention with specific convention (max length)

Source: https://learn.microsoft.com/en-us/ef/ef6/modeling/code-first/conventions/custom

Shows two conventions where the second overrides the first for properties named 'Name'. The last convention to execute wins, so all 'Name' properties get MaxLength 250 while other strings get 500.

```csharp
    modelBuilder.Properties<string>()
                .Configure(c => c.HasMaxLength(500));

    modelBuilder.Properties<string>()
                .Where(x => x.Name == "Name")
                .Configure(c => c.HasMaxLength(250));
```

--------------------------------

### Use the Model - Main method code

Source: https://learn.microsoft.com/en-us/ef/ef6/modeling/designer/table-splitting

Paste this code into the Main method to use the table-splitting model. It creates a Person and HireInfo, adds them to the context, saves changes, and queries the data. The example assumes a SchoolEntities context and Person/HireInfo entities.

```csharp
using (var context = new SchoolEntities())
{
    Person person = new Person()
    {
        FirstName = "Kimberly",
        LastName = "Morgan",
        Discriminator = "Instructor",
    };

    person.HireInfo = new HireInfo()
    {
        HireDate = DateTime.Now
    };

    // Add the new person to the context.
    context.People.Add(person);

    // Insert a row into the Person table.  
    context.SaveChanges();

    // Execute a query against the Person table.
    // The query returns columns that map to the Person entity.
    var existingPerson = context.People.FirstOrDefault();

    // Execute a query against the Person table.
    // The query returns columns that map to the Instructor entity.
    var hireInfo = existingPerson.HireInfo;

    Console.WriteLine("{0} was hired on {1}",
        existingPerson.LastName, hireInfo.HireDate);
}
```

--------------------------------

### Example output from using OneLineFormatter

Source: https://learn.microsoft.com/en-us/ef/ef6/fundamentals/logging-and-interception

Shows the resulting log output when Database.Log is set and the custom formatter is used. Each command is logged as a single line with the context name and command text.

```text
Context 'BlogContext' is executing command 'SELECT TOP (1) [Extent1].[Id] AS [Id], [Extent1].[Title] AS [Title]FROM [dbo].[Blogs] AS [Extent1]WHERE (N'One Unicorn' = [Extent1].[Title]) AND ([Extent1].[Title] IS NOT NULL)'
Context 'BlogContext' is executing command 'SELECT [Extent1].[Id] AS [Id], [Extent1].[Title] AS [Title], [Extent1].[BlogId] AS [BlogId]FROM [dbo].[Posts] AS [Extent1]WHERE [Extent1].[BlogId] = @EntityKeyValue1'
Context 'BlogContext' is executing command 'update [dbo].[Posts]set [Title] = @0where ([Id] = @1)'
Context 'BlogContext' is executing command 'insert [dbo].[Posts]([Title], [BlogId])values (@0, @1)select [Id]from [dbo].[Posts]where @@rowcount > 0 and [Id] = scope_identity()'
```

--------------------------------

### Author, Reader, and IPerson classes for change tracking example

Source: https://learn.microsoft.com/en-us/ef/ef6/querying/local-data

These classes are used in the change tracking example. Author and Reader implement the IPerson interface, which exposes a Name property. The IPerson interface allows the ChangeTracker.Entries<IPerson>() call to find both authors and readers.

```csharp
public class Author : IPerson
{
    public int AuthorId { get; set; }
    public string Name { get; set; }
    public string Biography { get; set; }
}

public class Reader : IPerson
{
    public int ReaderId { get; set; }
    public string Name { get; set; }
    public string Username { get; set; }
}

public interface IPerson
{
    string Name { get; }
}
```

--------------------------------

### Update Program.cs to use BlogContext

Source: https://learn.microsoft.com/en-us/ef/ef6/modeling/code-first/migrations/

Replace the contents of Program.cs with this code to add a blog, save changes, and list all blogs. Running the application creates the MigrationsCodeDemo.BlogContext database.

```csharp
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;

    namespace MigrationsDemo
    {
        class Program
        {
            static void Main(string[] args)
            {
                using (var db = new BlogContext())
                {
                    db.Blogs.Add(new Blog { Name = "Another Blog " });
                    db.SaveChanges();

                    foreach (var blog in db.Blogs)
                    {
                        Console.WriteLine(blog.Name);
                    }
                }

                Console.WriteLine("Press any key to exit...");
                Console.ReadKey();
            }
        }
    }
```

--------------------------------

### DeleteFunction Element Example for Person Entity

Source: https://learn.microsoft.com/en-us/ef/ef6/modeling/designer/advanced/edmx/msl-spec

Shows the DeleteFunction element mapping the delete function of the Person entity type to the DeletePerson stored procedure. The stored procedure is declared in the storage model. The example includes the full EntitySetMapping with InsertFunction, UpdateFunction, and DeleteFunction.

```XML
 <EntitySetMapping Name="People">
   <EntityTypeMapping TypeName="SchoolModel.Person">
     <MappingFragment StoreEntitySet="Person">
       <ScalarProperty Name="PersonID" ColumnName="PersonID" />
       <ScalarProperty Name="LastName" ColumnName="LastName" />
       <ScalarProperty Name="FirstName" ColumnName="FirstName" />
       <ScalarProperty Name="HireDate" ColumnName="HireDate" />
       <ScalarProperty Name="EnrollmentDate"
                       ColumnName="EnrollmentDate" />
     </MappingFragment>
 </EntityTypeMapping>
   <EntityTypeMapping TypeName="SchoolModel.Person">
     <ModificationFunctionMapping>
       <InsertFunction FunctionName="SchoolModel.Store.InsertPerson">
         <ScalarProperty Name="EnrollmentDate"
                         ParameterName="EnrollmentDate" />
         <ScalarProperty Name="HireDate" ParameterName="HireDate" />
         <ScalarProperty Name="FirstName" ParameterName="FirstName" />
         <ScalarProperty Name="LastName" ParameterName="LastName" />
         <ResultBinding Name="PersonID" ColumnName="NewPersonID" />
       </InsertFunction>
       <UpdateFunction FunctionName="SchoolModel.Store.UpdatePerson">
         <ScalarProperty Name="EnrollmentDate"
                         ParameterName="EnrollmentDate"
                         Version="Current" />
         <ScalarProperty Name="HireDate" ParameterName="HireDate"
                         Version="Current" />
         <ScalarProperty Name="FirstName" ParameterName="FirstName"
                         Version="Current" />
         <ScalarProperty Name="LastName" ParameterName="LastName"
                         Version="Current" />
         <ScalarProperty Name="PersonID" ParameterName="PersonID"
                         Version="Current" />
       </UpdateFunction>
       <DeleteFunction FunctionName="SchoolModel.Store.DeletePerson">
         <ScalarProperty Name="PersonID" ParameterName="PersonID" />
       </DeleteFunction>
     </ModificationFunctionMapping>
   </EntityTypeMapping>
 </EntitySetMapping>
```

--------------------------------

### Cold Query Execution Example

Source: https://learn.microsoft.com/en-us/ef/ef6/fundamentals/performance/perf-whitepaper

Shows the code a user writes for the first query against a model, which triggers cold query overhead such as metadata loading and view generation. The performance impact for each step is compared across EF4, EF5, and EF6.

```csharp
using(var db = new MyContext())
{
var q1 =
from c in db.Customers
where c.Id == id1
select c;
var c1 = q1.First();
}
```

--------------------------------

### SSDL Schema Example with EntityContainer, EntityTypes, Association, and Functions

Source: https://learn.microsoft.com/en-us/ef/ef6/modeling/designer/advanced/edmx/ssdl-spec

This SSDL schema example shows a Schema element with an EntityContainer, two EntityType elements, one Association element, and two Function elements. It includes EntitySets, an AssociationSet, properties, documentation, custom elements, referential constraints, and functions with parameters and command text.

```XML
 <Schema Namespace="ExampleModel.Store"
       Alias="Self" Provider="System.Data.SqlClient"
       ProviderManifestToken="2008"
       xmlns="https://schemas.microsoft.com/ado/2009/11/edm/ssdl">
   <EntityContainer Name="ExampleModelStoreContainer">
     <EntitySet Name="Customers"
                EntityType="ExampleModel.Store.Customers"
                Schema="dbo" />
     <EntitySet Name="Orders"
                EntityType="ExampleModel.Store.Orders"
                Schema="dbo" />
     <AssociationSet Name="FK_CustomerOrders"
                     Association="ExampleModel.Store.FK_CustomerOrders">
       <End Role="Customers" EntitySet="Customers" />
       <End Role="Orders" EntitySet="Orders" />
     </AssociationSet>
   </EntityContainer>
   <EntityType Name="Customers">
     <Documentation>
       <Summary>Summary here.</Summary>
       <LongDescription>Long description here.</LongDescription>
     </Documentation>
     <Key>
       <PropertyRef Name="CustomerId" />
     </Key>
     <Property Name="CustomerId" Type="int" Nullable="false" />
     <Property Name="Name" Type="nvarchar(max)" Nullable="false" />
   </EntityType>
   <EntityType Name="Orders" xmlns:c="http://CustomNamespace">
     <Key>
       <PropertyRef Name="OrderId" />
     </Key>
     <Property Name="OrderId" Type="int" Nullable="false"
               c:CustomAttribute="someValue"/>
     <Property Name="ProductId" Type="int" Nullable="false" />
     <Property Name="Quantity" Type="int" Nullable="false" />
     <Property Name="CustomerId" Type="int" Nullable="false" />
     <c:CustomElement>
       Custom data here.
     </c:CustomElement>
   </EntityType>
   <Association Name="FK_CustomerOrders">
     <End Role="Customers"
          Type="ExampleModel.Store.Customers" Multiplicity="1">
       <OnDelete Action="Cascade" />
     </End>
     <End Role="Orders"
          Type="ExampleModel.Store.Orders" Multiplicity="*" />
     <ReferentialConstraint>
       <Principal Role="Customers">
         <PropertyRef Name="CustomerId" />
       </Principal>
       <Dependent Role="Orders">
         <PropertyRef Name="CustomerId" />
       </Dependent>
     </ReferentialConstraint>
   </Association>
   <Function Name="UpdateOrderQuantity"
             Aggregate="false"
             BuiltIn="false"
             NiladicFunction="false"
             IsComposable="false"
             ParameterTypeSemantics="AllowImplicitConversion"
             Schema="dbo">
     <Parameter Name="orderId" Type="int" Mode="In" />
     <Parameter Name="newQuantity" Type="int" Mode="In" />
   </Function>
   <Function Name="UpdateProductInOrder" IsComposable="false">
     <CommandText>
       UPDATE Orders
       SET ProductId = @productId
       WHERE OrderId = @orderId;
     </CommandText>
     <Parameter Name="productId"
                Mode="In"
                Type="int"/>
     <Parameter Name="orderId"
                Mode="In"
                Type="int"/>
   </Function>
 </Schema>
```

--------------------------------

### Define Blog model and BlogContext in Model.cs

Source: https://learn.microsoft.com/en-us/ef/ef6/modeling/code-first/migrations/

Create a Model.cs file with this code to define the Blog domain model and the BlogContext EF Code First context. This is the initial model used for migrations.

```csharp
    using System.Data.Entity;
    using System.Collections.Generic;
    using System.ComponentModel.DataAnnotations;
    using System.Data.Entity.Infrastructure;

    namespace MigrationsDemo
    {
        public class BlogContext : DbContext
        {
            public DbSet<Blog> Blogs { get; set; }
        }

        public class Blog
        {
            public int BlogId { get; set; }
            public string Name { get; set; }
        }
    }
```

--------------------------------

### SQL to Create Blogging Database Tables and Seed Data

Source: https://learn.microsoft.com/en-us/ef/ef6/modeling/code-first/workflows/existing-database

SQL script to create the Blogs and Posts tables with primary and foreign keys, and insert two sample blog entries. Execute this in a new query against the Blogging database.

```sql
CREATE TABLE [dbo].[Blogs] (
    [BlogId] INT IDENTITY (1, 1) NOT NULL,
    [Name] NVARCHAR (200) NULL,
    [Url]  NVARCHAR (200) NULL,
    CONSTRAINT [PK_dbo.Blogs] PRIMARY KEY CLUSTERED ([BlogId] ASC)
);

CREATE TABLE [dbo].[Posts] (
    [PostId] INT IDENTITY (1, 1) NOT NULL,
    [Title] NVARCHAR (200) NULL,
    [Content] NTEXT NULL,
    [BlogId] INT NOT NULL,
    CONSTRAINT [PK_dbo.Posts] PRIMARY KEY CLUSTERED ([PostId] ASC),
    CONSTRAINT [FK_dbo.Posts_dbo.Blogs_BlogId] FOREIGN KEY ([BlogId]) REFERENCES [dbo].[Blogs] ([BlogId]) ON DELETE CASCADE
);

INSERT INTO [dbo].[Blogs] ([Name],[Url])
VALUES ('The Visual Studio Blog', 'http://blogs.msdn.com/visualstudio/')

INSERT INTO [dbo].[Blogs] ([Name],[Url])
VALUES ('.NET Framework Blog', 'http://blogs.msdn.com/dotnet/')
```

--------------------------------

### LINQ queries for blogs with names starting with B and the blog named ADO.NET Blog

Source: https://learn.microsoft.com/en-us/ef/ef6/querying/

Shows two LINQ queries: one using query syntax to find blogs starting with 'B' and another using method syntax with Where and FirstOrDefault to find the blog named 'ADO.NET Blog'. Queries always hit the database and return empty collections if no rows match.

```csharp
using (var context = new BloggingContext())
{
    // Query for all blogs with names starting with B
    var blogs = from b in context.Blogs
                   where b.Name.StartsWith("B")
                   select b;

    // Query for the Blog named ADO.NET Blog
    var blog = context.Blogs
                    .Where(b => b.Name == "ADO.NET Blog")
                    .FirstOrDefault();
}
```

--------------------------------

### SingleAggregating Query Example

Source: https://learn.microsoft.com/en-us/ef/ef6/fundamentals/performance/perf-whitepaper

A normal BI query with multiple aggregations but no subtotals. It calls the MDF_SessionLogin_Time_Max() function defined in the model.

```XML
  <Query complexity="SingleAggregating">
    <CommandText>NavisionFK.MDF_SessionLogin_Time_Max()</CommandText>
  </Query>
```
Tokens:
Raw