Book Image

C# 12 and .NET 8 – Modern Cross-Platform Development Fundamentals - Eighth Edition

By : Mark J. Price

4.7 (15)

Book Image

C# 12 and .NET 8 – Modern Cross-Platform Development Fundamentals - Eighth Edition

4.7 (15)

By: Mark J. Price

Overview of this book

This latest edition of the bestselling Packt series will give you a solid foundation to start building projects using modern C# and .NET with confidence. You'll learn about object-oriented programming; writing, testing, and debugging functions; and implementing interfaces. You'll take on .NET APIs for managing and querying data, working with the fi lesystem, and serialization. As you progress, you'll explore examples of cross-platform projects you can build and deploy, such as websites and services using ASP.NET Core. This latest edition integrates .NET 8 enhancements into its examples: type aliasing and primary constructors for concise and expressive code. You'll handle errors robustly through the new built-in guard clauses and explore a simplified implementation of caching in ASP.NET Core 8. If that's not enough, you'll also see how native ahead-of-time (AOT) compiler publish lets web services reduce memory use and run faster. You'll work with the seamless new HTTP editor in Visual Studio 2022 to enhance the testing and debugging process. You'll even get introduced to Blazor Full Stack with its new unified hosting model for unparalleled web development flexibility.

Preface

Where to find the code solutions

What this book covers

What you need for this book

Hello, C#! Welcome, .NET!

Hello, C#! Welcome, .NET!

Introducing this book and its contents

Setting up your development environment

Understanding .NET

Building console apps using Visual Studio 2022

Building console apps using Visual Studio Code

Making good use of the GitHub repository for this book

Looking for help

Practicing and exploring

Learn more on Discord

Free Chapter

Speaking C#

Introducing the C# language

Discovering your C# compiler version

Understanding C# grammar and vocabulary

Working with variables

Exploring more about console apps

Understanding async and await

Practicing and exploring

Controlling Flow, Converting Types, and Handling Exceptions

Controlling Flow, Converting Types, and Handling Exceptions

Operating on variables

Understanding selection statements

Understanding iteration statements

Storing multiple values in an array

Casting and converting between types

Handling exceptions

Checking for overflow

Practicing and exploring

Writing, Debugging, and Testing Functions

Writing, Debugging, and Testing Functions

Writing functions

Debugging during development

Hot reloading during development

Logging during development and runtime

Throwing and catching exceptions in functions

Practicing and exploring

Building Your Own Types with Object-Oriented Programming

Building Your Own Types with Object-Oriented Programming

Talking about OOP

Building class libraries

Storing data in fields

Working with methods and tuples

Controlling access with properties and indexers

Pattern matching with objects

Working with record types

Practicing and exploring

Implementing Interfaces and Inheriting Classes

Implementing Interfaces and Inheriting Classes

Setting up a class library and console application

Static methods and overloading operators

Making types safely reusable with generics

Raising and handling events

Implementing interfaces

Managing memory with reference and value types

Working with null values

Inheriting from classes

Casting within inheritance hierarchies

Inheriting and extending .NET types

Summarizing custom type choices

Practicing and exploring

Packaging and Distributing .NET Types

Packaging and Distributing .NET Types

The road to .NET 8

Understanding .NET components

Publishing your code for deployment

Native ahead-of-time compilation

Decompiling .NET assemblies

Packaging your libraries for NuGet distribution

Working with preview features

Practicing and exploring

Working with Common .NET Types

Working with Common .NET Types

Working with numbers

Working with text

Pattern matching with regular expressions

Storing multiple objects in collections

Working with spans, indexes, and ranges

Practicing and exploring

Working with Files, Streams, and Serialization

Working with Files, Streams, and Serialization

Managing the filesystem

Reading and writing with streams

Encoding and decoding text

Serializing object graphs

Working with environment variables

Practicing and exploring

Working with Data Using Entity Framework Core

Working with Data Using Entity Framework Core

Understanding modern databases

Setting up EF Core in a .NET project

Defining EF Core models

Querying EF Core models

Loading and tracking patterns with EF Core

Modifying data with EF Core

Practicing and exploring

Querying and Manipulating Data Using LINQ

Querying and Manipulating Data Using LINQ

Writing LINQ expressions

LINQ in practice

Sorting and more

Using LINQ with EF Core

Joining, grouping, and lookups

Aggregating and paging sequences

Practicing and exploring

Introducing Web Development Using ASP.NET Core

Introducing Web Development Using ASP.NET Core

Understanding ASP.NET Core

Structuring projects

Building an entity model for use in the rest of the book

Understanding web development

Practicing and exploring

Building Websites Using ASP.NET Core Razor Pages

Building Websites Using ASP.NET Core Razor Pages

Exploring ASP.NET Core

Exploring ASP.NET Core Razor Pages

Using Entity Framework Core with ASP.NET Core

Configuring services and the HTTP request pipeline

Practicing and exploring

Building and Consuming Web Services

Building and Consuming Web Services

Building web services using the ASP.NET Core Web API

Creating a web service for the Northwind database

Documenting and testing web services

Consuming web services using HTTP clients

Practicing and exploring

Building User Interfaces Using Blazor

Building User Interfaces Using Blazor

History of Blazor

Reviewing the Blazor Web App project template

Building components using Blazor

Enabling client-side execution using WebAssembly

Practicing and exploring

Epilogue

Next steps on your C# and .NET learning journey

The ninth edition, coming November 2024

Index

Customer Reviews

4.7 (15)

5 star

80%

4 star

13.3%

3 star

0

2 star

6.7%

1 star

0

Packaging your libraries for NuGet distribution

Before we learn how to create and package our own libraries, we will review how a project can use an existing package.

Referencing a NuGet package

Let’s say that you want to add a package created by a third-party developer, for example, Newtonsoft.Json, a popular package for working with the JavaScript Object Notation (JSON) serialization format:

In the AssembliesAndNamespaces project, add a reference to the Newtonsoft.Json NuGet package, either using the GUI for Visual Studio 2022 or the dotnet add package command for Visual Studio Code.
Open the AssembliesAndNamespaces.csproj file and note that a package reference has been added, as shown in the following markup:
```
<ItemGroup>
  <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
</ItemGroup>
```

If you have a more recent version of the Newtonsoft.Json package, then it has been updated...