Visão Geral

O curso C# Design Patterns and Best Practices Advanced é destinado a desenvolvedores experientes que desejam aprofundar seus conhecimentos sobre padrões de projeto (Design Patterns) em C#, com foco na aplicação prática em projetos reais, arquiteturas modernas (como DDD, Clean Architecture) e melhores práticas de desenvolvimento de software. Os alunos aprenderão como aplicar corretamente os principais padrões de projeto, evitar más práticas e escrever código mais robusto, escalável e manutenível.

Objetivo

Após realizar este curso C# Design Patterns and Best Practices Advanced, você será capaz de:

• Resolver problemas complexos de programação usando padrões de design tático e estratégico
• Entregue código sem bugs usando desenvolvimento orientado a testes (TDD)
• Crie arquiteturas em camadas para reutilização e eliminação de duplicação funcional
• Aplique os princípios SOLID para um melhor design de aplicações
• Simplifique aplicativos centrados em dados com recursos estendidos do C# e o Entity Framework
• Explorar palavras-chave LINQ e recursos de pilha completa, incluindo consultas, agrupamentos e junções

Publico Alvo

• Desenvolvedores C# com experiência que desejam dominar padrões de projeto.
• Engenheiros de software e arquitetos de sistemas.
• Profissionais que atuam em projetos corporativos com foco em qualidade de código.
• Times de desenvolvimento que desejam padronizar a arquitetura e boas práticas.

Pre-Requisitos

• Conhecimento intermediário a avançado em C# e .NET.
• Experiência prática com desenvolvimento orientado a objetos.
• Noções básicas sobre princípios SOLID e Clean Code

Materiais

Conteúdo Programatico

Learning Objectives

Module 1: Simplifying Complex Programming with Proven Design Patterns

Applying simple interfaces to intricate algorithms

• Unifying interfaces from subsystems for ease of use and reusability
• Implementing the Façade, Observer and thread-safe lazy Singleton patterns

Module 2: Automated Test-Driven Development

Automating unit testing

• Shortening development cycles with automated tests
• Eliminating regression errors with reusable tests

Integrating testing and coding

• Applying the test–first programming practice
• Generating immediate red–green feedback for increased code quality and shortened feature development cycles
• Organizing, coordinating and running test cases
• Isolating dependencies with the Mock–Object pattern for reliable and repeatable testing

Refactoring code to improve design

• Improving design while ensuring correct behavior is preserved
• Eliminating code duplication by refactoring using the Template Methods pattern and the Hollywood principle

Module 3: Applying SOLID Principles

Design by Interface

• Identifying objects by behavior, not type
• Organizing state–rich applications with the State pattern
• Refactoring to achieve the Single Responsibility Principle
• Maintaining the Open-Closed Principle during development

Inheritance vs. Aggregation

• Adhering to Interface Segregation for code design
• Applying the Liskov Substitutability Principle to ensure correct inheritance
• Changing algorithms dynamically at run-time using the Strategy Pattern
• Dependency injection vs. Dependency Inversion
• Deploying run-time Factory Patterns
• Template Methods and the Hollywood Principle

Module 4: Threading and Concurrency

Organizing long-running business logic

• Capabilities of Task Parallel Library (Parallel.For and Parallel.Foreach)
• Asynchronous C# keywords
• Coding using the Awaitable-Awaiter Pattern

Module 5: Separation of Concerns (Business Logic – Data)

Object-Relational Mapping (ORM)

• Creating an effective Data Access Layer
• Reducing User Interface code with Data Binding
• Centralizing data access using the lazy Repository pattern
• Determining when to force eager loading

Easing data access code with the Entity Framework

• Maintaining data context automatically
• Reducing database access code by exploiting Entity Navigation Properties
• Eliminating database update code with Entity change tracking

Module 6: Separation of Concerns (View - Business Logic)

Strategic (Architectural) Design Patterns

• Designing with MVC, MVP and MVVM
• Simplifying complex highly-stateful logic with the State Pattern
• Coding controller objects for use with auto-generated entity objects

Module 7: Harnessing Lesser-Used C# Language Features

Language shortcuts

• Applying auto-implemented and lambda generated properties
• Benefiting from dynamic and implied-type declaration

Streamlining program logic

• Instantiating entity objects
• Simplifying construction with object initializers

Filtering and ordering data with lambda expressions

• Passing lambda expressions to methods (behavior vs. data)
• Calling Count, Reverse, Union, Except and other extension methods

Applying extended features

• Making code more flexible with delegates
• Parameterizing delegates and lambda expressions
• Streamlining code with Func<T,R> generic delegates

Module 8: Leveraging LINQ Query Keywords

Syntax and semantics

• Coding LINQ queries
• Filtering with from, where, orderby and group
• Performing inner and outer joins
• Generating anonymous types

Iterating collections

• Interfacing between C# and LINQ using IEnumerable<T> and IQueryable<T>
• Issuing queries on entity and spatial types

Connecting to and reading from a database

• Inheriting DbContext objects
• Correlating entity classes and data tables
• Executing stored procedures and table-valued functions

Object Relational Mapping

• Employing code-first and database first mapping to generate entity classes
• Optimizing complex mapping including many to many and database inheritance

Updating a database

• Inserting, updating and deleting data when Core is integrated with .NET Framework
• Error handling and exceptions
• Committing and rolling back transactions

Module 9: Enumerations and Generic Classes

Dynamic Enumeration

• Comparing IEnumerable<T> and IEnumerator<T>
• The yield keyword

Module 10: Processing Data with LINQ Queries

Advanced LINQ techniques

• Creating anonymous query results
• Retrieving composite views using nested from clauses

Referential Integrity and Concurrency

• First-wins, Last-wins and everyone wins scenarios
• Protecting concurrency data corruption
• Concurrency detection and recovery
• Transaction Processing
• Recovering from Data Exceptions