• FinUniversity Electronic Library

Login
Search manual

Details

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
Network User group Action
Finuniversity Local Network All
Read Print Download
Internet Readers
Read Print
Internet Anonymous
  • 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

Access count: 0 
Last 30 days: 0

Detailed usage statistics