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...
| Otros Autores: | , |
|---|---|
| Formato: | Libro electrónico |
| Idioma: | Inglés |
| Publicado: |
Birmingham :
Packt Publishing
[2024]
|
| Edición: | Fourth edition |
| Colección: | Expert insight.
|
| Materias: | |
| Ver en Biblioteca Universitat Ramon Llull: | https://discovery.url.edu/permalink/34CSUC_URL/1im36ta/alma991009805126006719 |
Tabla de Contenidos:
- 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.
