Delegates, Events & Async

// 1. Declare a delegate (a blueprint for methods)
public delegate int Operation(int a, int b);

// 2. Create methods that match the blueprint
public int Add(int a, int b) => a + b;
public int Multiply(int a, int b) => a * b;

// 3. Use the delegate to point to different methods
Operation op = Add;
int result = op(5, 3);   // result = 8

op = Multiply;
result = op(5, 3);       // result = 15

// Basic structure of an async method
public async Task<string> FetchDataAsync()
{
    // Simulate a 2-second network call
    await Task.Delay(2000);
    return "Data loaded!";
}

// Calling it:
public async Task ProcessAsync()
{
    string result = await FetchDataAsync();
    Console.WriteLine(result);
}

// Visual representation of what happens:
// The compiler transforms your code into something like this:

public Task<string> FetchDataAsync()
{
    var stateMachine = new StateMachine();
    stateMachine.MoveNext();
    return stateMachine.Task;
}

private class StateMachine
{
    private int state = 0;
    private TaskAwaiter awaiter;
    public TaskCompletionSource<string> tcs = new TaskCompletionSource<string>();
    
    public Task<string> Task => tcs.Task;
    
    public void MoveNext()
    {
        switch(state)
        {
            case 0:
                awaiter = Task.Delay(2000).GetAwaiter();
                if (!awaiter.IsCompleted)
                {
                    state = 1;
                    awaiter.OnCompleted(MoveNext);
                    return;
                }
                goto case 1;
            case 1:
                awaiter.GetResult();
                tcs.SetResult("Data loaded!");
                break;
        }
    }
}

using HttpClient client = new HttpClient();

public async Task<string> GetWebContentAsync(string url)
{
    try
    {
        // This starts the network request and immediately returns control
        HttpResponseMessage response = await client.GetAsync(url);
        
        // Check if the request succeeded
        response.EnsureSuccessStatusCode();
        
        // Read the response body asynchronously
        string content = await response.Content.ReadAsStringAsync();
        
        return content;
    }
    catch (HttpRequestException ex)
    {
        return $"Error: {ex.Message}";
    }
    catch (TaskCanceledException)
    {
        return "Request timed out!";
    }
}

// Scenario: Fetch data from three different APIs
public async Task ProcessAllAsync()
{
    // Start ALL tasks at the same time (they run in parallel)
    Task<string> task1 = FetchUserDataAsync();
    Task<string> task2 = FetchProductDataAsync();
    Task<string> task3 = FetchOrderDataAsync();

    // Wait for ALL to complete
    string[] results = await Task.WhenAll(task1, task2, task3);
    
    // All data is ready to use
    Console.WriteLine($"User: {results[0]}");
    Console.WriteLine($"Products: {results[1]}");
    Console.WriteLine($"Orders: {results[2]}");
}

// Alternative: Process tasks one by one (slower)
public async Task ProcessSequentialAsync()
{
    string user = await FetchUserDataAsync();      // Wait 3 seconds
    string products = await FetchProductDataAsync(); // Wait 2 more seconds
    string orders = await FetchOrderDataAsync();   // Wait 1 more second
    // Total: 6 seconds
}

// Parallel version: All start at the same time
// Total: Only 3 seconds (the longest one)!

// Using CancellationToken to cancel long-running operations
public async Task<string> FetchWithTimeoutAsync(
    string url, 
    CancellationToken cancellationToken = default)
{
    using (CancellationTokenSource cts = CancellationTokenSource.CreateLinkedTokenSource(
        cancellationToken,
        new CancellationTokenSource(TimeSpan.FromSeconds(5)).Token))
    {
        try
        {
            HttpResponseMessage response = await client.GetAsync(url, cts.Token);
            response.EnsureSuccessStatusCode();
            return await response.Content.ReadAsStringAsync();
        }
        catch (OperationCanceledException)
        {
            return "Request was cancelled or timed out!";
        }
    }
}

// Usage with cancellation
public async Task ExampleUsageAsync()
{
    // Create a cancellation token that cancels after 3 seconds
    using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(3));
    
    string result = await FetchWithTimeoutAsync("https://api.example.com/data", cts.Token);
    Console.WriteLine(result);
}