Book Image

C# 11 and .NET 7 – Modern Cross-Platform Development Fundamentals - Seventh Edition

By : Mark J. Price

4.2 (5)

Book Image

C# 11 and .NET 7 – Modern Cross-Platform Development Fundamentals - Seventh Edition

4.2 (5)

By: Mark J. Price

Overview of this book

Extensively revised to accommodate the latest features that come with C# 11 and .NET 7, this latest edition of our guide will get you coding in C# with confidence. You’ll learn object-oriented programming, writing, testing, and debugging functions, implementing interfaces, and inheriting classes. Next, you’ll take on .NET APIs for performing tasks like managing and querying data, working with the filesystem, and serialization. As you progress, you’ll also explore examples of cross-platform projects you can build and deploy, such as websites and services using ASP.NET Core. Instead of distracting you with unnecessary graphical user interface code, the first eleven chapters will teach you about C# language constructs and many of the .NET libraries through simple console applications. Having mastered the basics, you’ll then start building websites, web services, and browser apps. By the end of this book, you’ll be able to create rich web experiences and have a solid grasp of object-oriented programming that you can build upon.

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!

Setting up your development environment

Understanding .NET

Building console apps using Visual Studio 2022

Building console apps using Visual Studio Code

Exploring code using Polyglot Notebooks

Reviewing the folders and files for projects

Making good use of the GitHub repository for this book

Looking for help

Practicing and exploring

Free Chapter

Speaking C#

Introducing the C# language

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 within fields

Writing and calling methods

Splitting classes using partial

Controlling access with properties and indexers

More about methods

Pattern matching with objects

Working with records

Practicing and exploring

Implementing Interfaces and Inheriting Classes

Implementing Interfaces and Inheriting Classes

Setting up a class library and console application

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

Writing better code

Practicing and exploring

Packaging and Distributing .NET Types

Packaging and Distributing .NET Types

The road to .NET 7

Understanding .NET components

Publishing your code for deployment

Decompiling .NET assemblies

Packaging your libraries for NuGet distribution

Porting from .NET Framework to modern .NET

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

Working with network resources

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

Reading and writing with random access handles

Serializing object graphs

Practicing and exploring

Working with Data Using Entity Framework Core

Working with Data Using Entity Framework Core

Understanding modern databases

Setting up EF Core

Defining EF Core models

Querying EF Core models

Loading patterns with EF Core

Modifying data with EF Core

Working with transactions

Defining Code First EF Core models

Practicing and exploring

Querying and Manipulating Data Using LINQ

Querying and Manipulating Data Using LINQ

Writing LINQ expressions

Using LINQ with EF Core

Sweetening LINQ syntax with syntactic sugar

Using multiple threads with parallel LINQ

Creating your own LINQ extension methods

Working with LINQ to XML

Practicing and exploring

Introducing Web Development Using ASP.NET Core

Introducing Web Development Using ASP.NET Core

Understanding ASP.NET Core

New features in 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

Using Razor class libraries

Configuring services and the HTTP request pipeline

Enabling HTTP/3 support

Practicing and exploring

Building Websites Using the Model-View-Controller Pattern

Building Websites Using the Model-View-Controller Pattern

Setting up an ASP.NET Core MVC website

Exploring an ASP.NET Core MVC website

Customizing an ASP.NET Core MVC website

Querying a database and using display templates

Improving scalability using asynchronous tasks

Practicing and exploring

Building and Consuming Web Services

Building and Consuming Web Services

Building web services using the ASP.NET Core Web API

Documenting and testing web services

Consuming web services using HTTP clients

Implementing advanced features for web services

Building web services using Minimal APIs

Practicing and exploring

Building User Interfaces Using Blazor

Building User Interfaces Using Blazor

Understanding Blazor

Comparing Blazor project templates

Building components using Blazor Server

Building components using Blazor WebAssembly

Improving Blazor WebAssembly apps

Practicing and exploring

Epilogue

The next steps on your C# and .NET learning journey

The eighth edition coming November 2023

Index

Customer Reviews

4.2 (5)

5 star

60%

4 star

20%

3 star

0

2 star

20%

1 star

0

Working with transactions

Every time you call the SaveChanges method, an implicit transaction is started so that if something goes wrong, it will automatically roll back all the changes. If the multiple changes within the transaction succeed, then the transaction and all changes are committed.

Transactions maintain the integrity of your database by applying locks to prevent reads and writes while a sequence of changes is occurring.

Transactions are ACID, which is an acronym explained in the following list:

A is for atomic. Either all the operations in the transaction commit, or none of them do.
C is for consistent. The state of the database before and after a transaction is consistent. This is dependent on your code logic; for example, when transferring money between bank accounts, it is up to your business logic to ensure that if you debit $100 from one account, you credit $100 to the other account.
I is for isolated. During a transaction, changes are...