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.

Index:

  • [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.

Index:

  • [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.

Index:

  • [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.

Index:

  • [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).

Who doesn’t appreciate good BBQ?

Well, maybe some people don’t but I certainly do and that means more for me. Winking smile

In this video, Cam Soper comes on to show us another one of this home projects.

Cam tells us the story of how a Raspberry PI, a chat bot, and a little .NET Core allows him to control his smoker and make great BBQ!

Time Index:

  • [00:34] – Kansas City BBQ
  • [01:52] – Building the PID controller
  • [03:35] – Exploring the components
  • [04:31] – Light it up
  • [07:00] – Creating the Skype bot
  • [10:42] – The Bot commands
  • [12:16] – Further resources

Useful Links

Looking for a good DIY (Do It Yourself) IoT project?

There are so many interesting things that we can do with a few components and a little creatively.

In this video, Cam Soper comes on to show us how he automated his home with .NET Core, Hubitat, and Azure with his open source project called Puppet.

Time Index:

  • [01:00] – Taking a look at the setup
  • [02:29] – Triggering Hubitat events
  • [05:15] – Using .NET for interaction
  • [08:52] – The motivation behind Puppet
  • [13:35] – Running your own Puppet server

Useful Links

    In this video, Robert is joined by Phil Japikse for part 3 of a 5 part series on Entity Framework Core. Aimed at folks new to EF Core, Phil shows how to start with an existing SQL Server database, create entities/objects for each table and then how to perform basic CRUD operations on the data.

    This episode covers querying data using EF Core. We discuss the basics of Where clauses, retrieving single items or lists of items, as well as when queries actually execute.

    Find the sample code here.

    Episode list:

    • Part 1: Working with Existing Databases. We scaffold the DbContext and the Entities from the Northwind Database, discuss navigation properties and relationships.
    • Part 2: Change Tracking. Change Tracking is one of the most compelling reasons to use an object-relational-mapper (ORM) like EF Core. In this episode we discuss how the change tracker works, see it in action, as well as load data outside of the change tracker.
    • Part 3: Basic Queries (this episode).
    • Part 4: Querying Related Data and Using Projections (coming soon). Querying related data is simple in EF Core. In this episode we demonstrate creating joins in our LINQ queries with Include and ThenInclude. We also discuss how you use projections to shape the queried data into other objects, anonymous or strongly typed.
    • Part 5: Putting the CUD into CRUD (coming soon). Wrapping up our starter series on EF Core, this episode covers adding, updating, and deleting data.

    In this video, Robert is joined by Phil Japikse for part 2 of a 5 part series on Entity Framework Core.

    Aimed at folks new to EF Core, Phil shows how to start with an existing SQL Server database, create entities/objects for each table and then how to perform basic CRUD operations on the data.

    Change Tracking is one of the most compelling reasons to use an object-relational-mapper (ORM) like EF Core.     

    Find the sample code here.

    Episode list:

    • Part 1: Working with Existing Databases. We scaffold the DbContext and the Entities from the Northwind Database, discuss navigation properties and relationships.
    • Part 2: Change Tracking (this episode).
    • Part 3: Basic Queries (coming soon). This episodes querying data using EF Core. We discuss the basics of where clauses, retrieving single items or lists of items, as well as when queries actually execute.
    • Part 4: Querying Related Data and Using Projections (coming soon). Querying related data is simple in EF Core, and In this episode we demonstrate creating joins in our LINQ queries with Include and ThenInclude. We also discuss how you use projections to shape the queried data into other objects, anonymous or strongly typed.
    • Part 5: Putting the CUD into CRUD (coming soon). Wrapping up our starter series on EF Core, this episode covers adding, updating, and deleting data using EF Core.