On the surface many-to-many in EF6 and EF Core look very similar.

However, under the covers the design in EF Core 5.0 provides  more flexibility and power.

In this episode, Arthur Vickers returns to chat some more with Jeremy about some of the new  features in Entity Framework Core 5. In particular, they’ll be diving deep into the building blocks of many-to-many. You’ll see how they can be configured to allow flexible mapping and access to the underlying join table.

Useful Links

Caching can make your website run faster, it can improve your desktop application, and it can reduce the stress on your database.

Basically, if you figure out caching, you can dramatically improve how well your application scales. In this video, we are going to look at how to use Redis to quickly and easily cache our data. I think you will be shocked by how easy this turns out to be.

Tim Corey shows us how to get started.

Peachpie is an open source project that allows for a seamless interoperability between PHP and .NET applications. In this video, Benjamin and Jakub from the Peachier project show us how they enable developers to run WordPress on .NET Core.


  • [01:19] – Why run WordPress on .NET?
  • [03:22] – What enables WordPress to run on .NET
  • [07:32] – Getting started with WordPress in .NET Core
  • [16:43] – How does updating to newer WordPress versions work?
  • [18:54] – Using custom themes and plugins
  • [27:40] – Migrating over an existing WordPress site
  • [29:48] – Creating WordPress plugins with .NET
  • [34:06] – Publishing the application
  • [35:27] – Customer feedback

Useful Links

Learn ASP.NET Core 5 MVC(.NET 5) in this complete tutorial course for beginners.

After learning about the history and basics of ASP.NET Core, you will learn how to build a small book list application with CRUD operations. You will learn how to use the Entity Framework for integration with a database with ASP.NET Core Razor Pages.

You will build a CRUD application with validations and finally deploy the application on Azure!

Code: https://github.com/dotnetmastery/Rocky

Course Contents

  • 0:00:00 Welcome
  • 0:03:52 Tools
  • 0:05:59 ASP.NET Core
  • 0:10:15 Create Project
  • 0:14:11 Project File
  • 0:15:54 Program Class File
  • 0:17:21 Dependency Injection
  • 0:21:55 StartUp Part 1
  • 0:24:21 StartUp Part 2
  • 0:27:46 Routing in MVC
  • 0:33:47 AppSettings
  • 0:34:37 wwwRoot and launchSettings
  • 0:37:28 MVC Application
  • 0:41:13 Routing in Action
  • 0:45:02 Views in Default Project
  • 0:49:55 Create First Model
  • 0:53:30 Add Connection String
  • 0:56:59 Setup DbContext
  • 1:02:23 Complete DbContext Configuration
  • 1:06:12 Push Category to Database
  • 1:09:47 Check Database
  • 1:11:00 Add Category Controller
  • 1:13:52 Add Category Index View
  • 1:16:24 Get all Category
  • 1:20:59 Display All Category
  • 1:26:19 Add Category Part 1
  • 1:31:16 Add Category Part 2
  • 1:36:46 Add Category Part 3
  • 1:40:43 Assignment
  • 1:41:53 Solution
  • 1:48:14 Validations in ASP.NET Core
  • 1:52:52 Client side and server side validations
  • 1:57:13 Passing Parameters on Redirect
  • 2:00:27 Category Edit Get Action
  • 2:04:16 Update Category
  • 2:06:31 Delete Category
  • 2:10:28 Font Awesome
  • 2:15:04 Assignment
  • 2:15:41 Assignment Solution
  • 2:20:46 Azure Deployment

Swagger and the OpenAPI specification  the manual work out of API documentation and make it easier for developers to share their APIs with the wold.

In this video, Hassan Habib is back again with Jeremy to talk about Swagger support in the latest version of the OData package for ASP.NET Core.


  • [01:08] – The need for Swagger
  • [05:17] – Adding Swagger to an OData API application
  • [10:45] – Fixing the integration

Useful Links

GitHub Actions makes it easy to automate all your software workflows.

Tim Heuer joins Scott Hanselman to saunter through the process of deploying .NET Core apps to Azure using GitHub Actions.


  • [0:00:00]- Overview
  • [0:00:19]- Project setup
  • [0:04:02]- Configuring the workflow
  • [0:07:29]- Build job – setting up the environment
  • [0:13:18]- Build job – configuring the build
  • [0:16:07]- Getting the publish profile from Azure
  • [0:17:45]- Build job – handling secrets
  • [0:20:37]- Build job – deploying to Azure
  • [0:22:34]- Actions tab in GitHub and workflow log review
  • [0:24:59]- Adding artifacts to the job
  • [0:27:59]- Wrap-up

Related links:

There are a variety of ways to publish .NET Core applications.

In the video below, Todd Gardner shares his experience with publishing self contained .NET applications to Linux.


  • [02:10] – What does the application architecture look like?
  • [04:42] – Exploring the worker processes
  • [10:50] – Collecting metrics
  • [12:55] – Self contained deployments

Useful Links:

In this episode, Robert is joined by Phil Japikse for part 1 of a 10 part series on Entity Framework Core. This series is a follow-up to the 5 part series that was aimed at folks new to EF Core and provides a more in-depth exploration of a number of topics.

Find the sample code here.

Episode list:

  • Part 1: Performance. (this episode)
  • Part 2: View Models. Phil covers using straight SQL, stored procedures, and populating view models with projections.
  • Part 3: Configuration. EF Core provides a wide range of configuration options for the derived DbContext and it’s full support of dependency injection.
  • Part 4: Build Your Model. This show is all about creating your EF Core entities to shape the database and using migrations to publish the model.
  • Part 5: Global Query Filters. These are new in EF Core, and provide a great mechanism for handling scenarios like multi-tenancy and soft deletes.
  • Part 6: Concurrency Conflicts. These have long been a problem for multi-user systems. Phil walks us through how concurrency checking works with EF Core and SQL Server, and all of the data provided back to the developer when a concurrency issue occurs.
  • Part 7: Connection Resiliency. EF Core can gracefully handles transient database errors (if you enable the feature). Phil and Robert talk about what transient errors are, how to enable the feature, and how it effects using explicit permissions.
  • Part 8: Computed Columns. Blending EF Core with server side functionality is a breeze with EF Core. Phil covers using computed columns in EF Core as well as mapping SQL Server function to C# functions for use in LINQ queries.
  • Part 9: Change Tracking Events. The fairly recent addition of Tracking and State Change events provides a mechanism for audit logging (among other uses). Phil shows how this works as well as takes a quick spin through the EF Core Interceptors.
  • Part 10: Field Mapping. This enables EF Core to create your entities without calling the property setters, solving the long running problem of using an ORM with frameworks that use INotifyPropertyChanged, such as Windows Presentation Foundation (WPF).