Home About Courses Schedule Services Webinars Contact Search

Advanced C# with Design Patterns

SEE SCHEDULE

Duration: 5 Days

Method: Instructor led, Hands-on workshops

Price: $2750.00

Course Code: NE2208


Audience

Software developers, team leaders and architects who have a background in C# software development.

Description

This course presents some of the advanced C# concepts involving design patterns using generics, tuples, multithreading and LINQ. The fundamental design patterns often referred to as Gang of Four – GoF are explained and their practical applications provided in an easy to understand manner. The GoF patterns provide an elegant creation and communication methodology for commonly occurring problems in modern object-oriented development . The GoF lists twenty three patterns that are divided into three main categories of “creational patterns”, “structural patterns” and “behavioral patterns”. The course covers majority of the popular patterns in detail explaining the concept behind a particular pattern, as well as a practical example of its usefulness. The last part of the course covers the design principles often referred to as S.O.L.I.D which involve Single Responsibility Principle (SRP), Open Closed Principle (OCP), Liskov Substitution Principle (LSP), Interface Segregation Principle (ISP) and Dependency Inversion Principle (DIP).

Objectives

Upon successful completion of this course, the student will be able to:

  • Understand Advanced Object-Oriented Programming in C#
  • Understand and develop software architectures
  • Understand software architecture specifications via UML
  • Be able to create advanced C# applications with proper design principles

Prerequisites

Intermediate level background in software development using C# or VB.Net or Java or C++.

Topics

  • I. Overview of UML for Design Patterns
    • Concept of aggregation and composition
    • UML class diagrams involving class and interface inheritance
    • Interfaces and dependency injection
  • II. Overview of C# intermediate OOP Concepts
    • Abstract classes and methods, delegates, generics, attributes
    • Multithreading and Task Parallel Library, Async programming
  • III. New Features in C#
    • Tuples, Record types, pattern matching
    • Local functions, immutable types
  • IV. Overview of Design Patterns
    • Motivation for design patterns
    • Overview of Gang of Four design patters
    • How software design can benefit from design patterns
  • V. Creational Design Patterns
    • Factory Method Pattern - for creating an instance of one of derived classes
    • Singleton Pattern – for creating a class which can only exist as a single instance
    • Abstract Factory Pattern – for controlling the architecture of an application
  • VI. Structural Design Patterns
    • Adapter Pattern – for converting the interface of a class into another interface requested by the client
    • Bridge Pattern – for separating an object’s interface from its implementation
    • Decorator Pattern – for adding responsibilities to objects dynamically
    • Facade Pattern - for providing a unified interface to a set of interfaces in a subsystem
    • Proxy Pattern - for providing a surrogate for another object to control access to it
  • VII. Behavioral Patterns
    • State Pattern - for allowing an object to alter its behavior when its internal state changes.
    • Strategy Pattern - for defining a family of algorithms, encapsulating each one, and making them interchangeable
    • Template Method Pattern– for delegatig the exact steps of an algorithm to a subclass.
    • Visitor Pattern – for defining new operations to a class
    • Observer Pattern – for implementing publisher subscriber cases
    • Prototype Pattern – for making in-memory copies of objects
  • VIII. S.O.L.I.D Design Principles
    • Single Responsibility Principle (SRP) – single focus of responsibility for each class.
    • Open Closed Principle (OCP) – a class needs to be open for extension but closed for modification.
    • Liskov Substitution Principle (LSP) – be able to use a derived class in place of a base class.
    • Interface Segregation Principle (ISP) – breaking related methods into interfaces.
    • Dependency Inversion Principle (DIP) – isolating a class from its implementation and using abstract classes and interfaces.