Gain the skills needed to solve enterprise-level software programming problems to quickly deliver reliable applications that realize the value and quality goals of Agile development.

Utbildningsmål

In part 1 you will identify and apply tactical design patterns to achieve SOLID results. This includes a cross section of patterns from lazy Singleton to delegate-based Strategy to leveraging the Task Parallel Library (TPL) using asynchronous adapters. Best practices include comprehensive coverage of automated Test-Driven Development (TDD) and modern techniques for paying down technical debt.

In part 2, strategic architectural patterns such as MVC and ORM are utilized to achieve "separation of concerns", an approach in which you will learn to write C# code that is much more maintainable, flexible and resilient. You will apply extended features, including definitive coverage Language Integrated Query (LINQ), to streamline the use of C# as both an object-oriented and a first-class data-manipulation language. This includes leveraging the Entity Framework (EF) in the highly portable and open .NET Core environment.

Throughout the course, advanced and less-used features of C# are introduced as needed including specialized C# keywords, advanced lambda expressions, extension methods, generic classes and delegates, universal functions, dynamic enumeration and anonymous types. In particular, to optimize data access, productivity, and overall application performance.

Förkunskaper

• Constructing, compiling, and executing C# applications using the Visual Studio integrated development environment.
• Designing and implementing moderately complex programs in C#.
• Applying fundamental object-oriented development techniques, such as encapsulation, inheritance, interfaces, and polymorphism.
• Developing applications that leverage key components of the .NET framework library.

Innehåll

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

 

Kursen levereras genom utbildningspartner: Learning Tree