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

Understanding modern databases

Two of the most common places to store data are in a Relational Database Management System (RDBMS), such as SQL Server, PostgreSQL, MySQL, and SQLite, or in a NoSQL database such as Azure Cosmos DB, Redis, MongoDB, and Apache Cassandra.Relational databases were invented in the 1970s. They are queried with Structured Query Language (SQL). At the time, data storage costs were high, so they reduced data duplication as much as possible. Data is stored in tabular structures with rows and columns that are tricky to refactor once in production. They can be difficult and expensive to scale.NoSQL databases do not just mean “no SQL”; they can also mean “not only SQL.” They were invented in the 2000s, after the Internet and the web had become popular, and adopted many of the learnings from that era of software. They are designed for massive scalability and high performance and to make programming easier by providing maximum flexibility and...