Architecting ASP.NET Core Applications, 3rd Edition: An atypical design patterns guide for .NET 8, C# 12, and beyond / Архитектура приложений ASP.NET Core, 3-е издание: Руководство по нетипичным паттернам проектирования для .NET 8, C# 12 и далее Год издания: 2024 Автор: Marcotte Carl-Hugo / Маркотт Карл-Хьюго Издательство: Packt Publishing ISBN: 978-1-80512-338-5 Язык: Английский Формат: PDF, EPUB Качество: Издательский макет или текст (eBook) Интерактивное оглавление: Да Количество страниц: 807 Описание: Backend design like you’ve never seen it before – a guide to building SOLID ASP.NET Core web apps that stand the test of time. Featuring more Minimal APIs, more testing, more building blocks, and the modular monolith! Key Features Apply design patterns hands-on and learn to treat them as simple building blocks Refactor code toward modern application design like feature-based vertical slice and clean architecture Discover architectural principles and mix patterns together to understand how to design flexible software Book Description This unique ASP.NET Core book will fill in the gaps you’re missing in your REST API and backend designs. Learn how to build robust, maintainable, and flexible apps using Gang of Four (GoF) design patterns and modern architectural principles. This new edition is updated for .NET 8 and focuses exclusively on the backend, with new content on the REPR pattern, black-box testing, and building modular monoliths. You’ll start by covering foundational concepts like REST, the SOLID principles, Minimal APIs, dependency injection, and other ASP.NET Core 8 mechanisms. Then, you’ll learn to develop components using design patterns, including many from the GoF. Finally, you’ll explore organizing your application code with patterns that vary from layers to feature-oriented vertical slice designs, touching on CQRS and microservices along the way. This is not a cookbook. You’ll instead understand how business-oriented building blocks work, how to write them, and how to assemble them to make your own APIs instead of getting stuck with recipes that never fit your real-world needs. What you will learn Apply the SOLID principles for building flexible and maintainable software Test your apps effectively with automated tests, including black-box testing Enter the path of ASP.NET Core dependency injection mastery Work with GoF design patterns such as strategy, decorator, facade, and composite Design REST APIs using Minimal APIs and MVC Discover layering techniques and the tenets of clean architecture Use feature-oriented techniques as an alternative to layering Explore microservices, CQRS, REPL, vertical slice architecture, and many more patterns Who this book is for This book is for intermediate-level ASP.NET Core developers who want to improve their C# app code structure. ASP.NET developers who want to modernize their knowledge and enhance their technical architecture skills will also like this book. It’s also a good refresher for those in software design roles with more experience looking to update their knowledge. A good knowledge of C# programming and a basic understanding of web concepts is necessary to get the most out of this book, though some refreshers are included along the way. Дизайн серверной части, которого вы никогда раньше не видели, – руководство по созданию надежных веб-приложений. ASP.NET Базовые веб-приложения, которые выдерживают испытание временем. В них больше минимальных API, больше возможностей тестирования, больше строительных блоков и модульный монолит! Kлючевые функции Применяйте шаблоны проектирования на практике и учитесь относиться к ним как к простым строительным блокам Проведите рефакторинг кода в направлении современного дизайна приложений, например, вертикального среза на основе функциональных возможностей и чистой архитектуры Откройте для себя архитектурные принципы и комбинируйте шаблоны, чтобы понять, как создавать гибкое программное обеспечение Описание книги Эта уникальная книга ASP.NET Core восполнит пробелы, которых вам не хватает в разработке REST API и серверной части. Узнайте, как создавать надежные, поддерживаемые и гибкие приложения, используя шаблоны проектирования Gang of Four (GoF) и современные архитектурные принципы. Это новое издание обновлено для .NET 8 и посвящено исключительно серверной части, с новым содержанием о шаблоне REPR, тестировании с использованием черного ящика и создании модульных монолитов. Вы начнете с изучения основополагающих концепций, таких как REST, принципы SOLID, минимальные API, внедрение зависимостей и другие ASP.NET Механизмы Core 8. Затем вы научитесь разрабатывать компоненты с использованием шаблонов проектирования, в том числе многих из GoF. Наконец, вы изучите организацию кода вашего приложения с помощью шаблонов, которые варьируются от слоев до функционально-ориентированных вертикальных срезов, попутно затрагивая CQR и микросервисы. Это не кулинарная книга. Вместо этого вы поймете, как работают бизнес-ориентированные компоненты, как их писать и как собирать, чтобы создавать собственные API-интерфейсы, а не зацикливаться на рецептах, которые никогда не будут соответствовать вашим потребностям в реальном мире. Что вы узнаете Применяйте принципы SOLID для создания гибкого и удобного в обслуживании программного обеспечения Эффективно тестируйте свои приложения с помощью автоматизированных тестов, включая тестирование с помощью черного ящика Вступите на путь ASP.NET Мастерство внедрения основных зависимостей Работайте с шаблонами проектирования GoF, такими как strategy, decorator, facade и composite Разрабатывайте REST API, используя Minimal API и MVC Познакомьтесь с методами многоуровневости и принципами чистой архитектуры Используйте функционально-ориентированные методы в качестве альтернативы многоуровневости Изучите микросервисы, CQR, REPL, архитектуру вертикальных срезов и многие другие шаблоны Для кого предназначена эта книга Эта книга предназначена для разработчиков среднего уровня ASP.NET Которые хотят усовершенствовать структуру кода своих приложений на C#. ASP.NET разработчикам, которые хотят усовершенствовать свои знания и навыки в области технической архитектуры, также понравится эта книга. Это также хорошее пособие для тех, кто работает в сфере разработки программного обеспечения и имеет большой опыт, но хочет обновить свои знания. Чтобы извлечь максимальную пользу из этой книги, необходимо хорошее знание программирования на C# и базовое понимание веб-концепций, хотя некоторые дополнительные сведения включены по ходу чтения.
Примеры страниц (скриншоты)
Оглавление
Preface xxvii Section 1: Principles and Methodologies 1 Chapter 1: Introduction 3 What is a design pattern? .......................................................................................................... 4 Anti-patterns and code smells ................................................................................................... 5 Anti-patterns • 5 Anti-pattern: God class • 6 Code smells • 6 Code smell: Control Freak • 6 Code smell: long methods • 7 Understanding the web: request/response ................................................................................. 7 Getting started with .NET ....................................................................................................... 11 .NET SDK versus runtime • 12 .NET 5+ versus .NET Standard • 12 The command-line interface versus Visual Studio Code versus Visual Studio • 13 An overview of project templates • 13 Running and building your program • 14 Technical requirements • 15 Summary ............................................................................................................................... 15 Questions ............................................................................................................................... 16 Further reading ...................................................................................................................... 16 Answers ................................................................................................................................. 16 Chapter 2: Automated Testing 19 An overview of automated testing ........................................................................................... 19 Unit testing • 22 Integration testing • 23 End-to-end testing • 23 Other types of tests • 23 Finding the right balance • 24 Enhancing code quality • 27 Improving quality with refactoring • 27 Managing technical debt • 28 Testing approaches ................................................................................................................. 29 TDD • 29 ATDD • 29 BDD • 30 Testing techniques ................................................................................................................. 31 White-box testing • 31 Black-box testing • 31 Gray-box testing • 32 White-box vs. black-box vs. gray-box testing • 32 Conclusion • 33 Test case creation ................................................................................................................... 34 Equivalence partitioning • 34 Boundary value analysis • 35 Decision table testing • 35 State transition testing • 36 Use case testing • 36 Introducing the xUnit framework ............................................................................................ 37 How to create an xUnit test project • 37 Key xUnit features • 38 FactAttribute • 38 Assertions • 41 TheoryAttribute • 43 Fixture • 53 Arrange, Act, Assert ................................................................................................................ 54 Organizing your tests .............................................................................................................. 55 Unit tests • 56 Namespaces • 56 Test class names • 57 Test code inside the test class • 58 Integration tests • 59 Writing ASP.NET Core integration tests ................................................................................... 59 Classic web application • 60 Minimal hosting • 63 Workaround • 63 Alternative to using fixtures • 65 Creating a reusable test application • 66 Important testing principles ................................................................................................... 67 Summary ............................................................................................................................... 68 Questions ............................................................................................................................... 68 Further reading ...................................................................................................................... 68 Answers ................................................................................................................................. 69 Chapter 3: Architectural Principles 71 Separation of concerns (SoC) .................................................................................................. 71 Don’t repeat yourself (DRY) ..................................................................................................... 72 Keep it simple, stupid (KISS) ................................................................................................... 74 You Aren’t Gonna Need It (YAGNI) ........................................................................................... 75 The SOLID principles ............................................................................................................. 75 Single responsibility principle (SRP) • 75 Project – Single Responsibility • 76 Open/closed principle (OCP) • 78 Project – Open Close • 79 Liskov substitution principle (LSP) • 82 The LSP explained • 82 Covariance and contravariance • 84 Project – Liskov Substitution • 87 Conclusion • 92 Interface segregation principle (ISP) • 93 What is an interface? • 93 Project – Interface Segregation • 94 Conclusion • 99 Dependency inversion principle (DIP) • 100 Direct dependency • 100 Inverted dependency • 101 Direct subsystems dependency • 102 Inverted subsystems dependency • 102 Project – Dependency inversion • 103 Conclusion • 106 Summary ............................................................................................................................. 107 Questions ............................................................................................................................. 107 Further reading .................................................................................................................... 108 Answers ............................................................................................................................... 108 Learn more on Discord ......................................................................................................... 108 Chapter 4: REST APIs 109 REST and HTTP .................................................................................................................... 110 HTTP methods • 110 HTTP status codes • 111 HTTP headers • 112 Versioning • 114 Default versioning strategy • 114 Versioning strategy • 115 Wrapping up • 115 The Data Transfer Object (DTO) pattern ................................................................................ 116 Goal • 116 Design • 116 Conceptual examples • 117 Registering for an activity • 118 Fetching activity registration details • 119 Conclusion • 120 API contracts ........................................................................................................................ 121 Code-first API contract • 123 The first endpoint • 124 The second endpoint • 127 Wrapping up • 129 Summary ............................................................................................................................. 130 Questions ............................................................................................................................. 131 Further reading .................................................................................................................... 131 Answers ............................................................................................................................... 131 Section 2: Designing with ASP.NET Core 133 Chapter 5: Minimal APIs 135 Top-level statements ............................................................................................................. 135 Minimal hosting ................................................................................................................... 136 Minimal APIs ....................................................................................................................... 137 Mapping a route to a delegate • 138 Configuring endpoints • 139 Inputs • 140 Outputs • 147 Metadata • 154 Configuring JSON serialization • 159 Leveraging endpoint filters • 162 Leveraging the endpoint filter factory • 165 Organizing endpoints • 167 MapGroup • 168 Creating a custom Map extension method • 169 Class libraries • 171 Using Minimal APIs with Data Transfer Objects ..................................................................... 172 Goal • 173 Design • 173 Project – Minimal API • 174 Raw CRUD endpoints • 175 DTO-enabled endpoints • 176 Conclusion • 181 Summary ............................................................................................................................. 182 Questions ............................................................................................................................. 182 Further reading .................................................................................................................... 183 Answers ............................................................................................................................... 183 Chapter 6: Model-View-Controller 185 The MVC design pattern ....................................................................................................... 185 Goal • 187 Design • 187 Anatomy of ASP.NET Core web APIs • 188 The entry point • 188 Directory structure • 189 Controller • 189 Returning values • 190 Attribute routing • 194 Conclusion • 197 Using MVC with DTOs ........................................................................................................... 197 Goal • 197 Design • 198 Project – MVC API • 198 Raw CRUD controller • 199 DTO controller • 200 Conclusion • 202 Summary ............................................................................................................................. 202 Questions ............................................................................................................................. 202 Further reading .................................................................................................................... 203 Answers ............................................................................................................................... 203 Chapter 7: Strategy, Abstract Factory, and Singleton Design Patterns 205 The Strategy design pattern .................................................................................................. 205 Goal • 206 Design • 206 Project – Strategy • 207 Conclusion • 212 The Abstract Factory design pattern ...................................................................................... 213 Goal • 213 Design • 213 Project – Abstract Factory • 215 Project – the mid-range vehicle factory • 218 Impacts of the Abstract Factory • 219 Conclusion • 220 The Singleton design pattern ................................................................................................ 221 Goal • 221 Design • 222 An alternative (better) way • 224 Code smell – Ambient Context • 225 Conclusion • 227 Summary ............................................................................................................................. 228 Questions ............................................................................................................................. 229 Answers ............................................................................................................................... 229 Chapter 8: Dependency Injection 231 What is dependency injection? .............................................................................................. 231 The composition root • 235 Striving for adaptability • 235 Understanding the use of the IoC container • 236 The role of an IoC container • 236 Code smell – Control Freak • 237 Stable dependencies • 238 Volatile dependencies • 238 Conclusion • 238 Object lifetime • 239 What’s an object’s lifetime? • 239 .NET object lifetime • 239 Registering our dependencies • 243 Registering your features elegantly • 243 Project – Registering the demo feature • 245 Using external IoC containers • 246 Revisiting the Strategy pattern .............................................................................................. 248 Constructor injection • 248 Property injection • 248 Method injection • 249 Project – Strategy • 252 Shared building blocks • 252 Control Freak controllers • 254 Injecting an implementation in the controllers • 255 Injecting an abstraction in the controller • 257 Constructing the InjectAbstractionLocationsController • 258 Conclusion • 262 Revisiting the Singleton pattern ............................................................................................ 263 Project – Application state • 263 First implementation • 265 Second implementation • 266 Using the implementations • 267 Project – Wishlist • 270 Conclusion • 276 Understanding guard clauses ................................................................................................ 276 Understanding the Service Locator pattern ........................................................................... 277 Project – ServiceLocator • 278 Implementing method injection • 280 Implementing constructor injection • 281 Implementing a minimal API • 281 Conclusion • 282 Revisiting the Factory pattern ............................................................................................... 283 Project – Factory • 283 Summary ............................................................................................................................. 285 Questions ............................................................................................................................. 286 Further reading .................................................................................................................... 286 Answers ............................................................................................................................... 286 Chapter 9: Application Configuration and the Options Pattern 289 Loading the configuration .................................................................................................... 290 Learning the options interfaces ............................................................................................ 291 IOptionsMonitor • 292 IOptionsFactory • 293 IOptionsSnapshot • 293 IOptions • 294 Exploring common usage scenarios ...................................................................................... 294 Manual configuration • 294 Using the settings file • 295 Injecting options • 295 Named options • 296 IOptionsFactory • 297 IOptionsMonitor • 298 IOptionsSnapshot • 299 Bind options to an existing object • 299 Reloading options at runtime • 300 Learning options configuration ............................................................................................. 302 Creating the program • 303 Configuring the options • 305 Implementing a configurator object • 305 Adding post-configuration • 307 Using multiple configurator objects • 309 Exploring other configuration possibilities • 310 Validating our options objects ............................................................................................... 312 Eager validation • 313 Data annotations • 313 Validation types • 316 Validating options using FluentValidation .............................................................................. 319 Injecting options objects directly ......................................................................................... 321 Centralizing the configuration for easier management ........................................................... 324 Using the configuration-binding source generator ................................................................. 327 Using the options validation source generator ....................................................................... 328 Using the ValidateOptionsResultBuilder class ........................................................................ 331 Wrapping up ........................................................................................................................ 333 Summary ............................................................................................................................. 334 Questions ............................................................................................................................. 335 Further reading .................................................................................................................... 335 Answers ............................................................................................................................... 336 Chapter 10: Logging Patterns 337 What is logging? ................................................................................................................... 338 Writing logs ......................................................................................................................... 339 Log levels ............................................................................................................................. 344 Logging providers ................................................................................................................ 346 Configuring logging .............................................................................................................. 347 Structured logging ............................................................................................................... 350 Summary ............................................................................................................................. 351 Questions ............................................................................................................................. 352 Further reading .................................................................................................................... 352 Answers ............................................................................................................................... 352 Section 3: Component Patterns 353 Chapter 11: Structural Patterns 355 The Decorator design pattern ............................................................................................... 355 Goal • 356 Design • 356 Project – Adding behaviors • 360 DecoratorA • 361 DecoratorB • 362 Project – Decorator using Scrutor • 363 Conclusion • 366 The Composite design pattern .............................................................................................. 366 Goal • 366 Design • 367 Project – BookStore • 367 Conclusion • 379 The Adapter design pattern .................................................................................................. 379 Goal • 379 Design • 379 Project – Greeter • 381 Conclusion • 383 The Façade design pattern .................................................................................................... 383 Goal • 383 Design • 384 Project – The façades • 386 Opaque façade • 386 Transparent façade • 389 The program • 393 Flexibility in action • 396 Alternative façade patterns • 398 Conclusion • 399 Summary ............................................................................................................................. 399 Questions ............................................................................................................................. 400 Further reading .................................................................................................................... 400 Answers ............................................................................................................................... 400 Chapter 12: Behavioral Patterns 403 The Template Method pattern ............................................................................................... 403 Goal • 403 Design • 403 Project – Building a search machine • 404 Unit tests • 411 Conclusion • 414 The Chain of Responsibility pattern ...................................................................................... 415 Goal • 415 Design • 415 Project – Message interpreter • 417 Conclusion • 423 Mixing the Template Method and Chain of Responsibility patterns ......................................... 423 Project – Improved message interpreter • 424 Project – A final, finer-grained design • 426 Conclusion • 431 Summary ............................................................................................................................. 431 Questions ............................................................................................................................. 432 Answers ............................................................................................................................... 432 Chapter 13: Operation Result Pattern 435 The Operation Result pattern ................................................................................................ 435 Goal • 436 Design • 436 Project – Implementing different Operation Result patterns • 438 The Program.cs file • 438 The simplest form of the Operation Result pattern • 438 A single error message • 440 Adding a return value • 442 Multiple error messages • 443 Adding message severity • 445 Sub-classes and factories • 450 Project – Registration Application • 454 Advantages and disadvantages • 459 Advantages • 459 Disadvantages • 460 Conclusion • 460 Summary ............................................................................................................................. 460 Questions ............................................................................................................................. 461 Further reading .................................................................................................................... 461 Answers ............................................................................................................................... 461 Section 4: Application Patterns 463 Anti-pattern – Big Ball of Mud ............................................................................................... 464 Chapter 14: Layering and Clean Architecture 467 Introducing layering ............................................................................................................ 468 Classic layering model • 468 Splitting the layers • 471 Layers versus tiers versus assemblies • 473 What is a tier? • 473 What is a layer? • 473 What is an assembly? • 474 Responsibilities of the common layers .................................................................................. 474 Presentation • 474 Domain • 474 Rich domain model • 475 Anemic domain model • 477 The Service layer • 478 Data • 480 Overview of the Repository pattern • 481 Overview of the Unit of Work pattern • 483 Abstract layers ..................................................................................................................... 485 Sharing the model ................................................................................................................ 488 Clean Architecture ............................................................................................................... 491 Implementing layering in real life ......................................................................................... 496 To be or not to be a purist? • 496 Building a façade over a database • 498 Summary ............................................................................................................................. 500 Questions ............................................................................................................................. 500 Further reading .................................................................................................................... 501 Answers ............................................................................................................................... 501 Chapter 15: Object Mappers 503 The Object Mapper pattern ................................................................................................... 503 Goal • 504 Design • 504 Project – Mapper • 506 Conclusion • 511 Code smell – too many dependencies .................................................................................... 512 Overview of the Aggregate Services pattern • 513 Implementing a mapping façade ........................................................................................... 519 Implementing a mapping service .......................................................................................... 522 Exploring AutoMapper ......................................................................................................... 525 Project – AutoMapper • 526 Exploring Mapperly .............................................................................................................. 532 Project – Mapperly • 532 Summary ............................................................................................................................. 536 Questions ............................................................................................................................. 537 Further reading .................................................................................................................... 537 Answers ............................................................................................................................... 538 Chapter 16: Mediator and CQS Patterns 539 A high-level overview of Vertical Slice Architecture ............................................................... 539 The Mediator pattern ........................................................................................................... 541 Goal • 541 Design • 541 Project – Mediator (IMediator) • 543 Project – Mediator (IChatRoom) • 547 Conclusion • 552 The CQS pattern ................................................................................................................... 553 Goal • 553 Design • 554 Project – CQS • 555 Conclusion • 569 Code smell – Marker Interfaces ............................................................................................. 570 Metadata • 570 Dependency identifier • 571 Using MediatR as a mediator ................................................................................................. 574 Project – Clean Architecture with MediatR • 575 Summary ............................................................................................................................. 580 Questions ............................................................................................................................. 580 Further reading .................................................................................................................... 581 Answers ............................................................................................................................... 581 Chapter 17: Getting Started with Vertical Slice Architecture 583 Vertical Slice Architecture .................................................................................................... 584 What are the advantages and disadvantages? • 588 Advantages • 588 Disadvantages • 588 Downsides or upsides? • 589 Project – Vertical Slice Architecture • 590 Project organization • 591 Exploring a feature • 593 Testing • 599 Continuing your journey – a few tips and tricks • 604 Agile and DevOps synergy • 606 Conclusion • 607 Summary ............................................................................................................................. 608 Questions ............................................................................................................................. 609 Further reading .................................................................................................................... 609 Answers ............................................................................................................................... 609 Chapter 18: Request-EndPoint-Response (REPR) 611 The Request-EndPoint-Response (REPR) pattern ................................................................... 612 Goal • 612 Design • 612 Project – SimpleEndpoint • 613 Feature: ShuffleText • 613 Feature: RandomNumber • 615 Feature: UpperCase • 616 Conclusion • 618 An e-commerce application—a slice of the real-world ............................................................ 619 Assembling our stack • 620 Dissecting the code structure • 620 Exploring the shopping basket • 625 AddItem feature • 628 Managing exception handling • 633 Creating an exception handler middleware • 633 Exception handling using ExceptionMapper • 636 Leveraging exceptions to propagate errors • 639 Gray-box testing • 640 AddItemTest • 640 Summary ............................................................................................................................. 645 Questions ............................................................................................................................. 645 Further reading .................................................................................................................... 645 Answers ............................................................................................................................... 645 Chapter 19: Introduction to Microservices Architecture 647 What are microservices? ....................................................................................................... 647 Cohesive unit of business • 648 Ownership of data • 649 Microservice independence • 649 An introduction to Event-Driven Architecture ........................................................................ 650 Types of events • 651 Domain events • 651 Integration events • 651 Application events • 651 Enterprise events • 651 Getting started with message queues • 652 Overview of the Publish-Subscribe pattern • 654 Message brokers • 658 Overview of the Event Sourcing pattern • 658 Example • 660 Conclusion • 668 Introducing Gateway patterns • 669 Overview of the Gateway Routing pattern • 670 Overview of the Gateway Aggregation pattern • 672 Overview of the Backend for Frontend pattern • 674 Mixing and matching gateways • 675 Conclusion • 676 Project – BFF ........................................................................................................................ 678 Layering APIs • 678 Advantages of a layered API design • 679 Disadvantages of a layered API design • 680 Running the microservices • 680 Manually starting the projects • 681 Using Docker Compose to run the projects • 682 Briefly testing the services • 683 Creating typed HTTP clients using Refit • 685 Creating a service that serves the current customer • 690 Features • 691 Fetching the catalog • 691 Fetching the shopping cart • 693 Managing the shopping cart • 696 Conclusion • 700 Revisiting the CQRS pattern .................................................................................................. 701 Advantages and potential risks • 705 Benefits of the CQRS pattern • 705 Potential risks of using the CQRS pattern • 705 Conclusion • 706 Overview of the Microservice Adapter pattern ....................................................................... 706 Adapting an existing system to another • 707 Decommissioning a legacy application • 709 Adapting an event broker to another • 715 Conclusion • 717 Summary ............................................................................................................................. 718 Questions ............................................................................................................................. 719 Further reading .................................................................................................................... 719 Answers ............................................................................................................................... 720 Chapter 20: Modular Monolith 721 What is a Modular Monolith? ................................................................................................ 722 What are traditional monoliths? • 722 What are microservices? • 723 Advantages of Modular Monoliths • 723 Key components of a Modular Monolith • 723 Implementing a Modular Monolith ....................................................................................... 725 Planning the project • 726 Analyzing the domain • 728 Identifying the modules • 728 Identifying the interactions between modules • 729 Defining our stack • 730 The module structure • 730 The URI space • 732 The data space • 733 The message broker • 735 Project – Modular Monolith .................................................................................................. 736 Sending events from the catalog module • 736 Consuming the events from the basket module • 738 Inside the aggregator • 741 Exploring the REST API HttpClient • 744 Sending HTTP requests to the API • 746 Validating the existence of a product • 747 Transitioning to microservices ............................................................................................. 748 Challenges and pitfalls ......................................................................................................... 749 Summary ............................................................................................................................. 750 Questions ............................................................................................................................. 751 Further reading .................................................................................................................... 751 Answers ............................................................................................................................... 751 An end is simply a new beginning ......................................................................................... 752 Other Books You May Enjoy 755 Index 759
Marcotte Carl-Hugo / Маркотт Карл-Хьюго - Architecting ASP.NET Core Applications, 3rd Edition / Архитектура приложений ASP.NET Core, 3-е издание [2024, PDF, EPUB, ENG] download torrent for free and without registration
You cannot post new topics in this forum You cannot reply to topics in this forum You cannot edit your posts in this forum You cannot delete your posts in this forum You cannot vote in polls in this forum You cannot attach files in this forum You can download files in this forum
![[Quote]](./templates/default/images/lang/en/icon_quote.gif "Reply with quote"){kind=icon}
![[Profile]](./templates/default/images/lang/en/icon_profile.gif "View user's profile"){kind=icon}
![[PM]](./templates/default/images/lang/en/icon_pm.gif "Send private message"){kind=icon}
