Software Architecture with C# 12 And . NET 8 : Build Enterprise Applications Using Microservices, DevOps, EF Core, and Design Patterns for Azure / Gabriel Baptista and Francesco Abbruzzese.

Format:

Book

Author/Creator:

Baptista, Gabriel, author.

Abbruzzese, Francesco, author.

Series:

Expert insight.

Expert insight

Language:

English

Subjects (All):

Software architecture.

C# (Computer program language).

Physical Description:

1 online resource (757 pages)

Edition:

Fourth edition.

Place of Publication:

Birmingham : Packt Publishing, [2024]

Biography/History:

Baptista Gabriel: Gabriel Baptista has been working with software development since the beginning of. NET. Today, his main contributions are managing numerous projects for retail and industry. He is an Azure Platform-as-a-Service (PaaS) solution specialist, teaches at Computing Engineering universities, and helps tech startups as a mentor. Abbruzzese Francesco: Francesco Abbruzzese dedicates his life to his two great passions: software and powerlifting. He is the author of the MVC Controls Toolkit and the Blazor Controls Toolkit libraries. He has contributed to the diffusion and evangelization of the Microsoft web stack since the first version of ASP. NET. His company, Mvcct Team, offers web applications, tools, and services for web technologies. He has moved from AI systems, where he implemented one of the first decision support systems for financial institutions, to top-10 video game titles such as Puma Street Soccer.

Summary:

Software Architecture with C# 12 and .NET 8 puts high-level design theory to work in a .NET context, teaching you the key skills, technologies, and best practices required to become an effective .NET software architect. This fourth edition puts emphasis on a case study that will bring your skills to life. You’ll learn how to choose between different architectures and technologies at each level of the stack. You’ll take an even closer look at Blazor and explore OpenTelemetry for observability, as well as a more practical dive into preparing .NET microservices for Kubernetes integration. Divided into three parts, this book starts with the fundamentals of software architecture, covering C# best practices, software domains, design patterns, DevOps principles for CI/CD, and more. The second part focuses on the technologies, from choosing data storage in the cloud to implementing frontend microservices and working with Serverless. You’ll learn about the main communication technologies used in microservices, such as REST API, gRPC, Azure Service Bus, and RabbitMQ. The final part takes you through a real-world case study where you’ll create software architecture for a travel agency. By the end of this book, you will be able to transform user requirements into technical needs and deliver highly scalable enterprise software architectures.

Contents:

Cover

Copyright

Contributots

Table of Contents

Preface

Chapter 1: Understanding the Importance of Software Architecture

What is software architecture?

Creating an Azure account

Software development process models

Reviewing traditional software development process models

Understanding the waterfall model principles

Analyzing the incremental model

Understanding agile software development process models

Scaling agile throughout a company

Gathering the right information to design high-quality software

Understanding the requirements gathering process

Detecting exact user needs

Analyzing requirements

Writing the specifications

Understanding the principles of scalability, robustness, security, and performance

Reviewing the specification

Using design techniques as a helpful tool

Design Thinking

Design Sprint

Common cases where the requirements gathering process impacts system results

Case 1 - my website is too slow to open that page!

Understanding backend caching

Applying asynchronous programming

Dealing with object allocation

Getting better database access

Case 2 - the user's needs are not properly implemented

Case 3 - the usability of the system does not meet the user's needs

Summary

Questions

Further reading

Chapter 2: Non-Functional Requirements

Technical requirements

Enabling scalability, availability, and resiliency with Azure and .NET 8

Creating a scalable web app in Azure

Vertical scaling (scaling up)

Horizontal scaling (scaling out)

Creating a scalable web app with .NET 8

Performance issues that need to be considered when programming in C#

String concatenation

Exceptions

Multithreading environments for better results - dos and don'ts

Software Usability: How to design effective user interfaces.

Designing fast selection logic

Selecting from a huge number of items

Interoperability with .NET 8

Tip - creating a service in Linux

Achieving security by design

List of practices for achieving a safe architecture

Authentication

Sensitive data

Web security

Chapter 3: Managing Requirements

Introducing Azure DevOps

Managing system requirements in Azure DevOps

Epic work items

Feature work items

Product Backlog items/User Story work items

Azure DevOps repository

Package feeds

Test Plans

Pipelines

Usage

Introducing GitHub projects

Chapter 4: Best Practices in Coding C# 12

The simpler your code, the better a programmer you are

Maintainability index

Cyclomatic complexity

Depth of inheritance

Class coupling

Number of lines of code

Using a version control system

Dealing with version control systems in teams

Writing safe code in C#

try-catch

try-finally and using

The IDisposable interface

.NET 8 tips and tricks for coding

Identifying well-written code

Understanding and applying tools that can evaluate C# code

Applying extension tools to analyze code

Applying SonarAnalyzer

Checking the final code after analysis

Chapter 5: Implementing Code Reusability in C# 12

Understanding the principles of code reusability

What code reuse is not

What code reuse is

Reusability in the development life cycle

Using .NET 8 for code reuse

Creating a reusable class library

How does C# deal with code reuse?

Object-oriented analysis

Generics

What if the code is not reusable?

I have my libraries. How do I promote them?.

Documenting .NET libraries using DocFX

Documenting a web API using Swagger

Chapter 6: Design Patterns and .NET 8 Implementation

Understanding design patterns and their purpose

Builder pattern

Factory pattern

Singleton pattern

Proxy pattern

Command pattern

Publisher/Subscriber pattern

Dependency Injection pattern

Understanding the design patterns available in .NET

Chapter 7: Understanding the Different Domains in Software Solutions

What are software domains?

Understanding DDD

Relationships among Bounded Contexts

Entities

Entity-level validation in .NET

DDD entities in .NET

Value objects

Aggregates

Domain events

Common DDD patterns and architectures

Classic layers architecture

Onion architecture

Repository pattern

Unit of work pattern

Classic repository pattern versus DDD aggregates

Command Query Responsibility Segregation (CQRS) pattern

Event sourcing

Command handlers and aggregate events

Chapter 8: Understanding DevOps Principles and CI/CD

Describing DevOps

Understanding DevOps principles

CI

CD

Risks and challenges when using CI/CD

Disabling continuous production deployment

Incomplete features

An unstable solution for testing

Continuous feedback

Tools to facilitate DevOps implementation

Azure DevOps

GitHub

Application Insights

Test and Feedback

Chapter 9: Testing Your Enterprise Application

Understanding unit and integration tests

Automating unit and integration tests

Writing automated (unit and integration) tests.

Acceptance tests: writing functional and performance tests

Understanding the basics of test-driven development

Functional tests

Behavior-Driven Development (BDD)

Defining C# test projects in Visual Studio

Using the xUnit test framework

Advanced test preparation and tear-down scenarios

Mocking interfaces with Moq

Automating functional tests in C#

Testing the staging application

Testing the staging application with Selenium

Testing a controlled application

Recording tests with Selenium IDE

Chapter 10: Deciding on the Best Cloud-Based Solution

Different software deployment models

IaaS and Azure opportunities

Security responsibility in IaaS

PaaS - a world of opportunities for developers

Web apps

SQL databases

Azure Cognitive Services

SaaS - just sign in and get started!

Understanding what serverless means

Comparing IaaS, PaaS, SaaS, and FaaS

Why are hybrid applications so useful in many cases?

Chapter 11: Applying a Microservice Architecture to Your Enterprise Application

What are microservices?

Microservices and the evolution of the concept of modules

Microservice design principles

The independence of design choices

Independence from the deployment environment

Loose coupling

No chained requests/responses

Containers and Docker

When do microservices help?

Layered architectures and microservices

The presentation layer

When is it worth considering microservice architectures?

How does .NET deal with microservices?

.NET communication facilities

Resilient task execution

Using generic hosts

Visual Studio support for Docker

Analyzing the Docker file

Publishing the project.

Azure and Visual Studio support for microservice orchestration

Which tools are needed to manage microservices?

Defining your private Docker registry in Azure

Chapter 12: How to Choose Your Data Storage in the Cloud

Understanding the different repositories for different purposes

Relational databases

NoSQL databases

Document-oriented database

Graph database

Key-value database

Wide-column store database

Redis

Azure storage accounts

Choosing between SQL and NoSQL document-oriented databases

Azure Cosmos DB - an opportunity to manage a multi-continental database

Creating an Azure Cosmos DB account

Creating an Azure Cosmos DB container

Accessing Azure Cosmos DB

Defining database consistency

The Cosmos DB client

The Cosmos DB Entity Framework Core provider

Chapter 13: Interacting with Data in C# - Entity Framework Core

Understanding ORM basics

Configuring Entity Framework Core

Defining DB entities

Defining the mapped collections

Completing the mapping configuration

Entity Framework Core migrations

Understanding stored procedures and direct SQL commands

Compiled models

Querying and updating data with Entity Framework Core

Returning data to the presentation layer

Issuing direct SQL commands

Handling transactions

Deploying your data layer

How data and domain layers communicate with other layers

Understanding Entity Framework Core advanced features

Chapter 14: Implementing Microservices with .NET

Communication and data serialization

Efficient and flexible binary serialization

The ProtoBuf language

ProtoBuf serialization.

Efficient and flexible RPC.

Notes:

Includes index.

Description based on publisher supplied metadata and other sources.

Description based on print version record.

ISBN:

9781805122456

1805122452

OCLC:

1424952059