C# Programming Tutorial: From Fundamentals to Advanced Application Development

📘 Chapter 5: Advanced Topics in C#

🧠 Introduction

Now that you’ve learned the basics of C# syntax and object-oriented programming, it's time to explore advanced features that take your programming skills to the next level. These features enable you to write cleaner, more powerful, scalable, and high-performance C# applications.

In this chapter, you’ll learn:

• Delegates and Events
• LINQ (Language Integrated Query)
• Anonymous Methods and Lambda Expressions
• Generics
• Asynchronous Programming with async/await
• Nullable Reference Types and Pattern Matching

⚡ 1. Delegates in C#

🔹 What is a Delegate?

A delegate is a type that represents references to methods with a particular parameter list and return type. Think of it as a function pointer or a type-safe callback mechanism.

✅ Basic Delegate Example:

public delegate int Operation(int x, int y);

class Calculator

{

    public static int Add(int a, int b) => a + b;

}

class Program

{

    static void Main()

    {

        Operation op = new Operation(Calculator.Add);

        Console.WriteLine(op(5, 3)); // Output: 8

    }

}

📋 Delegate Syntax Summary

📣 2. Events in C#

🔹 What is an Event?

An event in C# is a way for a class to provide notifications to clients when something happens. It is based on delegates.

✅ Event Example:

public class Button

{

    public event Action Clicked;

    public void Click()

    {

        Clicked?.Invoke();

    }

}

class Program

{

    static void Main()

    {

        var button = new Button();

        button.Clicked += () => Console.WriteLine("Button clicked!");

        button.Click();  // Output: Button clicked!

    }

}

📋 Event vs Delegate

🔍 3. Lambda Expressions & Anonymous Methods

🔹 Lambda Expressions

A concise way to write inline methods or delegates.

Func<int, int, int> multiply = (x, y) => x * y;

Console.WriteLine(multiply(4, 5));  // Output: 20

🔹 Anonymous Methods

Action greet = delegate { Console.WriteLine("Hello!"); };

greet();  // Output: Hello!

📋 Table: Lambda vs Anonymous Methods

📊 4. Generics

🔹 What are Generics?

Generics allow you to define classes, methods, interfaces, and delegates with placeholders for the data type. They provide type safety and code reusability.

✅ Generic List Example

List<string> names = new List<string>();

names.Add("Alice");

✅ Generic Method

public T Max<T>(T a, T b) where T : IComparable<T>

{

    return a.CompareTo(b) > 0 ? a : b;

}

✅ Generic Class

public class Box<T>

{

    public T Value { get; set; }

}

📋 Table: Built-in Generic Types

📈 5. LINQ (Language Integrated Query)

LINQ allows querying objects, databases, XML, and collections using SQL-like syntax within C#.

✅ LINQ Query Syntax

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

var even = from n in numbers

           where n % 2 == 0

           select n;

foreach (var num in even)

    Console.WriteLine(num);  // Output: 2, 4

✅ LINQ Method Syntax

var even = numbers.Where(n => n % 2 == 0).ToList();

📋 Common LINQ Methods

⚙️ 6. Asynchronous Programming

🔹 What is async/await?

Asynchronous programming allows execution of tasks without blocking the main thread.

✅ Async Example

async Task DownloadAsync()

{

    await Task.Delay(1000);

    Console.WriteLine("Download complete.");

}

csharp

CopyEdit

await DownloadAsync();

📋 Table: Async Keywords

✅ Example: HTTP Call with HttpClient

using System.Net.Http;

async Task GetData()

{

    HttpClient client = new HttpClient();

    string data = await client.GetStringAsync("https://api.example.com");

    Console.WriteLine(data);

}

❓ 7. Pattern Matching

Pattern Matching improves conditional expressions by matching data structures or types directly.

✅ is Pattern

object obj = "hello";

if (obj is string s)

{

    Console.WriteLine(s.ToUpper());  // Output: HELLO

}

✅ switch Expression

string fruit = "apple";

string result = fruit switch

{

    "apple" => "Red",

    "banana" => "Yellow",

    _ => "Unknown"

};

✅ Summary Table