Module 1: Introduction to C#

Objective: Understand the basics of C#, its history, key features, and set up the development environment to write and execute your first C# program.

1. What is C#?

• C# (C-Sharp) is a modern, object-oriented programming language developed by Microsoft.
• It is part of the .NET ecosystem, designed for developing a variety of applications, including web, desktop, mobile, and game applications.
• C# is strongly typed, which means it enforces strict type-checking, leading to fewer runtime errors.

2. Features of C#

Key Features:

1. Object-Oriented Programming (OOP):
   • Supports encapsulation, inheritance, and polymorphism.
2. Platform Independence:
   • Code is compiled into Intermediate Language (IL), which runs on the Common Language Runtime (CLR).
3. Type Safety:
   • Prevents unintended type errors (e.g., implicit type conversions).
4. Rich Library Support:
   • Offers a vast collection of libraries and frameworks through the .NET ecosystem.
5. Garbage Collection:
   • Automatically manages memory, reducing the risk of memory leaks.
6. Cross-Platform Development:
   • With .NET Core, C# programs can run on Windows, macOS, and Linux.

3. Installing .NET SDK and Setting Up an IDE

Step 1: Install the .NET SDK

1. Download the .NET SDK from the official .NET website.
2. Follow the installation instructions for your operating system (Windows, macOS, or Linux).
3. Verify the installation by opening a terminal or command prompt and typing:

   dotnet --version
   

Step 2: Install an IDE

Choose an Integrated Development Environment (IDE) for writing and running C# programs:

• Visual Studio:
  • Full-featured IDE for professional development.
  • Download: Visual Studio.
• Visual Studio Code:
  • Lightweight editor with C# extension support.
  • Download: VS Code.

4. Writing and Running Your First C# Program

Step 1: Create a New Console Application

1. Open a terminal or command prompt.
2. Navigate to a folder where you’d like to create your project.
3. Run the following command to create a new console application:

   dotnet new console -n HelloWorld
   

4. Navigate into the project directory:

   cd HelloWorld
   

Step 2: Open the Program File

1. Locate the file Program.cs in the project folder.
2. Open it in your IDE.

Step 3: Write Your Program

Replace the contents of Program.cs with the following code:

using System;

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Hello, World!");
    }
}

Step 4: Run Your Program

1. Open a terminal or command prompt.
2. Navigate to the project directory.
3. Run the program using the following command:

   dotnet run
   

5. Structure of a C# Program

using System;             // Namespace for standard input/output

class Program              // Class declaration
{
    static void Main(string[] args)   // Main method: Entry point of the program
    {
        Console.WriteLine("Hello, World!");  // Output to the console
    }
}

Explanation:

• using System: Imports the System namespace, which contains fundamental classes like Console.
• class Program: Defines a class named Program.
• static void Main(string[] args): The entry point of a C# application.
  • static: Indicates that the method belongs to the class, not an instance of the class.
  • void: Specifies that the method does not return a value.
  • string[] args: Accepts command-line arguments as an array of strings.

6. The Role of CLR and .NET Framework

Common Language Runtime (CLR):

• Acts as the runtime environment for executing C# programs.
• Responsibilities:
  • Compiling Intermediate Language (IL) code to machine code.
  • Memory management (via garbage collection).
  • Exception handling.
  • Security enforcement.

.NET Framework:

• A comprehensive development framework that provides:
  • Base Class Libraries (BCL) for core functionalities (e.g., file handling, networking).
  • Tools for building and running applications.

7. Practical Exercises

Exercise 1: Modify the Hello, World! Program

1. Add user input to your program.
2. Display a personalized greeting.

Solution:

using System;

class Program
{
    static void Main(string[] args)
    {
        Console.Write("Enter your name: ");
        string name = Console.ReadLine();  // Read user input
        Console.WriteLine($"Hello, {name}!");
    }
}

Exercise 2: Create a Simple Math Program

1. Write a program that accepts two numbers from the user.
2. Add the numbers and display the result.

Solution:

using System;

class Program
{
    static void Main(string[] args)
    {
        Console.Write("Enter the first number: ");
        int num1 = int.Parse(Console.ReadLine());  // Convert input to an integer

        Console.Write("Enter the second number: ");
        int num2 = int.Parse(Console.ReadLine());  // Convert input to an integer

        int sum = num1 + num2;  // Calculate the sum
        Console.WriteLine($"The sum is: {sum}");
    }
}

8. Summary

Key Takeaways:

1. C# Basics:
   • C# is a powerful, object-oriented programming language designed by Microsoft.
2. Setting Up:
   • Install the .NET SDK and an IDE like Visual Studio or VS Code to start coding.
3. First Program:
   • The Main() method serves as the entry point for your C# program.
4. CLR and .NET Framework:
   • CLR provides runtime services like garbage collection and exception handling.

Module 2: Variables and Data Types

Objective: Learn the fundamentals of variables, constants, and data types in C#. Understand type inference, nullable types, type casting, and common string operations.

1. Declaring Variables and Constants

A. Variables

• A variable is a named storage location that holds a value of a specific data type.
• Use the following syntax to declare a variable:

  dataType variableName = value;
  

B. Data Types in C#

1. Value Types:

   • int: Whole numbers (e.g., int age = 25;).
   • float, double: Decimal numbers (e.g., float height = 5.8f;).
   • bool: Boolean values (true or false).
   • char: Single character (e.g., char initial = 'A';).

2. Reference Types:

   • string: Sequence of characters (e.g., string name = "Alice";).

C. Constants

• Use the const keyword to define a value that cannot be changed after its declaration:

  const double PI = 3.14159;
  

2. Nullable Types

• In C#, value types (e.g., int, double) cannot be null by default.
• To allow null values, use the ? operator:

  int? nullableInt = null;
  

Example:

int? age = null;
if (age.HasValue)
    Console.WriteLine($"Age: {age.Value}");
else
    Console.WriteLine("Age is not set.");

3. Type Inference using var

• Use var to allow the compiler to infer the type of a variable based on the assigned value:

  var name = "Alice";  // Inferred as string
  var age = 25;        // Inferred as int
  

• var must be initialized during declaration:

  var height = 5.9;  // Allowed
  // var weight;    // Not allowed
  

4. Type Casting and Conversion

A. Implicit Casting

• Automatically performed when converting a smaller type to a larger type (e.g., int to double):

  int num = 10;
  double doubleNum = num;  // Implicit casting
  

B. Explicit Casting

• Required when converting a larger type to a smaller type:

  double num = 9.8;
  int intNum = (int)num;  // Explicit casting
  

C. Conversion Methods

• Use methods from the Convert class for safe conversions:

  string strNum = "123";
  int num = Convert.ToInt32(strNum);
  

5. Strings in C#

A. Declaring Strings

• A string is an immutable sequence of characters:

  string message = "Hello, World!";
  

B. Common String Operations

1. Length:

   • Get the number of characters in a string:

     string name = "Alice";
     Console.WriteLine(name.Length);  // Outputs: 5
     

2. Substring:

   • Extract part of a string:

     string message = "Hello, World!";
     Console.WriteLine(message.Substring(0, 5));  // Outputs: Hello
     

3. ToUpper and ToLower:

   • Convert strings to uppercase or lowercase:

     string name = "Alice";
     Console.WriteLine(name.ToUpper());  // Outputs: ALICE
     

4. Concatenation:

   • Combine strings using the + operator or String.Concat:

     string firstName = "Alice";
     string lastName = "Smith";
     string fullName = firstName + " " + lastName;
     Console.WriteLine(fullName);  // Outputs: Alice Smith
     

5. Interpolation:

   • Embed expressions into strings using $:

     string name = "Alice";
     int age = 25;
     Console.WriteLine($"Name: {name}, Age: {age}");  // Outputs: Name: Alice, Age: 25
     

6. Practical Exercises

Exercise 1: Input and Display Person Details

Problem: Write a program to input and display the name, age, and gender of a person.

Solution:

using System;

class Program
{
    static void Main(string[] args)
    {
        Console.Write("Enter your name: ");
        string name = Console.ReadLine();

        Console.Write("Enter your age: ");
        int age = int.Parse(Console.ReadLine());

        Console.Write("Enter your gender: ");
        string gender = Console.ReadLine();

        Console.WriteLine($"\nName: {name}\nAge: {age}\nGender: {gender}");
    }
}

Exercise 2: Type Conversion

Problem: Write a program to demonstrate explicit and implicit type conversion.

Solution:

using System;

class Program
{
    static void Main(string[] args)
    {
        // Implicit conversion
        int num = 10;
        double doubleNum = num;
        Console.WriteLine($"Implicit Conversion: int {num} -> double {doubleNum}");

        // Explicit conversion
        double doubleValue = 9.8;
        int intValue = (int)doubleValue;
        Console.WriteLine($"Explicit Conversion: double {doubleValue} -> int {intValue}");

        // Conversion using Convert class
        string strValue = "123";
        int convertedValue = Convert.ToInt32(strValue);
        Console.WriteLine($"String to Int Conversion: \"{strValue}\" -> {convertedValue}");
    }
}

7. Summary

Key Takeaways:

1. Variables and Constants:
   • Variables are used to store data, while constants store fixed values that cannot be modified.
2. Data Types:
   • C# provides value types (int, double) and reference types (string).
3. Nullable Types:
   • Allow value types to store null.
4. Type Inference:
   • Use var to let the compiler infer the type of a variable.
5. Strings:
   • C# provides rich string manipulation features like Length, Substring, and string interpolation.

Module 3: Control Flow

Objective: Learn how to control program execution in C# using decision-making structures and loops.

1. Decision-Making Statements

A. If-Else Statements

• Used to execute a block of code based on a condition.
• Syntax:

  if (condition) {
      // Code to execute if condition is true
  } else {
      // Code to execute if condition is false
  }
  

Example:

int number = 10;
if (number % 2 == 0) {
    Console.WriteLine("The number is even.");
} else {
    Console.WriteLine("The number is odd.");
}

B. Switch-Case Statements

• Used when multiple conditions need to be checked.
• Syntax:

  switch (variable) {
      case value1:
          // Code to execute for value1
          break;
      case value2:
          // Code to execute for value2
          break;
      default:
          // Code to execute if no cases match
          break;
  }
  

Example:

int day = 3;
switch (day) {
    case 1:
        Console.WriteLine("Monday");
        break;
    case 2:
        Console.WriteLine("Tuesday");
        break;
    case 3:
        Console.WriteLine("Wednesday");
        break;
    default:
        Console.WriteLine("Invalid day");
        break;
}

2. Loops

A. For Loop

• Executes a block of code a specific number of times.
• Syntax:

  for (initialization; condition; increment/decrement) {
      // Code to execute
  }
  

Example:

for (int i = 1; i <= 5; i++) {
    Console.WriteLine($"Iteration: {i}");
}

B. While Loop

• Executes a block of code while a condition is true.
• Syntax:

  while (condition) {
      // Code to execute
  }
  

Example:

int count = 1;
while (count <= 3) {
    Console.WriteLine($"Count: {count}");
    count++;
}

C. Do-While Loop

• Executes a block of code at least once, then repeats while a condition is true.
• Syntax:

  do {
      // Code to execute
  } while (condition);
  

Example:

int count = 1;
do {
    Console.WriteLine($"Count: {count}");
    count++;
} while (count <= 3);

D. Foreach Loop

• Iterates over a collection (e.g., arrays, lists).
• Syntax:

  foreach (var item in collection) {
      // Code to execute for each item
  }
  

Example:

string[] fruits = { "Apple", "Banana", "Cherry" };
foreach (string fruit in fruits) {
    Console.WriteLine(fruit);
}

3. Logical Operators

Example:

int age = 20;
if (age >= 18 && age <= 30) {
    Console.WriteLine("You are eligible.");
} else {
    Console.WriteLine("Not eligible.");
}

4. Breaking Out of Loops

A. Break

• Exits a loop prematurely.

Example:

for (int i = 1; i <= 5; i++) {
    if (i == 3) {
        break;  // Exit loop
    }
    Console.WriteLine($"i: {i}");
}

B. Continue

• Skips the rest of the current iteration and moves to the next.

Example:

for (int i = 1; i <= 5; i++) {
    if (i == 3) {
        continue;  // Skip iteration
    }
    Console.WriteLine($"i: {i}");
}

5. Practical Exercises

Exercise 1: Calculate Factorial Using a For Loop

Problem: Write a program to calculate the factorial of a number using a for loop.

Solution:

using System;

class Program {
    static void Main(string[] args) {
        Console.Write("Enter a number: ");
        int num = int.Parse(Console.ReadLine());

        int factorial = 1;
        for (int i = 1; i <= num; i++) {
            factorial *= i;
        }

        Console.WriteLine($"Factorial of {num} is {factorial}");
    }
}

Exercise 2: Determine Even or Odd Using If-Else

Problem: Write a program to check whether a number is even or odd.

Solution:

using System;

class Program {
    static void Main(string[] args) {
        Console.Write("Enter a number: ");
        int num = int.Parse(Console.ReadLine());

        if (num % 2 == 0) {
            Console.WriteLine("The number is even.");
        } else {
            Console.WriteLine("The number is odd.");
        }
    }
}

6. Summary

Key Takeaways:

1. Decision-Making Statements:
   • Use if-else for simple conditions and switch-case for multiple conditions.
2. Loops:
   • Use loops (for, while, do-while, foreach) to repeat actions.
3. Logical Operators:
   • Combine conditions using logical operators like &&, ||, and !.
4. Breaking Out of Loops:
   • Use break to exit a loop and continue to skip an iteration.

Module 4: Methods and Functions

Objective: Learn how to write reusable, modular, and efficient code using methods in C#. Understand the concepts of method parameters, return types, overloading, and recursion.

1. Defining and Calling Methods

A. What is a Method?

A method is a block of code that performs a specific task. It can be reused by calling it from different parts of a program.

B. Syntax

returnType MethodName(parameters) {
    // Method body
    return value;  // Optional (only if returnType is not void)
}

Example: Simple Method

using System;

class Program {
    static void Greet() {
        Console.WriteLine("Hello, World!");
    }

    static void Main(string[] args) {
        Greet();  // Calling the method
    }
}

2. Method Parameters (Value vs Reference)

A. Value Parameters

• By default, parameters are passed by value.
• Modifications to the parameter inside the method do not affect the original value.

Example:

void IncrementValue(int num) {
    num++;
    Console.WriteLine($"Inside method: {num}");
}

int x = 5;
IncrementValue(x);
Console.WriteLine($"Outside method: {x}");

B. Reference Parameters

• Use the ref or out keywords to pass parameters by reference, allowing modifications to affect the original value.

Using ref:

void IncrementRef(ref int num) {
    num++;
}

int x = 5;
IncrementRef(ref x);
Console.WriteLine($"After method: {x}");

Using out:

• out parameters must be assigned a value inside the method.

void Initialize(out int num) {
    num = 10;
}

int x;
Initialize(out x);
Console.WriteLine($"Initialized value: {x}");

3. Return Types and Void

A. Methods with Return Types

• Use methods that return a value when you need to send back a result.

Example:

int Add(int a, int b) {
    return a + b;
}

int result = Add(3, 5);
Console.WriteLine($"Result: {result}");

B. Void Methods

• Use void when the method does not need to return a value.

Example:

void PrintMessage(string message) {
    Console.WriteLine(message);
}

PrintMessage("Hello, Methods!");

4. Method Overloading

• Method overloading allows multiple methods with the same name but different parameter lists.

Example:

int Add(int a, int b) {
    return a + b;
}

double Add(double a, double b) {
    return a + b;
}

Console.WriteLine(Add(3, 5));         // Calls the int version
Console.WriteLine(Add(3.5, 5.2));    // Calls the double version

5. Recursion in C#

• A recursive method calls itself to solve a problem in smaller steps.

Example: Factorial Calculation

int Factorial(int n) {
    if (n == 1) return 1;
    return n * Factorial(n - 1);
}

Console.WriteLine($"Factorial: {Factorial(5)}");

6. Practical Exercises

Exercise 1: Calculate Area of Different Shapes

Problem:

Write a method to calculate the area of a circle and another method for the area of a rectangle.

Solution:

using System;

class Program {
    static double CircleArea(double radius) {
        return Math.PI * radius * radius;
    }

    static double RectangleArea(double length, double width) {
        return length * width;
    }

    static void Main(string[] args) {
        Console.WriteLine($"Circle Area: {CircleArea(5)}");
        Console.WriteLine($"Rectangle Area: {RectangleArea(4, 6)}");
    }
}

Exercise 2: Fibonacci Using Recursion

Problem:

Write a recursive method to find the nth Fibonacci number.

Solution:

using System;

class Program {
    static int Fibonacci(int n) {
        if (n <= 1) return n;
        return Fibonacci(n - 1) + Fibonacci(n - 2);
    }

    static void Main(string[] args) {
        Console.Write("Enter the position (n): ");
        int n = int.Parse(Console.ReadLine());
        Console.WriteLine($"Fibonacci({n}): {Fibonacci(n)}");
    }
}

7. Summary

Key Takeaways:

1. Defining Methods:
   • Methods encapsulate code for reuse and modularity.
   • Syntax: returnType MethodName(parameters).
2. Parameters:
   • Use ref and out for reference parameters.
   • Default is value parameter passing.
3. Return Types:
   • Use return types for methods that produce results.
   • Use void for methods that do not return values.
4. Method Overloading:
   • Multiple methods can share the same name if their parameter lists differ.
5. Recursion:
   • A method can call itself for tasks like factorials or Fibonacci sequences.

Module 5: Object-Oriented Programming (OOP) Basics

Objective: Learn the fundamentals of Object-Oriented Programming (OOP) in C#. Understand the concepts of classes, objects, encapsulation, constructors, and static members.

1. Classes and Objects

A. What is a Class?

• A class is a blueprint for creating objects. It defines the properties and behaviors (methods) of an object.
• Syntax:

  class ClassName {
      // Properties
      // Methods
  }
  

B. What is an Object?

• An object is an instance of a class. It holds specific data and allows you to access class methods and properties.

Example:

class Car {
    public string Make;
    public string Model;
    public int Year;
}

class Program {
    static void Main(string[] args) {
        Car myCar = new Car();  // Object creation
        myCar.Make = "Toyota";
        myCar.Model = "Corolla";
        myCar.Year = 2020;

        Console.WriteLine($"Car: {myCar.Make} {myCar.Model}, Year: {myCar.Year}");
    }
}

2. Properties (Getters and Setters)

• Properties are used to encapsulate fields and control how they are accessed or modified.
• Auto-Implemented Properties:

  public string Make { get; set; }
  public int Year { get; set; }
  

Example:

class Car {
    public string Make { get; set; }
    public string Model { get; set; }
    public int Year { get; set; }
}

class Program {
    static void Main(string[] args) {
        Car myCar = new Car {
            Make = "Honda",
            Model = "Civic",
            Year = 2021
        };

        Console.WriteLine($"Car: {myCar.Make} {myCar.Model}, Year: {myCar.Year}");
    }
}

3. Constructors

A. Default Constructor

• A default constructor has no parameters and initializes default values.

Example:

class Car {
    public string Make { get; set; }
    public string Model { get; set; }
    public int Year { get; set; }

    public Car() {  // Default constructor
        Make = "Unknown";
        Model = "Unknown";
        Year = 0;
    }
}

B. Parameterized Constructor

• A constructor that accepts parameters to initialize values.

Example:

class Car {
    public string Make { get; set; }
    public string Model { get; set; }
    public int Year { get; set; }

    public Car(string make, string model, int year) {  // Parameterized constructor
        Make = make;
        Model = model;
        Year = year;
    }
}

class Program {
    static void Main(string[] args) {
        Car myCar = new Car("Ford", "Fusion", 2019);
        Console.WriteLine($"Car: {myCar.Make} {myCar.Model}, Year: {myCar.Year}");
    }
}

4. Encapsulation

• Encapsulation hides the internal implementation details of a class and exposes only necessary properties and methods.
• Use private fields with public properties to implement encapsulation.

Example:

class BankAccount {
    private double balance;

    public double Balance {
        get { return balance; }
        set {
            if (value >= 0) balance = value;
            else Console.WriteLine("Balance cannot be negative!");
        }
    }
}

class Program {
    static void Main(string[] args) {
        BankAccount account = new BankAccount();
        account.Balance = 500;  // Valid
        Console.WriteLine($"Balance: {account.Balance}");

        account.Balance = -100;  // Invalid
    }
}

5. Static Members

• Static members belong to the class, not an instance. They can be accessed without creating an object.
• Use the static keyword to define static fields, properties, or methods.

Example:

class Counter {
    public static int Count { get; private set; }

    public Counter() {
        Count++;
    }
}

class Program {
    static void Main(string[] args) {
        Counter c1 = new Counter();
        Counter c2 = new Counter();
        Counter c3 = new Counter();

        Console.WriteLine($"Number of Counter objects created: {Counter.Count}");
    }
}

6. Practical Exercises

Exercise 1: Create a Car Class

Problem: Create a Car class with properties Make, Model, and Year. Add a method to display car details.

Solution:

class Car {
    public string Make { get; set; }
    public string Model { get; set; }
    public int Year { get; set; }

    public void DisplayDetails() {
        Console.WriteLine($"Car: {Make} {Model}, Year: {Year}");
    }
}

class Program {
    static void Main(string[] args) {
        Car car = new Car {
            Make = "Toyota",
            Model = "Camry",
            Year = 2022
        };

        car.DisplayDetails();
    }
}

Exercise 2: Static Property to Count Objects

Problem: Create a class with a static property to count the number of objects created from the class.

Solution:

class Employee {
    public string Name { get; set; }
    public static int Count { get; private set; }

    public Employee(string name) {
        Name = name;
        Count++;
    }
}

class Program {
    static void Main(string[] args) {
        Employee e1 = new Employee("Alice");
        Employee e2 = new Employee("Bob");
        Employee e3 = new Employee("Charlie");

        Console.WriteLine($"Number of employees created: {Employee.Count}");
    }
}

7. Summary

Key Takeaways:

1. Classes and Objects:
   • Classes are blueprints; objects are instances of classes.
2. Properties:
   • Encapsulate fields with getters and setters.
3. Constructors:
   • Use default or parameterized constructors to initialize object properties.
4. Encapsulation:
   • Use private fields with public properties to hide implementation details.
5. Static Members:
   • Belong to the class and can be accessed without an instance.

Module 6: Advanced OOP Concepts

Objective: Dive deeper into Object-Oriented Programming (OOP) by exploring inheritance, polymorphism, abstraction, and sealed classes.

1. Inheritance

A. What is Inheritance?

• Inheritance allows a class (derived class) to inherit members (fields, properties, methods) from another class (base class).

B. Syntax

class BaseClass {
    // Members of the base class
}

class DerivedClass : BaseClass {
    // Members of the derived class
}

C. Using the base Keyword

• Use base to call members or constructors of the base class from the derived class.

Example:

class Animal {
    public string Name { get; set; }

    public Animal(string name) {
        Name = name;
    }

    public void Speak() {
        Console.WriteLine($"{Name} makes a sound.");
    }
}

class Dog : Animal {
    public Dog(string name) : base(name) { }  // Using base keyword

    public void Bark() {
        Console.WriteLine($"{Name} barks.");
    }
}

class Program {
    static void Main(string[] args) {
        Dog dog = new Dog("Buddy");
        dog.Speak();  // Inherited from Animal
        dog.Bark();   // Defined in Dog
    }
}

2. Polymorphism

A. What is Polymorphism?

• Polymorphism allows methods in derived classes to have different behaviors while sharing the same name as the base class methods.

B. Method Overriding

• Use the virtual keyword in the base class and the override keyword in the derived class.

Example:

class Animal {
    public string Name { get; set; }

    public Animal(string name) {
        Name = name;
    }

    public virtual void Speak() {
        Console.WriteLine($"{Name} makes a generic sound.");
    }
}

class Dog : Animal {
    public Dog(string name) : base(name) { }

    public override void Speak() {
        Console.WriteLine($"{Name} barks.");
    }
}

class Cat : Animal {
    public Cat(string name) : base(name) { }

    public override void Speak() {
        Console.WriteLine($"{Name} meows.");
    }
}

class Program {
    static void Main(string[] args) {
        Animal dog = new Dog("Buddy");
        Animal cat = new Cat("Whiskers");

        dog.Speak();  // Output: Buddy barks.
        cat.Speak();  // Output: Whiskers meows.
    }
}

3. Abstract Classes and Interfaces

A. Abstract Classes

• Abstract classes cannot be instantiated and can have abstract (without implementation) and non-abstract methods.
• Use the abstract keyword.

Example:

abstract class Shape {
    public abstract double CalculateArea();  // Abstract method
    public virtual void Display() {
        Console.WriteLine("This is a shape.");
    }
}

class Circle : Shape {
    public double Radius { get; set; }

    public Circle(double radius) {
        Radius = radius;
    }

    public override double CalculateArea() {
        return Math.PI * Radius * Radius;
    }
}

B. Interfaces

• Interfaces define a contract that classes must implement.
• Use the interface keyword.

Example:

interface IShape {
    double CalculateArea();
}

class Rectangle : IShape {
    public double Width { get; set; }
    public double Height { get; set; }

    public Rectangle(double width, double height) {
        Width = width;
        Height = height;
    }

    public double CalculateArea() {
        return Width * Height;
    }
}

4. Sealed Classes

• A sealed class cannot be inherited by other classes.
• Use the sealed keyword.

Example:

sealed class FinalClass {
    public void Display() {
        Console.WriteLine("This is a sealed class.");
    }
}

// The following would cause a compilation error:
// class DerivedClass : FinalClass { }

5. Practical Exercises

Exercise 1: Class Hierarchy for Animals

Problem: Create a class hierarchy where Animal is the base class, and Dog and Cat are derived classes. Demonstrate polymorphism by overriding a Speak method.

Solution:

class Animal {
    public string Name { get; set; }

    public Animal(string name) {
        Name = name;
    }

    public virtual void Speak() {
        Console.WriteLine($"{Name} makes a sound.");
    }
}

class Dog : Animal {
    public Dog(string name) : base(name) { }

    public override void Speak() {
        Console.WriteLine($"{Name} barks.");
    }
}

class Cat : Animal {
    public Cat(string name) : base(name) { }

    public override void Speak() {
        Console.WriteLine($"{Name} meows.");
    }
}

class Program {
    static void Main(string[] args) {
        Animal[] animals = {
            new Dog("Buddy"),
            new Cat("Whiskers"),
        };

        foreach (Animal animal in animals) {
            animal.Speak();
        }
    }
}

Exercise 2: Using an Interface for Shapes

Problem: Create an interface IShape with a CalculateArea method. Implement it in Circle and Rectangle classes.

Solution:

interface IShape {
    double CalculateArea();
}

class Circle : IShape {
    public double Radius { get; set; }

    public Circle(double radius) {
        Radius = radius;
    }

    public double CalculateArea() {
        return Math.PI * Radius * Radius;
    }
}

class Rectangle : IShape {
    public double Width { get; set; }
    public double Height { get; set; }

    public Rectangle(double width, double height) {
        Width = width;
        Height = height;
    }

    public double CalculateArea() {
        return Width * Height;
    }
}

class Program {
    static void Main(string[] args) {
        IShape circle = new Circle(5);
        IShape rectangle = new Rectangle(4, 6);

        Console.WriteLine($"Circle Area: {circle.CalculateArea()}");
        Console.WriteLine($"Rectangle Area: {rectangle.CalculateArea()}");
    }
}

6. Summary

Key Takeaways:

1. Inheritance:
   • Share common functionality using base and derived classes.
   • Use the base keyword to access base class members.
2. Polymorphism:
   • Use virtual and override to implement polymorphism.
3. Abstract Classes and Interfaces:
   • Abstract classes can have both implemented and unimplemented methods.
   • Interfaces provide a contract that classes must implement.
4. Sealed Classes:
   • Use sealed to prevent inheritance.

Module 7: Collections and Generics

Objective: Learn how to manage collections of data in C# using built-in collection types and generics for type safety. Understand how to work with lists, dictionaries, and other collection types, and explore generic methods and classes.

1. Collections Overview

A. Arrays

• Fixed-size collection of elements of the same type.
• Example:

int[] numbers = { 1, 2, 3, 4, 5 };
foreach (int num in numbers) {
    Console.WriteLine(num);
}

B. Lists

• Dynamic collection that can grow and shrink.
• Example:

List<int> numbers = new List<int> { 1, 2, 3 };
numbers.Add(4);
numbers.Remove(2);
Console.WriteLine($"Count: {numbers.Count}");

2. Built-In Generic Collections

A. List

• A dynamic array-like structure.
• Key Methods:
  • Add(), Remove(), Contains(), Count.

Example:

List<string> fruits = new List<string> { "Apple", "Banana" };
fruits.Add("Cherry");
Console.WriteLine($"First fruit: {fruits[0]}");

B. Dictionary<TKey, TValue>

• A key-value pair collection.
• Key Methods:
  • Add(), Remove(), ContainsKey(), TryGetValue().

Example:

Dictionary<int, string> employees = new Dictionary<int, string> {
    { 1, "Alice" },
    { 2, "Bob" }
};

employees.Add(3, "Charlie");
if (employees.ContainsKey(2)) {
    Console.WriteLine($"Employee 2: {employees[2]}");
}

C. Queue

• First-in, first-out (FIFO) collection.
• Key Methods:
  • Enqueue(), Dequeue(), Peek().

Example:

Queue<string> tasks = new Queue<string>();
tasks.Enqueue("Task 1");
tasks.Enqueue("Task 2");

Console.WriteLine(tasks.Dequeue());  // Outputs: Task 1

D. Stack

• Last-in, first-out (LIFO) collection.
• Key Methods:
  • Push(), Pop(), Peek().

Example:

Stack<int> stack = new Stack<int>();
stack.Push(1);
stack.Push(2);

Console.WriteLine(stack.Pop());  // Outputs: 2

3. Iterating Through Collections

• Use the foreach loop to iterate over collections.

Example:

List<string> fruits = new List<string> { "Apple", "Banana", "Cherry" };
foreach (string fruit in fruits) {
    Console.WriteLine(fruit);
}

4. Generics

A. What are Generics?

• Generics provide type safety by allowing classes, methods, and collections to work with any data type while ensuring compile-time type checking.

B. Generic Methods

• Define methods that operate on different types.

Syntax:

public static T Max<T>(T a, T b) where T : IComparable<T> {
    return a.CompareTo(b) > 0 ? a : b;
}

Example:

Console.WriteLine(Max(3, 5));  // Outputs: 5
Console.WriteLine(Max("apple", "banana"));  // Outputs: banana

C. Generic Classes

• Create classes that work with any data type.

Syntax:

class Box<T> {
    public T Value { get; set; }

    public Box(T value) {
        Value = value;
    }
}

Example:

Box<int> intBox = new Box<int>(5);
Box<string> stringBox = new Box<string>("Hello");
Console.WriteLine(intBox.Value);  // Outputs: 5
Console.WriteLine(stringBox.Value);  // Outputs: Hello

5. Practical Exercises

Exercise 1: Store and Retrieve Employee Data Using a Dictionary

Problem:

Create a program that stores employee data (ID and Name) in a dictionary and retrieves the data based on user input.

Solution:

using System;
using System.Collections.Generic;

class Program {
    static void Main(string[] args) {
        Dictionary<int, string> employees = new Dictionary<int, string> {
            { 1, "Alice" },
            { 2, "Bob" },
            { 3, "Charlie" }
        };

        Console.Write("Enter Employee ID: ");
        int id = int.Parse(Console.ReadLine());

        if (employees.TryGetValue(id, out string name)) {
            Console.WriteLine($"Employee Name: {name}");
        } else {
            Console.WriteLine("Employee not found.");
        }
    }
}

Exercise 2: Generic Method to Find Maximum Value in an Array

Problem:

Write a generic method to find the maximum value in an array.

Solution:

using System;

class Program {
    public static T FindMax<T>(T[] array) where T : IComparable<T> {
        T max = array[0];
        foreach (T item in array) {
            if (item.CompareTo(max) > 0) {
                max = item;
            }
        }
        return max;
    }

    static void Main(string[] args) {
        int[] numbers = { 3, 5, 7, 2, 9 };
        Console.WriteLine($"Maximum: {FindMax(numbers)}");

        string[] words = { "apple", "orange", "banana" };
        Console.WriteLine($"Maximum: {FindMax(words)}");
    }
}

6. Summary

Key Takeaways:

1. Collections:
   • Use List<T> for dynamic arrays, Dictionary<TKey, TValue> for key-value pairs, Queue<T> for FIFO, and Stack<T> for LIFO operations.
2. Generics:
   • Provide type safety and reduce code duplication for classes, methods, and collections.
3. Iteration:
   • Use foreach to loop through collections efficiently.
4. Practical Applications:
   • Dictionaries are ideal for mapping data like employee IDs to names.
   • Generic methods and classes allow you to create reusable and flexible code.

Module 8: Exception Handling

Objective: Learn to handle runtime errors gracefully in C# using exception handling mechanisms. Understand how to use try-catch-finally blocks, recognize common exceptions, throw exceptions, and create custom exceptions.

1. Try-Catch-Finally Blocks

A. Syntax

• try contains code that may throw exceptions.
• catch handles specific exceptions or a general exception.
• finally is optional and executes regardless of whether an exception occurred.

Example:

try {
    int num = int.Parse("InvalidNumber");  // Throws FormatException
} catch (FormatException e) {
    Console.WriteLine($"Error: {e.Message}");
} finally {
    Console.WriteLine("This block always executes.");
}

B. Multiple Catch Blocks

• You can handle specific exceptions using multiple catch blocks.

Example:

try {
    int[] numbers = { 1, 2, 3 };
    Console.WriteLine(numbers[5]);  // Throws IndexOutOfRangeException
} catch (IndexOutOfRangeException e) {
    Console.WriteLine("Index out of range.");
} catch (Exception e) {
    Console.WriteLine($"An error occurred: {e.Message}");
}

2. Common Exceptions

A. NullReferenceException

• Thrown when trying to access a member on a null object.

Example:

string name = null;
try {
    Console.WriteLine(name.Length);  // Throws NullReferenceException
} catch (NullReferenceException e) {
    Console.WriteLine("Cannot access a member on a null object.");
}

B. IndexOutOfRangeException

• Thrown when accessing an array index that is out of bounds.

Example:

try {
    int[] numbers = { 1, 2, 3 };
    Console.WriteLine(numbers[5]);
} catch (IndexOutOfRangeException e) {
    Console.WriteLine("Array index is out of range.");
}

3. Throwing Exceptions

A. Syntax

• Use the throw keyword to manually raise an exception.

Example:

try {
    int age = -5;
    if (age < 0) {
        throw new ArgumentException("Age cannot be negative.");
    }
} catch (ArgumentException e) {
    Console.WriteLine($"Error: {e.Message}");
}

4. Custom Exceptions

• Create custom exceptions by inheriting from the Exception class.

Example:

class InvalidAgeException : Exception {
    public InvalidAgeException(string message) : base(message) { }
}

class Program {
    static void ValidateAge(int age) {
        if (age < 0 || age > 150) {
            throw new InvalidAgeException("Age must be between 0 and 150.");
        }
    }

    static void Main(string[] args) {
        try {
            ValidateAge(-5);
        } catch (InvalidAgeException e) {
            Console.WriteLine($"Custom Exception: {e.Message}");
        }
    }
}

5. Practical Exercises

Exercise 1: Catch Exceptions for Invalid Input

Problem: Write a program to read a number from the user and catch exceptions for invalid input.

Solution:

using System;

class Program {
    static void Main(string[] args) {
        try {
            Console.Write("Enter a number: ");
            int num = int.Parse(Console.ReadLine());
            Console.WriteLine($"You entered: {num}");
        } catch (FormatException) {
            Console.WriteLine("Invalid input. Please enter a valid number.");
        } catch (Exception e) {
            Console.WriteLine($"An error occurred: {e.Message}");
        } finally {
            Console.WriteLine("Program execution complete.");
        }
    }
}

Exercise 2: Custom Exception for Invalid Age

Problem: Implement a program that throws a custom exception for invalid age inputs.

Solution:

using System;

class InvalidAgeException : Exception {
    public InvalidAgeException(string message) : base(message) { }
}

class Program {
    static void ValidateAge(int age) {
        if (age < 0 || age > 120) {
            throw new InvalidAgeException("Age must be between 0 and 120.");
        }
    }

    static void Main(string[] args) {
        try {
            Console.Write("Enter your age: ");
            int age = int.Parse(Console.ReadLine());
            ValidateAge(age);
            Console.WriteLine($"Your age is: {age}");
        } catch (InvalidAgeException e) {
            Console.WriteLine($"Error: {e.Message}");
        } catch (Exception e) {
            Console.WriteLine($"An unexpected error occurred: {e.Message}");
        }
    }
}

6. Summary

Key Takeaways:

1. Try-Catch-Finally:
   • Use try-catch blocks to handle runtime errors.
   • The finally block executes regardless of whether an exception occurred.
2. Common Exceptions:
   • NullReferenceException: Thrown when accessing members on a null object.
   • IndexOutOfRangeException: Thrown when accessing an array index out of bounds.
3. Throwing Exceptions:
   • Use throw to raise exceptions manually.
4. Custom Exceptions:
   • Create custom exceptions by inheriting from the Exception class for specialized error handling.

Module 9: File Handling

Objective: Learn how to perform file operations in C#, including reading, writing, and managing files and directories using File, StreamReader, and StreamWriter.

1. Reading and Writing Text Files

A. Reading Files

• Use File.ReadAllText or File.ReadAllLines to read the contents of a text file.

Example: Reading a File

using System;

class Program {
    static void Main(string[] args) {
        try {
            string content = File.ReadAllText("example.txt");
            Console.WriteLine("File Content:");
            Console.WriteLine(content);
        } catch (Exception e) {
            Console.WriteLine($"Error: {e.Message}");
        }
    }
}

B. Writing Files

• Use File.WriteAllText or File.AppendAllText to write to or append data to a file.

Example: Writing to a File

using System;

class Program {
    static void Main(string[] args) {
        try {
            File.WriteAllText("example.txt", "Hello, World!");
            Console.WriteLine("Data written to file.");
        } catch (Exception e) {
            Console.WriteLine($"Error: {e.Message}");
        }
    }
}

Example: Appending to a File

using System;

class Program {
    static void Main(string[] args) {
        try {
            File.AppendAllText("example.txt", "\nNew Line Added!");
            Console.WriteLine("Data appended to file.");
        } catch (Exception e) {
            Console.WriteLine($"Error: {e.Message}");
        }
    }
}

2. Using StreamReader and StreamWriter

A. StreamReader

• Allows reading a file line by line for efficient memory usage.

Example: Reading Line by Line

using System;
using System.IO;

class Program {
    static void Main(string[] args) {
        try {
            using (StreamReader reader = new StreamReader("example.txt")) {
                string line;
                while ((line = reader.ReadLine()) != null) {
                    Console.WriteLine(line);
                }
            }
        } catch (Exception e) {
            Console.WriteLine($"Error: {e.Message}");
        }
    }
}

B. StreamWriter

• Writes to a file, either overwriting or appending data.

Example: Writing with StreamWriter

using System;
using System.IO;

class Program {
    static void Main(string[] args) {
        try {
            using (StreamWriter writer = new StreamWriter("example.txt")) {
                writer.WriteLine("Hello, StreamWriter!");
            }
            Console.WriteLine("Data written to file.");
        } catch (Exception e) {
            Console.WriteLine($"Error: {e.Message}");
        }
    }
}

3. Handling Binary Files

A. Reading Binary Data

• Use FileStream to read binary data from files.

Example: Reading Binary File

using System;
using System.IO;

class Program {
    static void Main(string[] args) {
        try {
            using (FileStream fs = new FileStream("example.dat", FileMode.Open)) {
                byte[] data = new byte[fs.Length];
                fs.Read(data, 0, data.Length);

                Console.WriteLine("Binary Data:");
                foreach (byte b in data) {
                    Console.Write($"{b} ");
                }
            }
        } catch (Exception e) {
            Console.WriteLine($"Error: {e.Message}");
        }
    }
}

B. Writing Binary Data

• Write binary data to a file using FileStream.

Example: Writing Binary File

using System;
using System.IO;

class Program {
    static void Main(string[] args) {
        try {
            byte[] data = { 0x01, 0x02, 0x03, 0x04 };
            using (FileStream fs = new FileStream("example.dat", FileMode.Create)) {
                fs.Write(data, 0, data.Length);
            }
            Console.WriteLine("Binary data written to file.");
        } catch (Exception e) {
            Console.WriteLine($"Error: {e.Message}");
        }
    }
}

4. File Paths and Directories

A. Working with File Paths

• Use the Path class to manipulate file paths.

Example:

using System;

class Program {
    static void Main(string[] args) {
        string filePath = @"C:\Users\Example\example.txt";
        Console.WriteLine($"File Name: {Path.GetFileName(filePath)}");
        Console.WriteLine($"Directory: {Path.GetDirectoryName(filePath)}");
        Console.WriteLine($"Extension: {Path.GetExtension(filePath)}");
    }
}

B. Directory Operations

• Create, delete, and list directories using the Directory class.

Example:

using System;
using System.IO;

class Program {
    static void Main(string[] args) {
        string dirPath = "TestDir";

        if (!Directory.Exists(dirPath)) {
            Directory.CreateDirectory(dirPath);
            Console.WriteLine("Directory created.");
        }

        string[] files = Directory.GetFiles(dirPath);
        Console.WriteLine("Files in directory:");
        foreach (string file in files) {
            Console.WriteLine(file);
        }
    }
}

5. Practical Exercises

Exercise 1: Read Data from a File

Problem: Create a program to read data from a file and display it line by line.

Solution:

using System;
using System.IO;

class Program {
    static void Main(string[] args) {
        try {
            using (StreamReader reader = new StreamReader("data.txt")) {
                string line;
                while ((line = reader.ReadLine()) != null) {
                    Console.WriteLine(line);
                }
            }
        } catch (FileNotFoundException) {
            Console.WriteLine("File not found.");
        } catch (Exception e) {
            Console.WriteLine($"Error: {e.Message}");
        }
    }
}

Exercise 2: Append User Input to a Log File

Problem: Write a program to take user input and append it to a log file.

Solution:

using System;
using System.IO;

class Program {
    static void Main(string[] args) {
        try {
            Console.Write("Enter a log message: ");
            string logMessage = Console.ReadLine();

            using (StreamWriter writer = new StreamWriter("log.txt", true)) {
                writer.WriteLine($"{DateTime.Now}: {logMessage}");
            }

            Console.WriteLine("Log message appended to file.");
        } catch (Exception e) {
            Console.WriteLine($"Error: {e.Message}");
        }
    }
}

6. Summary

Key Takeaways:

1. File Operations:
   • Use File class for simple operations like ReadAllText and WriteAllText.
   • Use StreamReader and StreamWriter for more control.
2. Binary Files:
   • Use FileStream to read and write binary data.
3. File Paths:
   • The Path class simplifies file path operations.
4. Directories:
   • Use Directory class for managing folders.
5. Practical Use:
   • Reading and writing files are essential for logging, configuration, and data persistence.

Module 10: LINQ (Language Integrated Query)

Objective: Understand and apply LINQ to query collections and databases effectively. Learn about LINQ syntax, filtering, sorting, and grouping operations to handle data in an expressive and readable way.

1. Introduction to LINQ

• What is LINQ?
  • LINQ (Language Integrated Query) is a feature in C# that allows querying collections, XML, databases, and other data sources in a consistent and type-safe manner.
  • It provides two syntaxes:
    • Query syntax: Similar to SQL.
    • Method syntax: Uses lambda expressions.

2. LINQ Basics

A. Query Syntax

• Queries are written using a declarative SQL-like syntax.

Example:

int[] numbers = { 1, 2, 3, 4, 5 };

var evenNumbers = from num in numbers
                  where num % 2 == 0
                  select num;

foreach (var num in evenNumbers) {
    Console.WriteLine(num);  // Output: 2, 4
}

B. Method Syntax

• Queries are written using extension methods with lambda expressions.

Example:

int[] numbers = { 1, 2, 3, 4, 5 };

var evenNumbers = numbers.Where(num => num % 2 == 0);

foreach (var num in evenNumbers) {
    Console.WriteLine(num);  // Output: 2, 4
}

3. LINQ Operations

A. Filtering Data

• Use the where clause (query syntax) or the Where() method (method syntax) to filter data.

Example:

string[] names = { "Alice", "Bob", "Charlie", "Anna" };

var filteredNames = names.Where(name => name.StartsWith("A"));

foreach (var name in filteredNames) {
    Console.WriteLine(name);  // Output: Alice, Anna
}

B. Sorting Data

• Use the orderby clause (query syntax) or OrderBy()/OrderByDescending() (method syntax).

Example:

int[] numbers = { 5, 2, 8, 1, 3 };

var sortedNumbers = numbers.OrderBy(num => num);

foreach (var num in sortedNumbers) {
    Console.WriteLine(num);  // Output: 1, 2, 3, 5, 8
}

C. Grouping Data

• Use the group clause (query syntax) or GroupBy() (method syntax) to group data.

Example:

string[] names = { "Alice", "Bob", "Charlie", "Anna" };

var groupedNames = from name in names
                   group name by name[0];

foreach (var group in groupedNames) {
    Console.WriteLine($"Group: {group.Key}");
    foreach (var name in group) {
        Console.WriteLine($"  {name}");
    }
}

4. Using LINQ with Collections

• LINQ can work seamlessly with lists, arrays, and other collections.

Example:

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };

var oddNumbers = numbers.Where(num => num % 2 != 0);

foreach (var num in oddNumbers) {
    Console.WriteLine(num);  // Output: 1, 3, 5
}

5. Practical Exercises

Exercise 1: Filter Even Numbers

Problem: Write a LINQ query to filter even numbers from a list.

Solution:

using System;
using System.Linq;
using System.Collections.Generic;

class Program {
    static void Main(string[] args) {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6 };

        var evenNumbers = numbers.Where(num => num % 2 == 0);

        Console.WriteLine("Even Numbers:");
        foreach (var num in evenNumbers) {
            Console.WriteLine(num);
        }
    }
}

Exercise 2: Group Employees by Department

Problem: Implement a program to group employees by department using LINQ.

Solution:

using System;
using System.Linq;
using System.Collections.Generic;

class Employee {
    public string Name { get; set; }
    public string Department { get; set; }
}

class Program {
    static void Main(string[] args) {
        List<Employee> employees = new List<Employee> {
            new Employee { Name = "Alice", Department = "HR" },
            new Employee { Name = "Bob", Department = "IT" },
            new Employee { Name = "Charlie", Department = "HR" },
            new Employee { Name = "Dave", Department = "IT" },
            new Employee { Name = "Eve", Department = "Finance" }
        };

        var groupedEmployees = from emp in employees
                               group emp by emp.Department;

        foreach (var group in groupedEmployees) {
            Console.WriteLine($"Department: {group.Key}");
            foreach (var emp in group) {
                Console.WriteLine($"  {emp.Name}");
            }
        }
    }
}

6. Summary

Key Takeaways:

1. Query Syntax vs Method Syntax:
   • Query syntax is SQL-like and readable.
   • Method syntax uses lambda expressions and extension methods.
2. Common LINQ Operations:
   • Filtering: Use Where to filter data.
   • Sorting: Use OrderBy and OrderByDescending.
   • Grouping: Use GroupBy to organize data into groups.
3. Practical Applications:
   • Use LINQ to simplify operations on collections like filtering and grouping.

Module 11: Delegates and Events

Objective: Learn the fundamentals of event-driven programming in C#. Understand how to use delegates, anonymous methods, lambda expressions, and events to create flexible and responsive applications.

1. Delegates

A. What is a Delegate?

• A delegate is a type-safe function pointer that allows methods to be passed as parameters.
• Syntax:

  delegate returnType DelegateName(parameters);
  

Example:

using System;

delegate int Operation(int a, int b);  // Delegate declaration

class Program {
    static int Add(int x, int y) {
        return x + y;
    }

    static void Main(string[] args) {
        Operation op = Add;  // Assign method to delegate
        Console.WriteLine(op(5, 3));  // Output: 8
    }
}

B. Multicast Delegates

• A delegate can point to multiple methods.

Example:

using System;

delegate void Notify();

class Program {
    static void Alert() {
        Console.WriteLine("Alert!");
    }

    static void Warning() {
        Console.WriteLine("Warning!");
    }

    static void Main(string[] args) {
        Notify notify = Alert;
        notify += Warning;  // Adding multiple methods
        notify();  // Output: Alert! Warning!
    }
}

2. Anonymous Methods and Lambda Expressions

A. Anonymous Methods

• Methods defined without a name using the delegate keyword.

Example:

using System;

delegate void Greet(string message);

class Program {
    static void Main(string[] args) {
        Greet greet = delegate (string msg) {
            Console.WriteLine(msg);
        };

        greet("Hello, Anonymous Method!");
    }
}

B. Lambda Expressions

• A concise way to write methods using the => operator.
• Syntax: (parameters) => expression.

Example:

using System;

delegate int Operation(int a, int b);

class Program {
    static void Main(string[] args) {
        Operation multiply = (x, y) => x * y;
        Console.WriteLine(multiply(5, 3));  // Output: 15
    }
}

3. Events

A. What is an Event?

• An event is a special kind of delegate used to notify subscribers when something happens.
• Syntax:

  public event EventHandler EventName;
  

B. Creating and Handling Events

Example:

using System;

class Publisher {
    public event EventHandler OnPublish;

    public void Publish() {
        Console.WriteLine("Publishing event...");
        OnPublish?.Invoke(this, EventArgs.Empty);  // Trigger event
    }
}

class Subscriber {
    public void Subscribe(Publisher publisher) {
        publisher.OnPublish += Respond;
    }

    void Respond(object sender, EventArgs e) {
        Console.WriteLine("Event received by subscriber.");
    }
}

class Program {
    static void Main(string[] args) {
        Publisher publisher = new Publisher();
        Subscriber subscriber = new Subscriber();

        subscriber.Subscribe(publisher);
        publisher.Publish();
    }
}

C. Practical Use of Events

File System Watcher (Monitoring Files in a Folder)

• Use the FileSystemWatcher class to monitor folder changes and trigger events.

Example:

using System;
using System.IO;

class Program {
    static void Main(string[] args) {
        FileSystemWatcher watcher = new FileSystemWatcher();
        watcher.Path = @"C:\TestFolder";  // Specify the folder path
        watcher.Filter = "*.*";  // Monitor all files

        watcher.Created += (sender, e) => {
            Console.WriteLine($"File Created: {e.FullPath}");
        };

        watcher.EnableRaisingEvents = true;

        Console.WriteLine("Monitoring folder. Press Enter to exit.");
        Console.ReadLine();
    }
}

4. Practical Exercises

Exercise 1: Delegate for Arithmetic Operations

Problem: Create a delegate that performs basic arithmetic operations (add, subtract, multiply, divide).

Solution:

using System;

delegate double ArithmeticOperation(double a, double b);

class Program {
    static double Add(double a, double b) => a + b;
    static double Subtract(double a, double b) => a - b;
    static double Multiply(double a, double b) => a * b;
    static double Divide(double a, double b) => a / b;

    static void Main(string[] args) {
        ArithmeticOperation operation;

        operation = Add;
        Console.WriteLine($"Add: {operation(10, 5)}");  // Output: 15

        operation = Subtract;
        Console.WriteLine($"Subtract: {operation(10, 5)}");  // Output: 5

        operation = Multiply;
        Console.WriteLine($"Multiply: {operation(10, 5)}");  // Output: 50

        operation = Divide;
        Console.WriteLine($"Divide: {operation(10, 5)}");  // Output: 2
    }
}

Exercise 2: Event-Driven File Monitoring

Problem: Implement an event-driven program to notify when a file is added to a specific folder.

Solution:

using System;
using System.IO;

class Program {
    static void Main(string[] args) {
        string folderPath = @"C:\TestFolder";

        if (!Directory.Exists(folderPath)) {
            Directory.CreateDirectory(folderPath);
        }

        FileSystemWatcher watcher = new FileSystemWatcher(folderPath);

        watcher.Created += (sender, e) => {
            Console.WriteLine($"New file added: {e.Name}");
        };

        watcher.EnableRaisingEvents = true;

        Console.WriteLine("Monitoring folder for new files. Press Enter to exit.");
        Console.ReadLine();
    }
}

5. Summary

Key Takeaways:

1. Delegates:
   • Delegates are type-safe pointers to methods.
   • Multicast delegates allow assigning multiple methods.
2. Anonymous Methods and Lambda Expressions:
   • Simplify code by writing methods inline.
3. Events:
   • Events notify subscribers about actions.
   • Use FileSystemWatcher for real-time file monitoring.
4. Practical Applications:
   • Delegates and events form the foundation of event-driven programming in C#.

Module 12: Multithreading and Asynchronous Programming

Objective: Learn how to write efficient concurrent and asynchronous programs in C#. Understand threading, Task class, async/await, and how to manage thread safety and synchronization.

1. Threads and the Thread Class

A. What is a Thread?

• A thread is a lightweight unit of execution.
• Multithreading allows multiple threads to run concurrently.

B. Creating and Starting Threads

• Use the Thread class to create and start threads.

Example:

using System;
using System.Threading;

class Program {
    static void PrintNumbers() {
        for (int i = 1; i <= 5; i++) {
            Console.WriteLine($"Thread: {i}");
            Thread.Sleep(500);  // Simulates work
        }
    }

    static void Main(string[] args) {
        Thread thread = new Thread(PrintNumbers);
        thread.Start();

        Console.WriteLine("Main thread continues...");
    }
}

C. Thread Safety

• Use locks to prevent race conditions.

Example:

using System;
using System.Threading;

class Program {
    private static int counter = 0;
    private static readonly object lockObj = new object();

    static void Increment() {
        lock (lockObj) {
            counter++;
            Console.WriteLine($"Counter: {counter}");
        }
    }

    static void Main(string[] args) {
        Thread t1 = new Thread(Increment);
        Thread t2 = new Thread(Increment);

        t1.Start();
        t2.Start();
    }
}

2. Tasks and async/await

A. Tasks

• Use Task for easier and more modern concurrency compared to threads.
• Task.Run schedules a task on a thread pool.

Example:

using System;
using System.Threading.Tasks;

class Program {
    static async Task DoWorkAsync() {
        Console.WriteLine("Task starting...");
        await Task.Delay(2000);  // Simulates asynchronous work
        Console.WriteLine("Task finished.");
    }

    static async Task Main(string[] args) {
        await DoWorkAsync();
        Console.WriteLine("Main method continues...");
    }
}

B. Using async/await

• The async keyword allows asynchronous programming.
• await pauses the execution until the awaited task completes.

Example:

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program {
    static async Task FetchDataAsync() {
        using HttpClient client = new HttpClient();
        string result = await client.GetStringAsync("https://example.com");
        Console.WriteLine(result);
    }

    static async Task Main(string[] args) {
        await FetchDataAsync();
    }
}

3. Synchronization and Thread Safety

A. Locks for Synchronization

• Use lock for thread-safe code when accessing shared resources.

B. Interlocked Class

• Use Interlocked for atomic operations on shared variables.

Example:

using System;
using System.Threading;

class Program {
    private static int counter = 0;

    static void Increment() {
        Interlocked.Increment(ref counter);
        Console.WriteLine($"Counter: {counter}");
    }

    static void Main(string[] args) {
        Thread t1 = new Thread(Increment);
        Thread t2 = new Thread(Increment);

        t1.Start();
        t2.Start();
    }
}

4. Practical Exercises

Exercise 1: Download Multiple Files Simultaneously Using Threads

Problem: Create a program that uses threads to download multiple files simultaneously.

Solution:

using System;
using System.Net;
using System.Threading;

class Program {
    static void DownloadFile(string url, string fileName) {
        using WebClient client = new WebClient();
        client.DownloadFile(url, fileName);
        Console.WriteLine($"{fileName} downloaded.");
    }

    static void Main(string[] args) {
        Thread t1 = new Thread(() => DownloadFile("https://example.com/file1.txt", "file1.txt"));
        Thread t2 = new Thread(() => DownloadFile("https://example.com/file2.txt", "file2.txt"));

        t1.Start();
        t2.Start();
    }
}

Exercise 2: Progress Bar Using async/await

Problem: Implement a program with a progress bar that updates as an asynchronous task progresses.

Solution:

using System;
using System.Threading.Tasks;

class Program {
    static async Task PerformTaskAsync() {
        for (int i = 1; i <= 100; i += 10) {
            Console.Write($"\rProgress: {i}%");
            await Task.Delay(500);  // Simulates work
        }
        Console.WriteLine("\nTask Completed!");
    }

    static async Task Main(string[] args) {
        await PerformTaskAsync();
    }
}

5. Summary

Key Takeaways:

1. Threads:
   • Use the Thread class for basic multithreading but ensure thread safety with locks.
2. Tasks:
   • Use Task and async/await for modern asynchronous programming.
3. Thread Safety:
   • Use lock and Interlocked for thread-safe operations.
4. Practical Applications:
   • Use threads for parallel tasks like file downloads.
   • Use async/await for tasks requiring responsiveness, such as UI updates or network requests.

Module 13: Building a Desktop Application

Objective: Build a simple yet functional desktop application using Windows Forms or WPF. Understand how to design user interfaces, handle events, and implement basic functionality.

1. Introduction to Windows Forms and WPF

A. Windows Forms

• Windows Forms is a graphical user interface (GUI) framework for building desktop applications in C#.
• Provides drag-and-drop tools for rapid development.

B. Windows Presentation Foundation (WPF)

• WPF is a more modern framework for desktop applications, offering advanced graphics and data binding capabilities.

2. Designing a Basic UI

A. Setting Up a Windows Forms Application

1. Open Visual Studio.
2. Create a new project → C# → Windows Forms App.
3. Use the toolbox to drag and drop UI components (e.g., buttons, textboxes).

B. Setting Up a WPF Application

1. Open Visual Studio.
2. Create a new project → C# → WPF App.
3. Edit the MainWindow.xaml to design your interface using XAML.
4. Use the MainWindow.xaml.cs file to handle events and logic.

3. Event Handling in Forms

A. Adding Events in Windows Forms

• Use the Properties window to add event handlers (e.g., Button.Click).

Example:

private void button1_Click(object sender, EventArgs e) {
    MessageBox.Show("Button clicked!");
}

B. Adding Events in WPF

• Use the XAML Click attribute to bind events to methods in the code-behind.

Example:

XAML:

<Button Content="Click Me" Click="Button_Click" />

Code-Behind:

private void Button_Click(object sender, RoutedEventArgs e) {
    MessageBox.Show("Button clicked!");
}

4. Data Binding in WPF

A. What is Data Binding?

• Data binding links UI elements to data sources, allowing real-time updates.

B. One-Way Binding Example

XAML:

<TextBox Text="{Binding Name}" />

Code-Behind:

public string Name { get; set; } = "John Doe";

5. Practical Exercises

Exercise 1: Create a Calculator Application (Windows Forms)

Steps:

1. Drag and drop:
   • TextBox for input.
   • Buttons (+, -, *, /, and =).
2. Add click events to the buttons.

Solution:

using System;
using System.Windows.Forms;

public partial class CalculatorForm : Form {
    private double result = 0;
    private string operation = "";

    public CalculatorForm() {
        InitializeComponent();
    }

    private void button_Click(object sender, EventArgs e) {
        Button button = (Button)sender;
        textBox1.Text += button.Text;
    }

    private void operator_Click(object sender, EventArgs e) {
        Button button = (Button)sender;
        result = double.Parse(textBox1.Text);
        operation = button.Text;
        textBox1.Clear();
    }

    private void equals_Click(object sender, EventArgs e) {
        switch (operation) {
            case "+":
                textBox1.Text = (result + double.Parse(textBox1.Text)).ToString();
                break;
            case "-":
                textBox1.Text = (result - double.Parse(textBox1.Text)).ToString();
                break;
            case "*":
                textBox1.Text = (result * double.Parse(textBox1.Text)).ToString();
                break;
            case "/":
                textBox1.Text = (result / double.Parse(textBox1.Text)).ToString();
                break;
        }
    }
}

Exercise 2: Build a To-Do List Application (WPF)

Steps:

1. Use a TextBox for input and a Button to add tasks.
2. Display tasks in a ListBox.
3. Allow users to delete tasks.

Solution:

XAML:

<StackPanel>
    <TextBox x:Name="TaskInput" Width="200" />
    <Button Content="Add Task" Click="AddTask_Click" />
    <ListBox x:Name="TaskList" Width="200" Height="150" />
</StackPanel>

Code-Behind:

using System.Windows;

public partial class MainWindow : Window {
    public MainWindow() {
        InitializeComponent();
    }

    private void AddTask_Click(object sender, RoutedEventArgs e) {
        if (!string.IsNullOrWhiteSpace(TaskInput.Text)) {
            TaskList.Items.Add(TaskInput.Text);
            TaskInput.Clear();
        }
    }
}

6. Summary

Key Takeaways:

1. Windows Forms:
   • Provides an easy-to-use drag-and-drop interface for building applications.
   • Focus on simplicity and rapid development.
2. WPF:
   • Offers advanced UI capabilities with XAML and data binding.
   • Better for modern applications requiring rich graphics.
3. Event Handling:
   • Use event handlers to manage user interactions.
4. Data Binding:
   • Real-time updates between the UI and data simplify dynamic application development.

Module 14: Working with Databases

Objective: Learn to connect C# applications to databases using ADO.NET and Entity Framework. Understand how to perform CRUD operations and utilize LINQ with EF for database interactions.

1. ADO.NET Basics

A. Connecting to a Database

• ADO.NET is a set of classes for database interaction in .NET.
• Use SqlConnection to establish a connection.

Example:

using System;
using System.Data.SqlClient;

class Program {
    static void Main(string[] args) {
        string connectionString = "Data Source=ServerName;Initial Catalog=DatabaseName;Integrated Security=True";
        using (SqlConnection connection = new SqlConnection(connectionString)) {
            try {
                connection.Open();
                Console.WriteLine("Connection successful!");
            } catch (Exception e) {
                Console.WriteLine($"Error: {e.Message}");
            }
        }
    }
}

B. Performing CRUD Operations

1. Create:

   string query = "INSERT INTO Books (Title, Author) VALUES ('Book Title', 'Author Name')";
   using (SqlCommand command = new SqlCommand(query, connection)) {
       command.ExecuteNonQuery();
   }
   

2. Read:

   string query = "SELECT * FROM Books";
   using (SqlCommand command = new SqlCommand(query, connection)) {
       using (SqlDataReader reader = command.ExecuteReader()) {
           while (reader.Read()) {
               Console.WriteLine($"Title: {reader["Title"]}, Author: {reader["Author"]}");
           }
       }
   }
   

3. Update:

   string query = "UPDATE Books SET Author = 'New Author' WHERE Title = 'Book Title'";
   using (SqlCommand command = new SqlCommand(query, connection)) {
       command.ExecuteNonQuery();
   }
   

4. Delete:

   string query = "DELETE FROM Books WHERE Title = 'Book Title'";
   using (SqlCommand command = new SqlCommand(query, connection)) {
       command.ExecuteNonQuery();
   }
   

2. Introduction to Entity Framework (EF)

A. What is EF?

• EF is an ORM (Object-Relational Mapper) that simplifies database operations by mapping .NET objects to database tables.
• Supports Code-First, Database-First, and Model-First approaches.

B. Code-First Approach

1. Install EF Core:

   Install-Package Microsoft.EntityFrameworkCore
   Install-Package Microsoft.EntityFrameworkCore.SqlServer
   

2. Define a Context and Model:

   using Microsoft.EntityFrameworkCore;
   
   public class Book {
       public int Id { get; set; }
       public string Title { get; set; }
       public string Author { get; set; }
   }
   
   public class LibraryContext : DbContext {
       public DbSet<Book> Books { get; set; }
   
       protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) {
           optionsBuilder.UseSqlServer("Data Source=ServerName;Initial Catalog=LibraryDB;Integrated Security=True");
       }
   }
   

3. Perform Migrations and Update Database:

   Add-Migration InitialCreate
   Update-Database
   

C. LINQ with EF

• Query data using LINQ to interact with EF models.

Example:

using (var context = new LibraryContext()) {
    var books = context.Books.Where(b => b.Author == "Author Name").ToList();
    foreach (var book in books) {
        Console.WriteLine($"{book.Title} by {book.Author}");
    }
}

3. Practical Exercises

Exercise 1: Manage a Library Database (ADO.NET)

Problem: Create a program to manage a library database with ADO.NET.

Solution:

1. Set Up Database:

   CREATE TABLE Books (
       Id INT PRIMARY KEY IDENTITY,
       Title NVARCHAR(100),
       Author NVARCHAR(100)
   );
   

2. C# Code:

   using System;
   using System.Data.SqlClient;
   
   class Program {
       static void Main(string[] args) {
           string connectionString = "Data Source=ServerName;Initial Catalog=LibraryDB;Integrated Security=True";
   
           using (SqlConnection connection = new SqlConnection(connectionString)) {
               connection.Open();
   
               // Add a book
               string insertQuery = "INSERT INTO Books (Title, Author) VALUES ('1984', 'George Orwell')";
               using (SqlCommand command = new SqlCommand(insertQuery, connection)) {
                   command.ExecuteNonQuery();
                   Console.WriteLine("Book added.");
               }
   
               // Read books
               string selectQuery = "SELECT * FROM Books";
               using (SqlCommand command = new SqlCommand(selectQuery, connection)) {
                   using (SqlDataReader reader = command.ExecuteReader()) {
                       while (reader.Read()) {
                           Console.WriteLine($"Id: {reader["Id"]}, Title: {reader["Title"]}, Author: {reader["Author"]}");
                       }
                   }
               }
           }
       }
   }
   

Exercise 2: CRUD Application Using Entity Framework

Problem: Implement a CRUD application using EF to manage books in a library.

Solution:

1. Define Models:

   public class Book {
       public int Id { get; set; }
       public string Title { get; set; }
       public string Author { get; set; }
   }
   
   public class LibraryContext : DbContext {
       public DbSet<Book> Books { get; set; }
   
       protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) {
           optionsBuilder.UseSqlServer("Data Source=ServerName;Initial Catalog=LibraryDB;Integrated Security=True");
       }
   }
   

2. CRUD Operations:

   using (var context = new LibraryContext()) {
       // Create
       var book = new Book { Title = "To Kill a Mockingbird", Author = "Harper Lee" };
       context.Books.Add(book);
       context.SaveChanges();
   
       // Read
       var books = context.Books.ToList();
       foreach (var b in books) {
           Console.WriteLine($"{b.Title} by {b.Author}");
       }
   
       // Update
       var bookToUpdate = context.Books.First();
       bookToUpdate.Author = "Updated Author";
       context.SaveChanges();
   
       // Delete
       var bookToDelete = context.Books.First();
       context.Books.Remove(bookToDelete);
       context.SaveChanges();
   }
   

4. Summary

Key Takeaways:

1. ADO.NET:
   • Provides low-level control over database interactions.
   • Use SqlConnection, SqlCommand, and SqlDataReader for CRUD operations.
2. Entity Framework:
   • Simplifies database operations with an ORM approach.
   • Code-First allows defining database structures using C# classes.
   • Use LINQ for querying data in a strongly typed way.
3. Practical Applications:
   • Use ADO.NET for simple, lightweight applications.
   • Use EF for more complex applications requiring rapid development and abstraction.

Module 15: Building a Web Application

Objective: Build a simple, functional web application using ASP.NET Core. Understand the fundamentals of ASP.NET Core, including setting up a project, handling forms, and working with APIs.

1. Introduction to ASP.NET Core

A. What is ASP.NET Core?

• ASP.NET Core is a cross-platform, open-source framework for building web applications.
• Features:
  • Supports MVC (Model-View-Controller) and Razor Pages.
  • High performance and scalability.
  • Integrated with dependency injection.

2. Setting Up a Project

A. Prerequisites

1. Install the .NET SDK.
2. Install a development environment such as Visual Studio or Visual Studio Code.

B. Creating an ASP.NET Core Project

1. Open your IDE.
2. Create a new project:
   • Select ASP.NET Core Web App for Razor Pages or MVC.
3. Select the framework version and configure the project.

Example Command (CLI):

dotnet new webapp -n WebApplication
cd WebApplication
dotnet run

C. Project Structure

• Controllers: Contains logic for handling HTTP requests.
• Models: Contains data and business logic.
• Views: Contains Razor Pages for rendering the UI.

3. Building and Handling Forms

A. Creating a Form

1. Add a Razor Page or View with a form element.
2. Use the asp-for attribute for model binding.

Example:

Model:

public class Contact {
    public string Name { get; set; }
    public string Email { get; set; }
    public string Message { get; set; }
}

Controller:

using Microsoft.AspNetCore.Mvc;

public class ContactController : Controller {
    [HttpGet]
    public IActionResult Index() {
        return View();
    }

    [HttpPost]
    public IActionResult Index(Contact contact) {
        if (ModelState.IsValid) {
            // Handle the form data
            return RedirectToAction("Success");
        }
        return View(contact);
    }

    public IActionResult Success() {
        return View();
    }
}

View (Razor):

<form method="post" asp-action="Index">
    <label asp-for="Name"></label>
    <input asp-for="Name" />
    
    <label asp-for="Email"></label>
    <input asp-for="Email" type="email" />
    
    <label asp-for="Message"></label>
    <textarea asp-for="Message"></textarea>
    
    <button type="submit">Submit</button>
</form>

B. Validation

• Use Data Annotations for validation.

Example:

public class Contact {
    [Required]
    public string Name { get; set; }

    [EmailAddress]
    public string Email { get; set; }

    [StringLength(500)]
    public string Message { get; set; }
}

4. Consuming and Creating APIs

A. Creating a RESTful API

1. Create a new API controller.

Example:

Model:

public class Task {
    public int Id { get; set; }
    public string Name { get; set; }
    public bool IsComplete { get; set; }
}

Controller:

[ApiController]
[Route("api/[controller]")]
public class TasksController : ControllerBase {
    private static List<Task> tasks = new List<Task>();

    [HttpGet]
    public IEnumerable<Task> Get() {
        return tasks;
    }

    [HttpPost]
    public IActionResult Post(Task task) {
        tasks.Add(task);
        return CreatedAtAction(nameof(Get), new { id = task.Id }, task);
    }

    [HttpDelete("{id}")]
    public IActionResult Delete(int id) {
        var task = tasks.FirstOrDefault(t => t.Id == id);
        if (task == null) return NotFound();
        tasks.Remove(task);
        return NoContent();
    }
}

B. Consuming APIs

• Use HttpClient to call APIs.

Example:

using System.Net.Http;
using System.Threading.Tasks;

public class ApiService {
    private readonly HttpClient _httpClient;

    public ApiService(HttpClient httpClient) {
        _httpClient = httpClient;
    }

    public async Task<IEnumerable<Task>> GetTasksAsync() {
        var response = await _httpClient.GetAsync("https://example.com/api/tasks");
        response.EnsureSuccessStatusCode();
        return await response.Content.ReadAsAsync<IEnumerable<Task>>();
    }
}

5. Practical Exercises

Exercise 1: Build a Simple Blog Application

Steps:

1. Create a model for blog posts.

   public class BlogPost {
       public int Id { get; set; }
       public string Title { get; set; }
       public string Content { get; set; }
       public DateTime CreatedAt { get; set; }
   }
   

2. Implement a controller to handle CRUD operations.
3. Create Razor views for listing, adding, and editing posts.

Controller:

public class BlogController : Controller {
    private static List<BlogPost> posts = new List<BlogPost>();

    public IActionResult Index() {
        return View(posts);
    }

    [HttpPost]
    public IActionResult Create(BlogPost post) {
        post.CreatedAt = DateTime.Now;
        posts.Add(post);
        return RedirectToAction("Index");
    }
}

View:

<form method="post" asp-action="Create">
    <input asp-for="Title" />
    <textarea asp-for="Content"></textarea>
    <button type="submit">Add Post</button>
</form>

@foreach (var post in Model) {
    <h2>@post.Title</h2>
    <p>@post.Content</p>
    <small>@post.CreatedAt</small>
}

Exercise 2: Create a RESTful API for Managing Tasks

Steps:

1. Define a model for tasks.
2. Create an API controller to handle GET, POST, and DELETE operations.
3. Test the API with a tool like Postman.

6. Summary

Key Takeaways:

1. ASP.NET Core:
   • A robust framework for building web applications.
   • Supports both Razor Pages and MVC patterns.
2. Forms:
   • Use Razor Pages for easy form creation and validation.
3. APIs:
   • Build and consume RESTful APIs using ASP.NET Core.
4. Practical Applications:
   • Combine these features to build robust, full-stack web applications.

Module 16: Advanced Topics

Objective: Explore advanced concepts in C#, including reflection, dependency injection, testing frameworks, and performance optimization. Develop skills to write robust, testable, and optimized C# applications.

1. Reflection and Metadata

A. What is Reflection?

• Reflection allows inspecting and manipulating metadata about types at runtime.
• Use cases:
  • Accessing type information dynamically.
  • Creating objects dynamically.
  • Working with attributes.

B. Example: Accessing Type Information

using System;
using System.Reflection;

class Program {
    static void Main(string[] args) {
        Type type = typeof(string);
        Console.WriteLine($"Type: {type.FullName}");
        Console.WriteLine("Methods:");
        foreach (var method in type.GetMethods()) {
            Console.WriteLine($"  {method.Name}");
        }
    }
}

C. Example: Custom Attributes

Step 1: Define an Attribute:

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
public class DeveloperAttribute : Attribute {
    public string Name { get; }
    public string Date { get; }

    public DeveloperAttribute(string name, string date) {
        Name = name;
        Date = date;
    }
}

Step 2: Apply the Attribute:

[Developer("Alice", "2024-01-01")]
public class SampleClass {
    [Developer("Bob", "2024-02-01")]
    public void SampleMethod() { }
}

Step 3: Access Attributes with Reflection:

Type type = typeof(SampleClass);
var attributes = type.GetCustomAttributes(typeof(DeveloperAttribute), false);
foreach (DeveloperAttribute attr in attributes) {
    Console.WriteLine($"Class Developer: {attr.Name}, Date: {attr.Date}");
}

2. Dependency Injection

A. What is Dependency Injection (DI)?

• DI is a design pattern used to inject dependencies into classes, making them more testable and maintainable.
• ASP.NET Core has built-in DI support.

B. Example: Manual Dependency Injection

public interface IMessageService {
    void SendMessage(string message);
}

public class EmailService : IMessageService {
    public void SendMessage(string message) {
        Console.WriteLine($"Email sent: {message}");
    }
}

public class Notification {
    private readonly IMessageService _messageService;

    public Notification(IMessageService messageService) {
        _messageService = messageService;
    }

    public void Notify(string message) {
        _messageService.SendMessage(message);
    }
}

class Program {
    static void Main(string[] args) {
        IMessageService emailService = new EmailService();
        Notification notification = new Notification(emailService);
        notification.Notify("Hello World!");
    }
}

C. Dependency Injection in ASP.NET Core

1. Register services in the Startup.cs or Program.cs:

   services.AddTransient<IMessageService, EmailService>();
   

2. Inject dependencies in controllers:

   public class HomeController {
       private readonly IMessageService _messageService;
   
       public HomeController(IMessageService messageService) {
           _messageService = messageService;
       }
   
       public IActionResult Index() {
           _messageService.SendMessage("Welcome!");
           return View();
       }
   }
   

3. Writing Unit Tests with NUnit or xUnit

A. Setting Up Testing Framework

1. Install the NUnit or xUnit NuGet packages:

   dotnet add package NUnit
   dotnet add package Microsoft.NET.Test.Sdk
   dotnet add package NUnit3TestAdapter
   

2. Create a test project:

   dotnet new nunit -n CalculatorTests
   

B. Writing Tests

Calculator Program:

public class Calculator {
    public int Add(int a, int b) => a + b;
    public int Divide(int a, int b) {
        if (b == 0) throw new DivideByZeroException();
        return a / b;
    }
}

Unit Tests:

using NUnit.Framework;

[TestFixture]
public class CalculatorTests {
    private Calculator _calculator;

    [SetUp]
    public void Setup() {
        _calculator = new Calculator();
    }

    [Test]
    public void Add_ShouldReturnCorrectSum() {
        int result = _calculator.Add(2, 3);
        Assert.AreEqual(5, result);
    }

    [Test]
    public void Divide_ByZero_ShouldThrowException() {
        Assert.Throws<DivideByZeroException>(() => _calculator.Divide(10, 0));
    }
}

4. Performance Optimization

A. Common Techniques

1. Use Async/Await:
   • Avoid blocking threads by using asynchronous operations.
2. Optimize Loops:
   • Minimize repeated calculations inside loops.
3. StringBuilder for String Operations:
   • Use StringBuilder for concatenating large numbers of strings.

B. Example: Using StringBuilder

using System.Text;

class Program {
    static void Main() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 1000; i++) {
            sb.Append(i);
        }
        Console.WriteLine(sb.ToString());
    }
}

5. Practical Exercises

Exercise 1: Create a Custom Attribute and Access It Using Reflection

Problem: Define an attribute for methods that logs their purpose and retrieve it using reflection.

Exercise 2: Write Unit Tests for a Calculator Program

Problem: Write unit tests for addition, subtraction, and division operations in a calculator program. Include edge cases like dividing by zero.

6. Summary

Key Takeaways:

1. Reflection:
   • Allows dynamic inspection and manipulation of types.
2. Dependency Injection:
   • Promotes loose coupling and makes code easier to test.
3. Unit Testing:
   • Essential for maintaining application quality.
   • NUnit and xUnit are powerful testing frameworks.
4. Performance Optimization:
   • Focus on efficient data handling and asynchronous programming.