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

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

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...

Full description

Bibliographic Details
Other Authors: Baptista, Gabriel, author (author), Abbruzzese, Francesco, author
Format: eBook
Language:Inglés
Published: Birmingham : Packt Publishing [2024]
Edition:Fourth edition
Series:Expert insight.
Subjects:
Software architecture.
C# (Computer program language)
See on Biblioteca Universitat Ramon Llull:https://discovery.url.edu/permalink/34CSUC_URL/1im36ta/alma991009805126006719
Table of 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
  • Summary
  • Questions
  • Further reading
  • Chapter 3: Managing Requirements
  • Technical 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
  • Summary
  • Questions
  • Chapter 4: Best Practices in Coding C# 12
  • Technical requirements
  • 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
  • Summary
  • Questions
  • Further reading
  • Chapter 5: Implementing Code Reusability in C# 12
  • Technical requirements
  • 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
  • Summary
  • Questions
  • Further reading
  • Chapter 6: Design Patterns and .NET 8 Implementation
  • Technical requirements
  • 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
  • Summary
  • Questions
  • Further reading
  • Chapter 7: Understanding the Different Domains in Software Solutions
  • Technical requirements
  • 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
  • Summary
  • Questions
  • Further reading
  • Chapter 8: Understanding DevOps Principles and CI/CD
  • Technical requirements
  • 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
  • Summary
  • Questions
  • Chapter 9: Testing Your Enterprise Application
  • Technical requirements
  • 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
  • Summary
  • Questions
  • Further reading
  • Chapter 10: Deciding on the Best Cloud-Based Solution
  • Technical requirements
  • 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?
  • Summary
  • Questions
  • Further reading
  • Chapter 11: Applying a Microservice Architecture to Your Enterprise Application
  • Technical requirements
  • 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
  • Summary
  • Questions
  • Further reading
  • Chapter 12: How to Choose Your Data Storage in the Cloud
  • Technical requirements
  • 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
  • Summary
  • Questions
  • Further reading
  • Chapter 13: Interacting with Data in C# - Entity Framework Core
  • Technical requirements
  • 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
  • Summary
  • Questions
  • Further reading
  • Chapter 14: Implementing Microservices with .NET
  • Technical requirements
  • Communication and data serialization
  • Efficient and flexible binary serialization
  • The ProtoBuf language
  • ProtoBuf serialization.
  • Efficient and flexible RPC.

Similar Items