Entity Framework Core is a modern, lightweight, open-source, cross-platform object-relational mapper.

Using Entity Framework Core for Data Access & Relational Mapping.png

ScaffoldDB.tar.gz

EFCore

EFCorePreCreateTablesInOutputDir

EFCorePreCreateTablesAndViewInOutputDir

EFCoreWithProxies

EFCoreWithXunit

CreateSchoolTablesInOutputDir

This course introduces Entity Framework Core for data access and object-relational mapping. Entity Framework Core provides benefits such as the ability to work with databases using .NET objects without the concern for underlying database tables. This leads to less code for data access and improved performance. 

You’ll begin with the workflows of Entity Framework Core—reverse engineering and migrations. Next, you’ll learn model configuration and relationships. Then, you’ll cover various methods for querying and saving data. You’ll also learn about change tracking and its relationship with queries. Finally, you’ll learn about logging and testing.

Entity Framework Core simplifies app development. By the end of this course, you’ll be able to improve code maintainability and concentrate on business logic by generating SQL, materializing results, and performing other tasks. You’ll have a good understanding of Entity Framework Core, which will improve your productivity and efficiency on your development journey.

Using Entity Framework Core for Data Access & Relational Mapping

Which option is _not_ a benefit of testing with SQLite?

Which option is not a benefit of testing with SQLite?

```C#
this._conn = new Sqlite("DataSource=:memory:");
this._conn.Open();
```

```C#
this._conn = new SqlServer("DataSource=:memory:");
this._conn.Open();
```

```C#
this._conn = new SqliteConnection("DataSource=:memory:");
this._conn.Open();
```

```C#
this._conn = new SqliteMemoryConnection(":memory:");
this._conn.Open();
```

For the code snippet below, select the missing lines of code that create an in-memory database.

```C#

public class ConnectionFactory : IDisposable
{

    private readonly SqliteConnection _conn;

    public ConnectionFactory()
    {
        //missing code        
    }

    public void Dispose()
    {
        _conn.Dispose();
    }
}

```

For the code snippet below, select the missing lines of code that create an in-memory database.
<pre><code class="language-C#">
public class ConnectionFactory : IDisposable
{

 private readonly SqliteConnection _conn;

 public ConnectionFactory()
 {
 //missing code 
 }

 public void Dispose()
 {
 _conn.Dispose();
 }
}

</code></pre>

It has the ability to easily support more than one database.

It has the ability to mock the repository abstraction rather than EF Core LINQ queries.

We can use LINQ queries anywhere in the application.

It exposes `IEnumerable<T>` rather than `IQueryable<T>`.

Which option is _not_ a benefit of using the repository pattern?

Which option is not a benefit of using the repository pattern?

(**Fill in the blank.**) When implementing a repository, we often inject ________ into the repository’s constructor.

(Fill in the blank.) When implementing a repository, we often inject ________ into the repository’s constructor.

(**Fill in the blank.**) In SQLite in-memory, a new database is created whenever ________.

(Fill in the blank.) In SQLite in-memory, a new database is created whenever ________.

Review your knowledge of testing EF Core applications.

Getting Started

Reverse Engineering

Migrations

Configuring a Model

Query Data

Save Data

Logging and Testing

Conclusion

Appendix

Quiz: Testing