Вход в систему
Инструкция по поиску

Детальная информация

Название ATYPICAL ASP.NET CORE 6 DESIGN PATTERNS GUIDE: a solid adventure into architectural principles... and design patterns using .net 6, and c# 10.
Авторы MARCOTTE CARL-HUGO.
Выходные сведения [S.l.]: PACKT PUBLISHING LIMITED, 2022
Коллекция Электронные книги зарубежных издательств ; Общая коллекция
Тематика Application software — Development. ; Web applications. ; C (Computer program language) ; EBSCO eBooks
Тип документа Другой
Тип файла PDF
Язык Английский
Права доступа Доступ по паролю из сети Интернет (чтение, печать, копирование)
Ключ записи on1306205682
Дата создания записи 29.03.2022

Разрешенные действия

pdf/3206126.pdf –
Действие 'Прочитать' будет доступно, если вы выполните вход в систему или будете работать с сайтом на компьютере в другой сети Действие 'Загрузить' будет доступно, если вы выполните вход в систему или будете работать с сайтом на компьютере в другой сети
epub/3206126.epub –
Действие 'Загрузить' будет доступно, если вы выполните вход в систему или будете работать с сайтом на компьютере в другой сети
Группа Анонимные пользователи
Сеть Интернет
Место доступа Группа пользователей Действие
Локальная сеть ИБК СПбПУ Все
Прочитать Печать Загрузить
Интернет Авторизованные пользователи СПбПУ
Прочитать Печать Загрузить
Интернет Анонимные пользователи
  • 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
pdf/3206126.pdf

Количество обращений: 1 
За последние 30 дней: 0

Подробная статистика

epub/3206126.epub

Количество обращений: 0 
За последние 30 дней: 0

Подробная статистика