Advanced C#, Design Patterns and Best Practices

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