Building Cross-platform Applications with .NET Core

—Introduction 1m 4s
—Deployment Options 6m 39s
—dotnet publish to Create a Framework Dependent Deployment 4m 22s
—Diff dotnet build vs. dotnet publish Output 2m 39s
—FDD to Windows 2m 2s
—FDD to Linux via Docker 2m 22s
—What if the Target Platform Does not Have the Runtime? 2m 3s
—Specifying RuntimeIdentifiers 2m 53s
—dotnet publish to Create a Self Contained Deployment 3m 36s
—What Happens if you Do Not Specify the RID in the Project? 3m 18s
—SCDs Also Contain an Executable 3m 12s
—Pre-reqs Must be Present When Using an SCD 1m 26s
—SCD to Windows 1m 42s
—Pros and Cons of FDD vs. SCD 1m 44s
—FDD Release Build 3m 14s
—Building a Linux Container Image with a Console App 4m 51s
—You Can Distribute Your App Only in a Linux Container Image 1m 41s
—Container Images Have Best of Both FDD and SCD 3m 12s
—Run Linux Container on Windows 2m 10s
—The Container Image Contains Your App Files 1m 26s
—There Is Also a .NET Core SDK Image 1m 13s

—Creating a Test Project 2m 54s
—Adding a dotnet new Project to a Solution 0m 49s
—Where I See an Opportunity to Benefit from Automated Testing 2m 33s
—ProjectReferences Are Much More Concise 4m 8s
—dotnet add - To Add a Project Reference 1m 32s
—Running Tests in Your IDE and Platform of Choice 3m 8s
—dotnet test to Execute Tests on Multiple Platforms 2m 40s
—How Much Testing Makes Sense per Platform 6m 12s

—Introduction 0m 42s
—The System.IO Namespace 1m 23s
—Getting a Temporary File Name 1m 48s
—Learning from the Open Source .NET Core Platform Specific Code 4m 48s
—Temporary Files in Unix Type Environments 1m 34s
—Writing to a Temporary File 1m 6s
—Combining Paths with Path.Combine 5m 17s
—Parsing and Creating Directories 2m 16s
—Write Report to Current Directory 1m 32s
—Quiz - Check if the App Runs in Linux Too 1m 32s
—Checking Link Existence 3m 24s
—Writing to a File Using a Stream - File.CreateText 3m 50s
—Reflecting on the Convenience of Cross-platform Testing 4m 16s

—Introduction 0m 44s
—One Configuration API to Rule Them All 3m 36s
—Configuration Is Affiliated with ASP.NET Core 2m 12s
—Configuring the Command Line Configuration Provider 3m 24s
—Loading the Site from a Command Line Argument 3m 26s
—Reading Configuration from Environment Variables 3m 18s
—Configuration Provider Order Matters 3m 9s
—Adding JSON Configuration 3m 25s
—Adding inMemory Configuration 2m 53s
—Adding Configuration Sections 3m 53s
—Configuration Sections and Binding POCOs 5m 8s
—Simplified Configuration Binding via Get 1m 3s
—Refactoring Configuration into a Config Object 8m 0s
—What Else There Is to Know About Configuration 3m 2s

—Introduction 0m 32s
—What Is Wrong with Console.WriteLine 1m 34s
—The Microsoft.Extensions Packages 2m 59s
—Adding the Microsoft.Extensions.Logging Packages 1m 30s
—Using a LoggerFactory to Create a Logger to Log Messages 2m 44s
—Logging to the Console 1m 29s
—Choosing a Log Level 3m 52s
—Changing the Minimum Log Level to Write to the Console 1m 11s
—Logging to Multiple Destinations 1m 59s
—Logging to the Debug Output Window 1m 30s
—Logging to a File with Serilog 2m 1s
—Sharing a LoggerFactory Instance 3m 18s
—Accessing the Source Code for the Logging Framework 1m 15s
—Using Fully Qualified Type Names for the Log Category 1m 23s
—Adding Trace Level Log Messages 3m 15s
—Different Minimum Levels per Logging Destination 1m 20s
—Correlating Logs with Scoping 4m 41s
—Identifying Related Logs with Event ID 1m 33s
—Serilog Generates Event IDs 1m 49s
—Structured Log Message Placeholders Can Be Queryable 4m 26s
—Logging Exceptions 2m 41s
—Logging Meets Configuration 6m 22s
—Setting a Log Level per Category 3m 3s
—Summary 2m 17s

—Introduction 1m 4s
—How to Access the Code Samples for this Module 0m 31s
—Referencing the Microsoft.EntityFrameworkCore.SqlServer Package 2m 32s
—Setting up a DbContext 3m 34s
—Saving LinkCheckResults to Out Database 1m 57s
—Starting MSSQL on Linux in a Container 4m 6s
—Connecting with SSMS 1m 7s
—Create a Links Database with SSMS 0m 47s
—Writing Data on a Mac to MSSQL 1m 15s
—Isolated DB Servers Are Incredibly Easy Thanks to Containers 1m 23s
—Troubleshooting MSSQL on Linux in a Container - Accessing Logs 2m 12s
—Starting MySQL in a Container 1m 10s
—Creating a Links Table in the MySQL DB 1m 2s
—Changing the App to Use the Official MySQL Provider 4m 47s
—Switching to the Pomelo MySql EF Core Provider 2m 44s
—Running PostgreSQL in a Container 0m 50s
—Initializing a PostgreSQL Database 2m 38s
—Changing the App to Use PostgreSQL 3m 16s
—Hunting Down Namespaces 1m 45s
—Containers Provide Flexibility for Cross-platform Development 2m 32s
—There Are Plenty of Third Party ORMs Too 1m 37s
—Creating a SQLite Database in a File 2m 0s
—Changing the App to Use SQLite 2m 53s
—Cross-platform SQL Based Migrations with Flyway 2m 19s
—Configuring the Connection String 1m 17s
—You Do Not Need an IRepository 5m 1s

—Introduction 0m 35s
—Adding Hangfire for Background Jobs 2m 43s
—Configuring Hangfire and Running a Background Job Server 1m 21s
—Running a Recurring Job with Hangfire 1m 39s
—Checking Links Every Minute 5m 2s
—Good Time to Turn Down Logging Verbosity 1m 3s
—Moving from Console Hosted to a Background Service 1m 5s
—Creating a Test Linux VM with Vagrant 1m 17s
—Installing the .NET Core Runtime on Ubuntu 3m 30s
—Deploying Your App to Your Ubuntu VM 3m 49s
—Creating a systemd Service 3m 57s
—Opening Your App in Visual Studio Code 3m 29s
—Generating a Web Example Project 3m 32s
—Adding a Blocking Web Endpoint to Your Service 6m 13s
—Successfully Running Your systemd Service 4m 0s
—Windows Service Considerations 5m 13s

—The Slippery Slope to a Web Status Endpoint 0m 39s
—Adding a Hangfire Web Dashboard 5m 0s
—This Web Endpoint Can Do Just About Anything You Want 2m 3s

—Introduction 0m 54s
—Sharing a Single LoggerFactory 1m 30s
—Telling ASP.NET Core to Use Your LoggerFactory 2m 51s
—How to Explicitly Access Services like ILoggerFactory 5m 10s
—Looking at Registered Services 3m 11s
—Resolving Other Services like Logger Of T 5m 27s
—Fulfilling Dependencies of Dependencies 2m 40s
—The Three Components of Service Registration 5m 28s
—Understanding How a Service Is Resolved 2m 21s
—Using Method Injection with the Startup Configure Method 2m 16s
—Letting ASP.NET Core Create the LoggerFactory 4m 1s
—Getting Back to Your Link Checking Job 1m 26s
—Resolve 1m 4s
—Registering CheckLinkJob as a Service 6m 35s
—Debugging Custom Service Registrations 1m 18s
—Using Constructor Injection with Your Services 3m 57s
—Injecting App Configuration with IOptions of T 4m 0s
—Registering App Configuration POCOs with DI 3m 59s
—Creating a Separate SiteSettings POCO 4m 25s
—Debugging the IConfigureOptions ServiceDescriptors 1m 28s
—Cleaning up Configuration 2m 39s
—Transitive Dependencies 4m 4s
—Exercise - Try Wiring in Entity Framework Core to Use DI 2m 52s
—The End 0m 44s