?

Details
Table Card RUSMARC
Title: ATYPICAL ASP.NET CORE 6 DESIGN PATTERNS GUIDE: a solid adventure into architectural principles... and design patterns using .net 6, and c# 10.
Creators: MARCOTTE CARL-HUGO.
Imprint: [S.l.]: PACKT PUBLISHING LIMITED, 2022
Collection: Электронные книги зарубежных издательств; Общая коллекция
Subjects: Application software — Development.; Web applications.; C (Computer program language); EBSCO eBooks
Document type: Other
File type: PDF
Language: English
Rights: Доступ по паролю из сети Интернет (чтение, печать, копирование)
Record key: on1306205682

Allowed Actions:

pdf/3206126.pdf –
Action 'Read' will be available if you login or access site from another network Action 'Download' will be available if you login or access site from another network
epub/3206126.epub –
Action 'Download' will be available if you login or access site from another network

Group: Anonymous

Network: Internet

Document access rights

Network User group Action
ILC SPbPU Local Network All Read Print Download
Internet Authorized users SPbPU Read Print Download
-> Internet Anonymous

Table of Contents

  • Preface
  • Section 1: Principles and Methodologies
  • Chapter 1: Introduction
    • What is a design pattern?
    • Anti-patterns and code smells
      • Anti-patterns
        • Anti-pattern – God Class
      • Code smells
        • Code smell – Control Freak
        • Code smell – Long Methods
    • Understanding the web – request/response
    • Getting started with .NET
      • .NET SDK versus runtime
      • .NET 5+ versus .NET Standard
      • Visual Studio Code versus Visual Studio versus the command-line interface
        • An overview of project templates
        • Running and building your program
      • Technical requirements
    • Summary
    • Questions
    • Further reading
  • Chapter 2: Automated Testing
    • An overview of automated testing
      • Unit testing
      • Integration testing
      • End-to-end testing
      • Other types of tests
      • Picking the right test style
      • Testing approaches
      • Refactoring
      • Technical debt
    • Testing .NET applications
      • Creating an xUnit test project
      • Getting started with xUnit
        • Facts
        • Assertions
        • Theories
        • Closing words
      • Arrange, Act, Assert
      • Organizing your tests
        • Unit tests
        • Integration tests
      • ASP.NET Core integration testing
        • Classic web application
        • Minimal hosting
    • Important testing principles
    • Summary
    • Questions
    • Further reading
  • Chapter 3: Architectural Principles
    • The SOLID principles
      • Single responsibility principle (SRP)
        • Project – BookStore
        • What is an interface?
      • Open/Closed principle (OCP)
        • Project – IAttacker
      • Liskov substitution principle (LSP)
        • Project – HallOfFame
        • Conclusion
      • Interface segregation principle (ISP)
        • Project – Ninja versus Pirate
        • Project – Bookstore update
        • Conclusion
      • Dependency inversion principle (DIP)
        • Direct dependency
        • Inverted dependency
        • Inverting subsystems using DIP
        • Project – Dependency inversion
        • Conclusion
        • What’s next?
    • Other important principles
      • Separation of concerns
      • Don’t repeat yourself (DRY)
      • Keep it simple, stupid (KISS)
    • Summary
    • Questions
    • Further reading
  • Section 2: Designing for ASP.NET Core
  • Chapter 4: The MVC Pattern Using Razor
    • The Model View Controller design pattern
      • Goal
      • Design
      • Anatomy of ASP.NET Core MVC
        • Directory structure
        • Controller
        • Model
        • View
        • Default routing
      • Conclusion
    • The View Model design pattern
      • Goal
      • Design
      • Project – View models (a list of students)
      • Conclusion
    • Summary
    • Questions
    • Further reading
  • Chapter 5: The MVC Pattern for Web APIs
    • An overview of REST
      • HTTP methods
      • Status code
      • HTTP headers
      • Versioning
        • Default versioning strategy
        • Versioning strategy
      • Wrapping up
    • The Model View Controller design pattern
      • Goal
      • Design
      • Anatomy of ASP.NET Core web APIs
        • The entry point
        • Directory structure
        • Controller
        • Returning values
        • Attribute routing
      • Conclusion
    • The Data Transfer Object design pattern
      • Goal
      • Design
      • Project – DTO
      • Conclusion
    • API contracts
    • Summary
    • Questions
    • Further reading
  • Chapter 6: Understanding the Strategy, Abstract Factory, and Singleton Design Patterns
    • The Strategy design pattern
      • Goal
      • Design
      • Project – Strategy
      • Conclusion
    • The Abstract Factory design pattern
      • Goal
      • Design
      • Project – AbstractVehicleFactory
      • Conclusion
    • The Singleton design pattern
      • Goal
      • Design
      • An alternate (better) way
      • Code smell – Ambient Context
      • Conclusion
    • Summary
    • Questions
  • Chapter 7: Deep Dive into Dependency Injection
    • What is dependency injection?
      • The composition root
      • Registering your features elegantly
      • Object lifetime
      • Code smell – Control Freak
    • Using external IoC containers
    • Revisiting the Strategy pattern
      • Constructor injection
      • Property injection
      • Method injection
      • Project – Strategy
        • Adding the View Model
        • Adding a guard clause
      • Conclusion
    • Revisiting the Singleton pattern
      • Project – Application state
      • Project – Wishlist
      • Conclusion
    • Understanding the Service Locator pattern
      • Project – ServiceLocator
        • Implementing method injection
        • Implementing constructor injection
        • Implementing a minimal API
      • Conclusion
    • Revisiting the Factory pattern
      • Project – Factory
      • Conclusion
    • Summary
    • Questions
    • Further reading
  • Chapter 8: Options and Logging Patterns
    • The Options pattern
      • Getting started
        • IOptionsMonitor
        • IOptionsFactory
        • IOptionsSnapshot
        • IOptions
      • Project – CommonScenarios
        • Named options
        • Using settings
      • Project – OptionsConfiguration
        • Implementing a configurator object
        • Using multiple configurator objects
        • Exploring other configuration possibilities
      • Project – OptionsValidation
        • Eager validation
        • Data annotations
        • Validation types
      • Project – OptionsValidationFluentValidation
      • Workaround – Injecting options directly
      • Conclusion
    • Becoming familiar with .NET logging abstractions
      • About logging
      • Writing logs
      • Log levels
      • Logging providers
      • Configuring logging
      • Structured logging
      • Conclusion
    • Summary
    • Questions
    • Further reading
  • Section 3: Designing at Component Scale
  • Chapter 9: Structural Patterns
    • Implementing the Decorator design pattern
      • Goal
      • Design
      • Project – Adding behaviors
        • DecoratorA
        • DecoratorB
      • Project – Decorator using Scrutor
      • Conclusion
    • Implementing the Composite design pattern
      • Goal
      • Design
      • Project – BookStore
      • Conclusion
    • Implementing the Adapter design pattern
      • Goal
      • Design
      • Project – Greeter
      • Conclusion
    • Implementing the Façade design pattern
      • Goal
      • Design
      • Project – The façades
        • Opaque façade
        • Transparent façade
        • The program
        • Flexibility in action
        • Alternative façade patterns
      • Conclusion
    • Summary
    • Questions
    • Further reading
  • Chapter 10: Behavioral Patterns
    • Implementing the Template Method pattern
      • Goal
      • Design
      • Project – Building a search machine
      • Conclusion
    • Implementing the Chain of Responsibility pattern
      • Goal
      • Design
      • Project – Message interpreter
      • Project – Improved message interpreter
      • Project – A final, finer-grained design
      • Conclusion
    • Summary
    • Questions
  • Chapter 11: Understanding the Operation Result Design Pattern
    • The Operation Result pattern
      • Goal
      • Design
      • Project – Implementing different Operation Result patterns
        • The consumer
        • The simplest form of the Operation Result pattern
        • A single error message
        • Adding a return value
        • Multiple error messages
        • Adding message severity
        • Sub-classes and factories
      • Advantages and disadvantages
        • Advantages
        • Disadvantages
    • Summary
    • Questions
    • Further reading
  • Section 4: Designing at Application Scale
  • Chapter 12: Understanding Layering
    • Introducing layering
      • Classic layering model
      • Splitting the layers
      • Layers versus tiers versus assemblies
        • What is an assembly?
    • Responsibilities of the common layers
      • Presentation
      • Domain
        • Rich domain model
        • Anemic domain model
        • Service layer
      • Data
        • Repository pattern
        • Unit of Work pattern
    • Abstract layers
    • Sharing the model
    • Clean Architecture
    • Implementing layering in real life
      • To be or not to be a purist?
      • Building a façade over a database
    • Summary
    • Questions
    • Further reading
  • Chapter 13: Getting Started with Object Mappers
    • Object mapper
      • Goal
      • Design
      • Project – Mapper
      • Code smell – Too many dependencies
      • Pattern – Aggregate Services
      • Pattern – Mapping Façade
      • Project – Mapping service
      • Project – AutoMapper
      • Conclusion
    • Summary
    • Questions
    • Further reading
  • Chapter 14: Mediator and CQRS Design Patterns
    • A high-level overview of Vertical Slice Architecture
    • Implementing the Mediator pattern
      • Goal
      • Design
      • Project – Mediator (IMediator)
      • Project – Mediator (IChatRoom)
      • Conclusion
    • Implementing the CQRS pattern
      • Goal
      • Design
      • Project – CQRS
      • Code smell – Marker Interfaces
        • Metadata
        • Dependency identifier
      • Conclusion
    • Using MediatR as a mediator
      • Project – Clean Architecture with MediatR
      • Conclusion
    • Summary
    • Questions
    • Further reading
  • Chapter 15: Getting Started with Vertical Slice Architecture
    • Vertical Slice Architecture
      • What are the advantages and disadvantages?
      • Anti-pattern – Big Ball of Mud
      • Project – Vertical Slice Architecture
        • Project organization
        • Exploring a feature
        • Request validation
        • Testing
      • Continuing your journey
      • Conclusion
    • Summary
    • Questions
    • Further reading
  • Chapter 16: Introduction to Microservices Architecture
    • What are microservices?
      • Cohesive unit of business
      • Ownership of data
      • Microservice independence
    • An introduction to event-driven architecture
      • Domain events
      • Integration events
      • Application events
      • Enterprise events
      • Conclusion
    • Getting started with message queues
      • Conclusion
    • Implementing the Publish-Subscribe pattern
      • Message brokers
      • The event sourcing pattern
      • Example
      • Conclusion
    • Introducing Gateway patterns
      • Gateway Routing pattern
      • Gateway Aggregation pattern
      • Backends for Frontends pattern
      • Mixing and matching gateways
      • Conclusion
    • Revisiting the CQRS pattern
      • Conclusion
    • Exploring the Microservice Adapter pattern
      • Adapting an existing system to another
      • Decommissioning a legacy application
      • Adapting an event broker to another
      • Conclusion
    • Summary
    • Questions
    • Further reading
  • Section 5: Designing the Client Side
  • Chapter 17: ASP.NET Core User Interfaces
    • Getting familiar with Razor Pages
      • Design
      • Routing
      • Conclusion
    • Organizing the user interface
      • Partial views
        • Project – Shared form
        • Conclusion
      • Tag Helpers
        • Built-in Tag Helpers
        • Creating a custom Tag Helper
        • Creating an RSS feed TagHelperComponent
        • Conclusion
      • View components
        • Project – Reusable employee count
        • Conclusion
    • Display and editor templates
      • Display templates
      • Editor templates
      • Project – Composite BookStore revisited
      • Conclusion
    • Summary
    • Questions
    • Further reading
  • Chapter 18: A Brief Look into Blazor
    • Overview of Blazor Server
    • Overview of Blazor WebAssembly
    • Getting familiar with Razor components
      • Creating Razor components
        • C#-only components
        • Razor-only components
        • Razor and C# hybrid components
      • CSS isolation
      • Component life cycle
      • Event handling
    • The Model-View-Update pattern
      • Goal
      • Design
      • Project – Counter
      • Conclusion
    • A medley of Blazor features
    • Summary
    • Questions
    • Further reading
    • An end is simply a new beginning
  • Appendices
  • Appendix A
    • Older C# features
      • The null-coalescing operator (C# 2.0)
      • Expression-bodied member (C# 6-7)
      • Throw expressions (C# 7.0)
      • Tuples (C# 7.0+)
      • Default literal expressions (C# 7.1)
      • Switch expressions (C# 8)
      • Discards (C# 7)
      • Async main (C# 7.1)
      • User-defined conversion operators (C# 1)
      • Local functions (C# 7) and a static local function (C# 8)
    • What’s new in .NET 5 and C# 9?
      • Top-level statements
      • Target-typed new expressions
      • Init-only properties
      • Record classes
        • Simplifying the record creation
        • The with keyword
        • Deconstruction
        • Equality comparison
        • Conclusion
    • What’s new in .NET 6 and C# 10?
      • File-scoped namespaces
      • Global using directives
      • Implicit using directives
      • Constant interpolated strings
      • Record struct
      • Minimal hosting model
      • Minimal APIs
      • Nullable reference types
  • Appendix B
    • An overview of containers
    • Docker
      • Docker Compose
    • Orchestration
      • Project Tye
      • Kubernetes
    • Scaling
    • Summary
    • Further reading
  • Assessment Answers
    • Chapter 1
    • Chapter 2
    • Chapter 3
    • Chapter 4
    • Chapter 5
    • Chapter 6
    • Chapter 7
    • Chapter 8
    • Chapter 9
    • Chapter 10
    • Chapter 11
    • Chapter 12
    • Chapter 13
    • Chapter 14
    • Chapter 15
    • Chapter 16
    • Chapter 17
    • Chapter 18
  • Acronyms Lexicon
    • Other Books You May Enjoy
  • PacktPage
  • Other Books You May Enjoy
  • Index

Usage statistics

pdf/3206126.pdf

stat Access count: 0
Last 30 days: 0
Detailed usage statistics

epub/3206126.epub

stat Access count: 0
Last 30 days: 0
Detailed usage statistics