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
