FinUniversity Electronic Library

     
?

Details
Card Table RUSMARC

Aroraa, Gaurav. Hands-on design patterns with C# and .NET Core: write clean and maintainable code by using reusable solutions to common software design problems / Gaurav Aroraa, Jeffrey Chilberto. — 1 online resource (1 volume) : illustrations — <URL:http://elib.fa.ru/ebsco/2190852.pdf>.

Record create date: 8/15/2019

Subject: C# (Computer program language); Software patterns.; Application software — Development.; Application software — Development.; C# (Computer program language); Software patterns.

Collections: EBSCO

Allowed Actions: –

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

Group: Anonymous

Network: Internet

Document access rights

Network User group Action
Finuniversity Local Network All Read Print Download
Internet Readers Read Print
-> Internet Anonymous

Table of Contents

  • Cover
  • Title Page
  • Copyright and Credits
  • Dedication
  • About Packt
  • Foreword
  • Contributors
  • Table of Contents
  • Preface
  • Section 1: Essentials of Design Patterns in C# and .NET Core
  • Chapter 1: Overview of OOP in .NET Core and C#
    • Technical requirements
      • Installing Visual Studio
      • Setting up .NET Core
      • The models used in this book
    • OOP and how classes and objects work
      • Explaining OOP
      • A class
      • An object
        • Associations
      • An interface
    • Inheritance
      • Types of inheritance
    • Encapsulation
    • Polymorphism
      • Static polymorphism
      • Dynamic polymorphism
        • Interface polymorphism
        • Inheritance polymorphism
        • Generics
    • Summary
    • Questions
  • Chapter 2: Modern Software Design Patterns and Principles
    • Technical requirements
      • Installing Visual Studio
      • Setting up .NET Core
    • Design principles
      • DRY – Don't Repeat Yourself
      • KISS – Keep It Simple Stupid
      • YAGNI – You Aren't Gonna Need It
      • MVP – Minimum Viable Product
      • SOLID
        • Single responsibility principle
        • Open/closed principle
        • Liskov substitution principle
        • Interface segregation principle
        • Dependency inversion principle
    • Software patterns
      • GoF patterns
        • Creational patterns
        • Structural patterns
          • Decorator patterns
        • Behavioral patterns
          • Chain of responsibility
          • Observer pattern
      • Enterprise integration patterns
        • Topology
        • Patterns
          • Messaging
          • Transformation
          • Routing
    • Software development life cycle patterns
      • Waterfall SDLC
      • Agile SDLC
    • Summary
    • Questions
  • Section 2: Deep Dive into Utilities and Patterns in .NET Core
  • Chapter 3: Implementing Design Patterns - Basics Part 1
    • Technical requirements
      • Installing Visual Studio
      • Setting up .NET Core
    • Minimum Viable Product
      • Requirements
      • How does MVP fit with future development?
    • Test-driven development
      • Why did the team choose TDD?
      • Setting up the projects
      • Initial unit test definitions
    • Abstract Factory design pattern
      • InventoryCommand abstract class
    • SOLID principles
      • Single responsibility principle (SRP)
      • Open/closed principle (OCP)
      • Liskov substitution principle (LSP)
      • Interface segregation principle (ISP)
      • Dependency inversion principle
      • InventoryCommand unit tests
        • Access modifiers
        • Helper TestUserInterface
        • Example unit test – QuitCommand
    • Summary
    • Questions
  • Chapter 4: Implementing Design Patterns - Basics Part 2
    • Technical requirements
      • Installing Visual Studio
      • Setting up .NET Core
    • The singleton pattern
      • Processes and threads
      • The repository pattern
      • Unit tests
      • A race condition illustration
      • AddInventoryCommand
        • TestInventoryContext
        • AddInventoryCommandTest
      • UpdateQuantityCommand
        • UpdateQuantityCommandTest
      • GetInventoryCommand
        • GetInventoryCommandTest
    • The factory pattern
      • Unit tests
        • Issue one – UnknownCommand
          • InventoryCommandFactoryTests
        • Issue two – case-insensitive text commands
    • Features in .NET Core
      • IServiceCollection
      • CatalogService
      • IServiceProvider
    • Console application
    • Summary
    • Questions
  • Chapter 5: Implementing Design Patterns - .NET Core
    • Technical requirements
      • Installing Visual Studio
      • Setting up .NET Core
    • .Net Core service lifetimes
      • Transient
      • Scoped
      • Singleton
      • Back to FlixOne 
        • Unit tests
      • Scope
    • Implementation factory
      • IInventoryContext
      • IInventoryReadContext
      • IInventoryWriteContext
      • InventoryCommandFactory
      • InventoryCommand
        • Implementation factory using a function
        • Using services
        • Using third-party containers
    • Summary
    • Questions
  • Chapter 6: Implementing Design Patterns for Web Applications - Part 1
    • Technical requirements
      • Installing Visual Studio
      • Setting up .NET Core
      • Installing SQL Server
    • Creating a .Net Core web application
      • Kicking off the project
        • Developing requirements
      • Crafting a web application
        • Web applications and how they work
        • Coding the web application
    • Implementing CRUD pages
    • Summary
    • Questions
    • Further reading
  • Chapter 7: Implementing Design Patterns for Web Applications - Part 2
    • Technical requirements
      • Installing Visual Studio
      • Setting up .NET Core
      • Installing SQL Server
    • Extending the .NET Core web application
      • Project kickoff
        • Requirements
          • Business requirements
          • Technical requirements
        • Challenges
          • Challenges for developers
          • Challenges for businesses
          • Finding a solution to the problems/challenges
    • Authentication and authorization
      • Authentication in action
        • Why does it make a difference?
      • Authorization in action
      • Creating a web test project
    • Summary
    • Questions
    • Further reading
  • Section 3: Functional Programming, Reactive Programming, and Coding for the Cloud
  • Chapter 8: Concurrent Programming in .NET Core
    • Technical requirements
      • Installing Visual Studio
      • Setting up .NET Core
      • Installing SQL Server
    • Concurrency in the real world
    • Multithreading and asynchronous programming
    • Async/Await – why is blocking bad?
    • Concurrent collections
    • Patterns and practices – TDD and Parallel LINQ
    • Summary
    • Questions
    • Further reading
  • Chapter 9: Functional Programming Practices
    • Technical requirements
      • Installing Visual Studio
      • Setting up .NET Core
      • Installing SQL Server
    • Understanding functional programming 
    • Enhancing our inventory application
      • Requirements
      • Back to FlixOne 
    • Strategy pattern and functional programming
    • Summary
    • Questions
  • Chapter 10: Reactive Programming Patterns and Techniques
    • Technical requirements
      • Installing Visual Studio
      • Setting up .NET Core
      • Installing SQL Server
    • The principles of reactive programming
      • Be reactive with reactive programming
        • Reactive streams in action
    • Reactive and IObservable
      • Observer pattern – implementation using IObservable
    • Reactive extensions – .NET Rx extensions
    • Inventory application use case
      • Starting the project
        • Requirements
          • Business requirements
      • Getting inventory with a filter, paging, and sorting
    • Patterns and Practices – MVVM
      • Implementation of MVVM
    • Summary
    • Questions
    • Further reading
  • Chapter 11: Advanced Database Design and Application Techniques
    • Technical requirements
      • Installing Visual Studio
      • Setting up .NET Core
      • Installing SQL Server
    • Use case discussion
      • Project kickoff
      • Requirements
        • Business requirements
        • Technical requirements
        • Challenges
          • Challenges for developers
          • Challenges for businesses
          • Providing a solution to the problems/challenges
    • Database discussion
    • Database processing
      • OLTP
      • OLAP
      • Ledger-style databases
    • Implementing the CQRS pattern
    • Summary
    • Questions
  • Chapter 12: Coding for the Cloud
    • Technical requirements
    • Key considerations when building solutions in the cloud
    • Scalability
      • Workload
      • Solution patterns
        • Vertical scaling
        • Horizontal scaling
        • Auto-scaling
        • Microservices
          • Small
          • Business capability
          • Loosely coupled
          • Independently maintainable
          • Isolated state
          • Advantages
    • Resiliency/availability
      • Solution pattern
        • EDA
          • Queue-Based Load Leveling
          • Publisher Subscriber
          • Priority Queue
          • Compensating transaction
    • Security
      • Solution patterns
        • Federated security
    • Application design
      • Solution patterns
        • Cache
          • Cache-aside
          • Write-through cache
          • Static Content Hosting
        • Command and Query Responsibility Segregation
          • Challenges of CQRS
          • Why CQRS?
    • DevOps
      • Solution patterns
        • Telemetry
        • Continuous integration/continuous deployment
    • Summary
    • Questions
    • Further reading
  • Miscellaneous Best Practices
    • Technical requirements
      • Installation of Visual Studio
    • Use case discussion
      • UML diagram
        • Types of UML diagram
    • Best practices
    • Other design patterns
    • Summary
    • Questions
    • Further reading
  • Assessments
    • Chapter 1 – Overview of OOP in .NET Core and C#
    • Chapter 2 – Modern Software Design Patterns and Principles
    • Chapter 3 – Implementing Design Patterns – Basics Part 1
    • Chapter 4 – Implementing Design Patterns – Basics Part 2
    • Chapter 5 – Implementing Design Patterns – .NET Core
    • Chapter 6 – Implementing Design Patterns for Web Applications – Part 1
    • Chapter 7 – Implementing Design Patterns for Web Applications – Part 2
    • Chapter 8 – Concurrent Programming in .NET Core
    • Chapter 9 – Functional Programming Practices – an Approach
    • Chapter 10 – Reactive Programming Patterns and Techniques
    • Chapter 11 – Advanced Database Design and Application Techniques
    • Chapter 12 – Coding for the Cloud
    • Appendix A – Miscellaneous Best Practices
  • Other Books You May Enjoy
  • Index

Usage statistics

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