C# Programming Training Course

Module 1: C# Fundamentals and the .NET Environment

• The history of C# and its role within the .NET ecosystem
• Understanding the Common Language Runtime (CLR) and Intermediate Language (IL)
• Setting up the development environment (Visual Studio/VS Code)
• Anatomy of a C# program (Main method, namespaces, comments)
• Compiling and running simple console applications
• Practical session: Creating and running the "Hello World" application and exploring the structure of a C# project file

Module 2: Variables, Data Types, and Operators

• Value types vs. Reference types and memory allocation basics
• Primitive data types (int, float, double, bool, char)
• Type conversions (implicit and explicit casting)
• Using assignment, arithmetic, and compound assignment operators
• Understanding logical and comparison operators
• Practical session: Writing a script to calculate simple interest, requiring type casting and using various arithmetic operators

Module 3: Control Flow and Decision Making

• Implementing conditional execution with if, else if, and else statements
• Using the ternary operator for concise conditional logic
• Handling multiple conditions efficiently with the switch statement
• Mastering for, while, and do-while loops
• Utilizing break and continue to control loop execution
• Practical session: Developing a simple menu-driven console application using a while loop and a switch statement

Module 4: Methods, Parameters, and Overloading

• Defining and calling methods for modular code structure
• Understanding method parameters (value, reference, and output)
• The importance of method return types and the void keyword
• Implementing method overloading for flexible function signatures
• Creating static methods and variables
• Practical session: Refactoring the console application by moving core functionality into separate, overloaded, and reusable methods

Module 5: Introduction to Arrays and Collections

• Defining, initializing, and accessing single-dimensional arrays
• Working with multi-dimensional and jagged arrays
• Introduction to the List<T> generic collection
• Common operations on List<T> (adding, removing, iterating)
• Overview of other key collections like Dictionary<TKey, TValue> and Queue<T>
• Practical session: Creating an application that manages a list of student names and grades using a List<string> and sorting the results

Module 6: Strings, Text Processing, and the StringBuilder

• Understanding the immutable nature of C# strings
• Common string manipulation methods (SubString, IndexOf, Replace)
• String formatting and interpolation (using $)
• Utilizing the StringBuilder class for efficient, mutable string operations
• Introduction to C#'s handling of character sets and encodings
• Practical session: Writing a tool to parse and format log entries, using string methods for cleaning and StringBuilder for output generation

Module 7: Object-Oriented Programming (OOP) I: Classes and Objects

• Core concepts of Object-Oriented Programming in C#
• Defining classes and creating objects (instances)
• Using properties (getters and setters) for encapsulated data access
• Understanding constructors and their role in object initialization
• Defining instance methods and class methods
• Practical session: Designing a Customer class with properties and a constructor, and creating several objects in the main program

Module 8: Object-Oriented Programming (OOP) II: Inheritance and Polymorphism

• Implementing inheritance using the : syntax
• Understanding the Liskov Substitution Principle
• Method overriding using the virtual and override keywords
• Understanding the concept of polymorphism and base class references
• Using the is and as operators for type checking and casting
• Practical session: Extending the Customer class into VIPCustomer, overriding a discount calculation method to demonstrate polymorphism

Module 9: Object-Oriented Programming (OOP) III: Abstraction and Interfaces

• Defining abstract classes and abstract methods
• Understanding the purpose and implementation of Interfaces
• Implementing multiple interfaces in a single class
• Utilizing interfaces for defining contracts and dependency injection basics
• Structuring large applications using namespaces and access modifiers
• Practical session: Defining an IPayable interface and implementing it in both a Customer and a new Vendor class

Module 10: Exception Handling and Debugging

• Understanding the C# exception hierarchy
• Using try, catch, and finally blocks for exception management
• Catching specific exceptions and re-throwing exceptions
• Utilizing the Visual Studio Debugger (breakpoints, step-over, locals window)
• Writing custom exception classes
• Practical session: Implementing robust error handling in a division function to prevent division by zero and debugging a provided code snippet with a logical error

Module 11: Working with Generics and Advanced Collections

• The motivation and benefits of using Generics
• Defining and using generic classes and methods
• Understanding constraints on generic types (where clause)
• Introduction to Dictionary<TKey, TValue> and its efficiency
• Utilizing HashSet<T> for high-performance unique item storage
• Practical session: Creating a generic repository class that can handle different types of data (e.g., Repository<User> and Repository<Product>)

Module 12: File System Input/Output (I/O)

• Reading and writing files using the StreamReader and StreamWriter
• Working with the File and Directory classes
• Path manipulation and checking for file existence
• Handling serialization and deserialization of objects (e.g., JSON)
• Utilizing the using statement for automatic resource cleanup
• Practical session: Building a file utility that reads configuration settings from a text file, processes them, and writes the results to a new file

Module 13: Introduction to LINQ (Language Integrated Query)

• The purpose of LINQ for querying data sources
• Understanding the syntax of LINQ query expressions
• Applying common LINQ operations (Where, Select, OrderBy, GroupBy)
• Using LINQ methods syntax for simplified queries
• Querying collections (objects in memory) and database tables (brief overview)
• Practical session: Using LINQ to query a list of complex objects (e.g., a list of Employee objects) to filter, sort, and group the results

Module 14: Asynchronous Programming with Async and Await

• Understanding the need for asynchronous programming (responsiveness, performance)
• The difference between synchronous and asynchronous calls
• Implementing the async and await keywords
• Handling asynchronous operations that return values
• Pitfalls of async programming (e.g., deadlocks - brief mention)
• Practical session: Creating an asynchronous method to simulate a long-running web request and updating the console interface without blocking

Module 15: Introduction to Relational Databases and ADO.NET

• Overview of SQL and the relational database model
• Connecting to a sample SQL database (e.g., local DB or mock)
• Executing basic SQL commands (SELECT, INSERT) using ADO.NET classes (SqlConnection, SqlCommand)
• Reading data using a SqlDataReader
• Parameterized queries to prevent SQL injection (security focus)
• Practical session: Writing a small application that connects to a database, retrieves a list of records, and displays them in the console

Module 16: Lambda Expressions and Delegates

• Understanding Delegates as type-safe function pointers
• Defining and using basic delegates
• Introduction to Func and Action built-in delegates
• Writing concise, inline methods using Lambda Expressions
• Using Lambdas with LINQ operations
• Practical session: Utilizing Func and Lambda expressions to pass custom filtering and sorting logic into a generic collection method

Module 17: .NET Core Fundamentals and Command Line Interface (CLI)

• Introduction to the cross-platform nature of .NET Core
• Using the .NET Command Line Interface (dotnet new, dotnet run, dotnet build)
• Understanding NuGet packages and package management
• Project structure and referencing external libraries
• Deploying a simple, self-contained application
• Practical session: Creating a new console project using the .NET CLI, adding a NuGet package, and running the application from the terminal

Module 18: Final Capstone Project and C# Best Practices

• Project requirements review and application architecture planning
• Integration of OOP principles, file I/O, and data structures
• Review of modern C# naming conventions and coding style (StyleCop, EditorConfig)
• Utilizing version control (Git) for the final project
• Preparing for next steps: Introduction to ASP.NET Core MVC/Web API
• Practical session: Dedicated work session on the capstone project, culminating in a presentation and final code review of the integrated C# application

Requirements:

• Participants should be reasonably proficient in English.
• Applicants must live up to Armstrong Global Institute admission criteria.

Terms and Conditions

1. Discounts: Organizations sponsoring Four Participants will have the 5th attend Free

2. What is catered for by the Course Fees: Fees cater for all requirements for the training – Learning materials, Lunches, Teas, Snacks and Certification. All participants will additionally cater for their travel and accommodation expenses, visa application, insurance, and other personal expenses.

3. Certificate Awarded: Participants are awarded Certificates of Participation at the end of the training.

4. The program content shown here is for guidance purposes only. Our continuous course improvement process may lead to changes in topics and course structure.

5. Approval of Course: Our Programs are NITA Approved. Participating organizations can therefore claim reimbursement on fees paid in accordance with NITA Rules.

Booking for Training

Simply send an email to the Training Officer on training@armstrongglobalinstitute.com and we will send you a registration form. We advise you to book early to avoid missing a seat to this training.

Or call us on +254720272325 / +254725012095 / +254724452588

Payment Options

We provide 3 payment options, choose one for your convenience, and kindly make payments at least 5 days before the Training start date to reserve your seat:

1. Groups of 5 People and Above – Cheque Payments to: Armstrong Global Training & Development Center Limited should be paid in advance, 5 days to the training.

2. Invoice: We can send a bill directly to you or your company.

3. Deposit directly into Bank Account (Account details provided upon request)

Cancellation Policy

1. Payment for all courses includes a registration fee, which is non-refundable, and equals 15% of the total sum of the course fee.

2. Participants may cancel attendance 14 days or more prior to the training commencement date.

3. No refunds will be made 14 days or less before the training commencement date. However, participants who are unable to attend may opt to attend a similar training course at a later date or send a substitute participant provided the participation criteria have been met.

Tailor Made Courses

This training course can also be customized for your institution upon request for a minimum of 5 participants. You can have it conducted at our Training Centre or at a convenient location. For further inquiries, please contact us on Tel: +254720272325 / +254725012095 / +254724452588 or Email training@armstrongglobalinstitute.com

Accommodation and Airport Transfer

Accommodation and Airport Transfer is arranged upon request and at extra cost. For reservations contact the Training Officer on Email: training@armstrongglobalinstitute.com or on Tel: +254720272325 / +254725012095 / +254724452588