Book Image

Software Architecture with C# 10 and .NET 6 - Third Edition

By : Gabriel Baptista, Francesco Abbruzzese
4 (1)
Book Image

Software Architecture with C# 10 and .NET 6 - Third Edition

4 (1)
By: Gabriel Baptista, Francesco Abbruzzese

Overview of this book

Software architecture is the practice of implementing structures and systems that streamline the software development process and improve the quality of an app. This fully revised and expanded third edition, featuring the latest features of .NET 6 and C# 10, enables you to acquire the key skills, knowledge, and best practices required to become an effective software architect. Software Architecture with C# 10 and .NET 6, Third Edition features new chapters that describe the importance of the software architect, microservices with ASP.NET Core, and analyzing the architectural aspects of the front-end in the applications, including the new approach of .NET MAUI. It also includes a new chapter focused on providing a short introduction to artificial intelligence and machine learning using ML.NET, and updated chapters on Azure Kubernetes Service, EF Core, and Blazor. You will begin by understanding how to transform user requirements into architectural needs and exploring the differences between functional and non-functional requirements. Next, you will explore how to choose a cloud solution for your infrastructure, taking into account the factors that will help you manage a cloud-based app successfully. Finally, you will analyze and implement software design patterns that will allow you to solve common development problems. By the end of this book, you will be able to build and deliver highly scalable enterprise-ready apps that meet your business requirements.

Related Content you might be interested in

Current Title:

Small book image
Software Architecture with C# 10 and .NET 6 - Third Edition
Gabriel Baptista | Francesco Abbruzzese
Mar, 2022 | 714 pages
Small book image
Enterprise Application Development with C# 10 and .NET 6
Arun Kumar Tamirisa | Ravindra Akella | Suneel Kumar Kunani | Bhupesh Guptha Muthiyalu
Jun, 2022 | 586 pages
Small book image
Web Development with Blazor, 2e
Jimmy Engstroumlm
Mar, 2023 | 360 pages
Table of Contents (27 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Get in touch
Free Chapter
1
Understanding the Importance of Software Architecture
Understanding the Importance of Software Architecture
What is software architecture?
Software development process models
Gathering the right information to design high-quality software
Using design techniques as a helpful tool
Common cases where the requirements gathering process impacts system results
Case study – introducing World Wild Travel Club
Summary
Questions
Further reading
2
Non-Functional Requirements
Non-Functional Requirements
Technical requirements
Enabling scalability, availability, and resiliency with Azure and .NET 6
Performance issues that need to be considered when programming in C#
Usability – why inserting data takes too much time
The fantastic world of interoperability with .NET 6
Achieving security by design
Book use case – understanding the main types of .NET projects
Summary
Questions
Further reading
3
Documenting Requirements with Azure DevOps
Documenting Requirements with Azure DevOps
Technical requirements
Introducing Azure DevOps
Organizing your work using Azure DevOps
Managing system requirements in Azure DevOps
Use case – presenting use cases in Azure DevOps
Summary
Questions
Further reading
4
Deciding on the Best Cloud-Based Solution
Deciding on the Best Cloud-Based Solution
Technical requirements
Different software deployment models
Why are hybrid applications so useful in many cases?
Book use case – which is the best cloud solution?
Summary
Questions
Further reading
5
Applying a Microservice Architecture to Your Enterprise Application
Applying a Microservice Architecture to Your Enterprise Application
Technical requirements
What are microservices?
When do microservices help?
How does .NET deal with microservices?
Which tools are needed to manage microservices?
Summary
Questions
Further reading
6
Azure Kubernetes Service
Azure Kubernetes Service
Technical requirements
Kubernetes basics
Interacting with Azure Kubernetes clusters
Advanced Kubernetes concepts
Summary
Questions
Further reading
7
Interacting with Data in C# – Entity Framework Core
Interacting with Data in C# – Entity Framework Core
Technical requirements
Understanding ORM basics
Configuring Entity Framework Core
Entity Framework Core migrations
Compiled models
Querying and updating data with Entity Framework Core
Deploying your data layer
Understanding Entity Framework Core advanced features
Summary
Questions
Further reading
8
How to Choose Your Data Storage in the Cloud
How to Choose Your Data Storage in the Cloud
Technical requirements
Understanding the different repositories for different purposes
Choosing between SQL or NoSQL document-oriented databases
Azure Cosmos DB – an opportunity to manage a multi-continental database
Use case – storing data
Summary
Questions
Further reading
9
Working with Azure Functions
Working with Azure Functions
Technical requirements
Understanding the Azure Functions app
Programming Azure Functions using C#
Maintaining Azure Functions
Azure Durable Functions
Azure Functions roadmap
Use case – Implementing Azure Functions to send emails
Summary
Questions
Further reading
10
Design Patterns and .NET 6 Implementation
Design Patterns and .NET 6 Implementation
Technical requirements
Understanding design patterns and their purpose
Understanding the available design patterns in .NET 6
Summary
Questions
Further reading
11
Understanding the Different Domains in Software Solutions
Understanding the Different Domains in Software Solutions
Technical requirements
What are software domains?
Understanding domain-driven design
Entities and value objects
Layers and the Onion architecture
Aggregates
The repository and Unit of Work patterns
DDD entities and Entity Framework Core
Command Query Responsibility Segregation (CQRS) pattern
Command handlers and domain events
Event sourcing
Use case – understanding the domains of the use case
Summary
Questions
Further reading
12
Implementing Code Reusability in C# 10
Implementing Code Reusability in C# 10
Technical requirements
Understanding the principles of code reusability
Reusability in the development life cycle
Using .NET 6 for code reuse
How does C# deal with code reuse?
What if the code is not reusable?
I have my libraries. How do I promote them?
Use case – reusing code as a fast way to deliver good and safe software
Summary
Questions
Further reading
13
Applying Service-Oriented Architectures with .NET
Applying Service-Oriented Architectures with .NET
Technical requirements
Understanding the principles of the SOA approach
SOAP web services
REST web services
How does .NET 6 deal with SOA?
Use case – exposing WWTravelClub packages
Summary
Questions
Further reading
14
Implementing Microservices with .NET
Implementing Microservices with .NET
Technical requirements
Communication and data serialization
Implementing worker microservices with ASP.NET core
Implementing microservices with .NET worker services and message brokers
Summary
Questions
Further reading
15
Presenting ASP.NET Core MVC
Presenting ASP.NET Core MVC
Technical requirements
Understanding the presentation layers of web applications
Understanding the basics of ASP.NET Core
Understanding how ASP.NET Core MVC creates the response HTML
Understanding the connection between ASP.NET Core MVC and design principles
Summary
Questions
Further reading
16
Implementing Frontend Microservices with ASP.NET Core
Implementing Frontend Microservices with ASP.NET Core
Technical requirements
Frontends and micro-frontends
Application specifications and architecture
Defining the domain layer abstraction
Defining the data layer
Defining the application layer
Defining controllers and views
Summary
Further reading
17
Blazor WebAssembly
Blazor WebAssembly
Technical requirements
Blazor WebAssembly architecture
Blazor pages and components
Blazor forms and validation
Blazor advanced features
Third-party tools for Blazor WebAssembly
Use case – implementing a simple application in Blazor WebAssembly
Summary
Questions
Further reading
18
Native versus Web Clients
Native versus Web Clients
Technical requirements
Technologies focused on native development
Technologies focused on web development
Cross-platform technologies
A first look at .NET MAUI
Summary
Questions
Further reading
19
Artificial Intelligence and Machine Learning
Artificial Intelligence and Machine Learning
Technical requirements
Introduction to AI and machine learning
Classification of the most common artificial intelligence techniques
What is machine learning and why does it work?
From theory to practice: the role of a software architect in an ML project
ML.NET – Machine learning made for .NET
Summary
Questions
Further reading
20
Best Practices in Coding C# 10
Best Practices in Coding C# 10
Technical requirements
The simpler your code, the better a programmer you are
Using a version control system
Writing safe code in C#
.NET 6 tips and tricks for coding
Identifying well-written code
Applying this chapter to the WWTravelClub sample project
Summary
Questions
Further reading
21
Understanding DevOps Principles
Understanding DevOps Principles
Technical requirements
Describing DevOps
Understanding DevOps principles
Understanding SaaS
The WWTravelClub project approach
Summary
Questions
Further reading
22
Challenges of Applying CI & CD Scenarios
Challenges of Applying CI & CD Scenarios
Technical requirements
Understanding CI/CD
CI/CD and GitHub
Understanding the risks and challenges when using CI/CD
Understanding the WWTravelClub project approach
Summary
Questions
Further reading
23
Testing Your Enterprise Application
Testing Your Enterprise Application
Technical requirements
Understanding unit and integration tests
Understanding test-driven development
Functional tests
Defining C# test projects in Visual Studio
Automating functional tests in C#
Use case – automating unit and functional tests
Summary
Questions
Further reading
24
Answers
Answers
25
Other Books You May Enjoy
Other Books You May Enjoy
26
Index
Index

Understanding unit and integration tests

Delaying application testing until immediately after most of its functionalities have been implemented in their entirety must be avoided for the following reasons:

  • If a class or module has been incorrectly designed or implemented, it might have already influenced the way other modules were implemented. Therefore, at this point, fixing the problem might have a very high cost.
  • The possible combination of input that is needed to test all possible paths that execution can take grows exponentially with the number of modules or classes that are tested together. Thus, for instance, if the execution of a class method A can take three different paths, while the execution of another method B can take four paths, then testing A and B together would require 3 x 4 different inputs. In general, if we test several modules together, the total number of paths to test is the product of the number of paths to test in each module. If modules...
Previous Section
End of Section 3
Next Section