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.

Related Content you might be interested in

Current Title:

Small book image
C# 12 and .NET 8 – Modern Cross-Platform Development Fundamentals - Eighth Edition
Mark J. Price
Nov, 2023 | 828 pages
Small book image
Apps and Services with .NET 8
Mark Price
Dec, 2023 | 798 pages
Small book image
Learn C# Programming
Ankit Sharma | Raffaele Rialdi | Marius Bancila
Apr, 2020 | 636 pages
Table of Contents (18 chapters)
Preface
Preface
Where to find the code solutions
What this book covers
What you need for this book
Get in touch
1
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
Summary
Learn more on Discord
Free Chapter
2
Speaking C#
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
Summary
3
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
Summary
4
Writing, Debugging, and Testing Functions
Writing, Debugging, and Testing Functions
Writing functions
Debugging during development
Hot reloading during development
Logging during development and runtime
Unit testing
Throwing and catching exceptions in functions
Practicing and exploring
Summary
5
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
Summary
6
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
Summary
7
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
Summary
8
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
Summary
9
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
Summary
10
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
Summary
11
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
Summary
12
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
Summary
13
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
Summary
14
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
Summary
15
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
Summary
16
Epilogue
Epilogue
Next steps on your C# and .NET learning journey
The ninth edition, coming November 2024
Good luck!
17
Index
Index

Native ahead-of-time compilation

Native AOT produces assemblies that are:

  • Self-contained, meaning they can run on systems that do not have the .NET runtime installed.
  • Ahead-of-time (AOT) compiled to native code, meaning a faster startup time and a potentially smaller memory footprint.

Native AOT compiles IL code to native code at the time of publishing, rather than at runtime using the Just In Time (JIT) compiler. But native AOT assemblies must target a specific runtime environment like Windows x64 or Linux Arm.Since native AOT happens at publish time, you should remember that while you are debugging and live working on a project in your code editor, it is still using the runtime JIT compiler, not native AOT, even if you have AOT enabled in the project! However, some features that are incompatible with native AOT will be disabled or throw exceptions, and a source analyzer is enabled to show warnings about potential code incompatibilities.

Limitations of native AOT

Native AOT has limitations...

Previous Section
End of Section 2
Next Section