.NET Core in Action
Dustin Metzgar
  • MEAP began September 2016
  • Publication in June 2018 (estimated)
  • ISBN 9781617294273
  • 275 pages (estimated)
  • printed in black & white

.NET Core is what it sounds like. It's a subset of the .NET framework with libraries and runtimes that drastically reduce its footprint, so you can write and run .NET applications more efficiently. In addition to Windows, .NET Core includes runtimes for Mac and Linux, making it a high-productivity cross-platform option for web, cloud, and server-based applications. It's open source and backed by Microsoft, so supported operating systems, CPUs, and application scenarios will continue to grow over time.

.NET Core in Action shows .NET developers how to build professional software applications with .NET Core. You'll start by getting the big picture of how to build .NET Core applications and use the tools. Then you'll learn unit testing, debugging, and logging. You'll also discover simple data access and networking. The last part of the book goes into more advanced topics, like performance profiling, localization, and signing assemblies, that you need to know so you can release your library or application to the world. By the end of this book, you'll be able to convert existing .NET code to work on multiple platforms or start new projects with knowledge of the tools and capabilities of .NET Core.

"Easy to read and understand."

~ Eric Sweigart

"Covers valuable use cases, such as dataaccess, web app development and deployment to multiple platforms."

~ Viorel Moisei

"This book covers all the bases to get you up and running on the .NET Core, even if you never worked with it before."

~ Bruno Figueiredo

Table of Contents detailed table of contents

1. Why .NET Core?

1.1. Architecting enterprise applications before .NET Core

1.2. If you are a .NET Framework developer

1.2.1. Your .NET apps can be cross—platform

1.2.2. ASP.NET Core outperforms Framework ASP.NET

1.2.3. .NET Core is the focus for innovation

1.2.4. Release cycles are faster

1.3. If you are new to .NET

1.3.1. C# is an amazing language

1.3.2. ASP.NET Core performance is on par with the top web frameworks

1.3.3. .NET Core is not starting from scratch

1.4. What is .NET Core?

1.5. Key .NET Core features

1.5.1. Expanding the reach of your libraries

1.5.2. Simple deployment on any platform

1.5.3. Clouds and containers

1.5.4. ASP.NET performance

1.5.5. Open source

1.5.6. Bring your own tools

1.6. Applying .NET Core to real—world applications

1.6.1. Scaling in response to demand

1.7. Differences from the .NET Framework

1.7.1. Framework features not ported to Core

1.7.2. Subtle changes for .NET Framework developers

1.7.3. Changes to .NET Reflection

1.8. Summary

2. Building Your First .NET Core Applications

2.1. The trouble with development environments

2.2. Installing the .NET Core SDK

2.2.1. Installing on Windows operating systems

2.2.2. Installing on Linux-based operating systems

2.2.3. Installing on macOS

2.2.4. Building .NET Core Docker containers

2.3. Creating and running the "Hello World" console application

2.3.1. Before you build

2.3.2. Running a .NET Core application

2.4. Creating an ASP.NET Core web application

2.4.1. ASP.NET Core uses the Kestrel web server

2.4.2. Using a Startup class to initialize the web server

2.4.3. Run the "Hello World" web application

2.5. Creating an ASP.NET Core website from the template

2.6. Creating an ASP.NET Core website from the Yeoman generator

2.7. Deploying to a server

2.7.1. Publishing an application

2.7.2. Deploying to a Docker container

2.7.3. Packaging for distribution

2.8. Development tools available for .NET Core

2.8.1. OmniSharp

2.8.2. Visual Studio for Mac

2.8.3. Visual Studio 2017

2.9. Summary

3. How to Build with .NET Core

3.1. Key concepts to understand .NET Core’s build system

3.1.1. Introducing MSBuild

3.1.2. Creating .NET projects from the command line

3.1.3. Clearing up the terminology

3.2. CSV parser sample project

3.3. MSBuild introduction

3.3.1. PropertyGroup

3.3.2. Targets

3.3.3. ItemGroup

3.4. Dependencies

3.4.1. What is NuGet?

3.5. Targeting multiple frameworks

3.5.1. MSBuild conditions

3.6. Summary

4. Unit Testing with xUnit

4.1. Why write unit tests?

4.2. Business day calculator example code

4.3. xUnit - a .NET Core unit testing framework

4.4. Setting up the xUnit test project

4.5. Evaluating truth with xUnit facts

4.5.1. Running tests from development environments

4.6. When it’s impossible to prove all cases, use a theory

4.6.1. Theories with MemberData

4.7. Shared context between tests

4.7.1. Using the constructor for setup

4.7.2. Using Dispose for cleanup

4.7.3. Sharing context with class fixtures

4.7.4. Sharing context with collection fixtures

4.8. Getting output from xUnit tests

4.9. Traits

4.10. Summary

5. Working with Relational Databases

5.1. Using SQLite for prototyping

5.2. Planning the application and database schema

5.2.1. Tracking inventory

5.2.2. Creating tables in SQLite

5.3. Creating a data access library

5.3.1. Specifying relationships in data and code

5.3.2. Updating data

5.3.3. Managing inventory

5.3.4. Using transactions for consistency

5.4. Ordering new parts from suppliers

5.4.1. Creating an Order

5.4.2. Checking if parts need to be ordered

5.5. Summary

6. Simplify Data Access with Object-Relational Mappers

6.1. Dapper

6.1.1. Inserting rows with Dapper

6.1.2. The drawback of a micro-ORM

6.1.3. A brief introduction to dependency injection

6.1.4. Dependency injection in .NET Core

6.1.5. JSON-based configuration

6.1.6. When to build your own data access layer

6.2. Entity Framework Core

6.2.1. Using Entity Framework migrations to create the database

6.2.2. Running the tests using Entity Framework

6.3. Summary

7. Creating a Microservice

7.1. Writing an ASP.NET web service

7.1.1. Converting Markdown to HTML

7.1.2. Creating an ASP.NET web service

7.1.3. Testing the web service with Curl

7.2. Making HTTP calls

7.3. Making the service asynchronous

7.4. Getting data from Azure blob storage

7.4.1. Getting values from configuration

7.4.2. Creating the GetBlob method

7.4.3. Testing the new Azure storage operation

7.5. Uploading and receiving uploaded data

7.6. Listing containers and blobs

7.7. Deleting a blob

7.8. Summary

8. Debugging

8.1. Debugging applications with Visual Studio Code

8.1.1. Using the .NET Core debugger

8.2. Debugging with Visual Studio 2017

8.3. Debugging with Visual Studio for Mac

8.4. SOS

8.4.1. Easier to get started with a self-contained app

8.4.2. WinDBG/CDB

8.4.3. LLDB

8.4.4. Further exploration

8.5. Summary

9. Performance and Profiling

9.1. Creating a test application

9.2. xUnit.Performance makes it easy to run performance tests

9.3. Using PerfView on .NET Core applications

9.3.1. Getting a CPU profile

9.3.2. Analyzing a CPU profile

9.3.3. Looking at GC information

9.3.4. Exposing exceptions

9.3.5. Collecting performance data on Linux

9.4. Summary

10. Building World-Ready Applications

10.1. Going international

10.1.1. Setting up the sample application

10.1.2. Using the Microsoft logging extensions library

10.2. Internationalization

10.3. How to globalize an application

10.3.1. Using the Microsoft localization extensions library

10.3.2. Adding a resource file

10.3.3. Invariant culture

10.3.4. Using EventSource to emit events

10.3.5. Using EventListener to listen for events

10.3.6. Other considerations for globalization

10.4. Localizability review

10.5. Localization

10.6. Summary

11. Multiple Frameworks and Runtimes

11.1. Why does the .NET Core SDK support multiple frameworks and runtimes?

11.2. .NET Portability Analyzer

11.2.1. Installing and configuring the Visual Studio 2015 plugin

11.2.2. Sample .NET Framework project

11.2.3. Running the portability analyzer in Visual Studio

11.3. Supporting multiple frameworks

11.3.1. Using EventSource to replace EventProvider

11.3.2. Adding another framework to the project.json

11.3.3. Creating a NuGet package and checking the contents

11.3.4. Per-framework build options

11.4. Runtime-specific code

11.5. Summary

12. Preparing for Release

12.1. Preparing a NuGet package

12.1.1. How to handle project references

12.1.2. NuGet feeds

12.1.3. Packaging resource assemblies

12.2. Signing assemblies

12.2.1. How to generate a signing key

12.2.2. Delay-signing

12.2.3. Signing an assembly in .NET Core

12.3. Summary


Appendix A: Frameworks and Runtimes

Appendix B: xUnit command line options

Appendix C: What’s in the .NET Standard Library?

C.1. netstandard 1.0

C.2. netstandard 1.1

C.3. netstandard 1.2

C.4. netstandard 1.3

C.5. netstandard 1.4

C.6. netstandard 1.5

C.7. netstandard 1.6

Appendix D: NuGet Cache Locations

Appendix E: Microsoft.Extensions.Configuration

What's inside

  • Debugging .NET Core applications
  • Using PerfView to investigate performance issues
  • Enabling localization in a library
  • Creating unit tests with XUnit
  • Converting existing .NET projects to Core
  • Working with relational data stores
  • Interacting with web services
  • Tools for writing .NET Core apps
  • All examples are in C#

About the reader

This book is for developers who are familiar with a C-like language.

About the author

Dustin Metzgar has developed software professionally for 13 years. He has worked for many companies from startups to large enterprises before joining Microsoft. He specializes in performance in both .NET and Azure services and participated in a number of .NET Core projects. Dustin owns several products, including the Windows Workflow Foundation.