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

Easy to read and understand.

Eric Sweigart

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

Table of Contents detailed table of contents

1. Why .NET Core?

1.1. Architecting enterprise applications before .NET Core

1.2. If you’re a .NET Framework developer

1.2.1. Your .NET apps can be cross-platform

1.2.2. ASP.NET Core outperforms ASP.NET in the .NET Framework

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. .NET Core is not starting from scratch

1.3.3. Focus on performance

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.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. Additional resources

1.9. 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. Additional resources

2.10. Summary

3. How to build with .NET Core

3.1. Key concepts in .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. Introducing MSBuild

3.3.1. PropertyGroups

3.3.2. Targets

3.3.3. ItemGroups

3.4. Dependencies

3.5. Targeting multiple frameworks

3.6. Additional resources

3.7. Summary

4. Unit testing with xUnit

4.1. Why write unit tests?

4.2. Business-day calculator example

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.6. Running tests from development environments

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

4.8. Shared context between tests

4.8.1. Using the constructor for setup

4.8.2. Using Dispose for cleanup

4.8.3. Sharing context with class fixtures

4.8.4. Sharing context with collection fixtures

4.9. Getting output from xUnit tests

4.10. Traits

4.11. Additional resources

4.12. 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. Additional resources

5.6. Summary

6. Simplify data access with object-relational mappers

6.1. Dapper

6.1.1. Inserting rows with Dapper

6.1.2. Applying transactions to Dapper commands

6.1.3. The drawback of a micro-ORM

6.1.4. A brief introduction to dependency injection

6.1.5. Dependency injection in .NET Core

6.1.6. Configuring the application

6.1.7. When to build your own data-access layer

6.2. Entity Framework Core

6.2.1. Using EF migrations to create the database

6.2.2. Running the tests using EF

6.3. Additional resources

6.4. 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. Additional resources

7.9. 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. Additional resources

9.5. Summary

10. Building world-ready applications

10.1. Going international

10.1.1. Setting up the sample application

10.1.2. Making the sample application world-ready

10.2. Using a logging framework instead of writing to the console

10.2.1. Using the Microsoft .Extensions.Logging library

10.2.2. Internationalization

10.2.3. Globalization

10.2.4. Localizability review

10.3. Using the Microsoft localization extensions library

10.3.1. Testing right-to-left languages

10.3.2. Invariant culture

10.3.3. Using EventSource to emit events

10.3.4. Using EventListener to listen for events

10.4. Other considerations for globalization

10.5. Localization

10.6. Additional resources

10.7. 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 2017 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

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. Additional resources

11.6. 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. Generating a signing key

12.2.2. Delay-signing

12.2.3. Signing an assembly in .NET Core

12.3. Additional resources

12.4. Summary

Appendixes

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

C.8. netstandard 2.0

Appendix D: NuGet Cache Locations

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.


Manning Early Access Program (MEAP) Read chapters as they are written, get the finished eBook as soon as it’s ready, and receive the pBook long before it's in bookstores.
buy
MEAP combo $44.99 pBook + eBook + liveBook
MEAP eBook $35.99 pdf + ePub + kindle + liveBook

FREE domestic shipping on three or more pBooks

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