What is the difference between `Task` and `Thread`?

Thread is a lower-level construct that represents an actual OS thread. It's part of the threading infrastructure.

Task is a higher-level abstraction that represents an asynchronous operation. It doesn't necessarily map to a single thread.

Example:

// Using Thread (lower-level, more control, more overhead)
public class ThreadExample
{
    public void RunWithThread()
    {
        Thread thread = new Thread(() =>
        {
            Console.WriteLine($"Thread ID: {Thread.CurrentThread.ManagedThreadId}");
            Thread.Sleep(2000);
            Console.WriteLine("Thread work completed");
        });
        
        thread.Start();
        thread.Join(); // Wait for thread to complete
    }
    
    // Creating multiple threads
    public void RunMultipleThreads()
    {
        for (int i = 0; i < 5; i++)
        {
            int taskNumber = i;
            Thread thread = new Thread(() =>
            {
                Console.WriteLine($"Thread {taskNumber} executing");
                Thread.Sleep(1000);
            });
            thread.Start();
        }
    }
}

// Using Task (higher-level, better performance, easier to use)
public class TaskExample
{
    public async Task RunWithTaskAsync()
    {
        await Task.Run(() =>
        {
            Console.WriteLine($"Task on Thread ID: {Thread.CurrentThread.ManagedThreadId}");
            Thread.Sleep(2000);
            Console.WriteLine("Task work completed");
        });
    }
    
    // Creating multiple tasks
    public async Task RunMultipleTasksAsync()
    {
        var tasks = new List();
        
        for (int i = 0; i < 5; i++)
        {
            int taskNumber = i;
            tasks.Add(Task.Run(() =>
            {
                Console.WriteLine($"Task {taskNumber} executing on Thread {Thread.CurrentThread.ManagedThreadId}");
                Thread.Sleep(1000);
            }));
        }
        
        await Task.WhenAll(tasks); // Wait for all tasks to complete
    }
    
    // Task with return value
    public async Task CalculateAsync()
    {
        return await Task.Run(() =>
        {
            Thread.Sleep(1000);
            return 42;
        });
    }
}

// Comparison example
public class ComparisonDemo
{
    public void CompareThreadAndTask()
    {
        // Thread approach - manual management
        var threads = new List();
        for (int i = 0; i < 10; i++)
        {
            var thread = new Thread(() => DoWork());
            threads.Add(thread);
            thread.Start();
        }
        
        foreach (var thread in threads)
        {
            thread.Join(); // Wait for completion
        }
        
        // Task approach - automatic management
        var tasks = new List();
        for (int i = 0; i < 10; i++)
        {
            tasks.Add(Task.Run(() => DoWork()));
        }
        
        Task.WaitAll(tasks.ToArray()); // Wait for completion
    }
    
    private void DoWork()
    {
        Thread.Sleep(500);
    }
}

// Task with proper async/await pattern
public class AsyncPatternExample
{
    public async Task FetchDataAsync()
    {
        // This doesn't block the calling thread
        await Task.Delay(1000);
        return "Data fetched";
    }
    
    public async Task ProcessDataAsync()
    {
        Console.WriteLine("Start processing");
        
        // Multiple async operations
        var task1 = FetchDataAsync();
        var task2 = FetchDataAsync();
        var task3 = FetchDataAsync();
        
        // Wait for all to complete
        string[] results = await Task.WhenAll(task1, task2, task3);
        
        Console.WriteLine($"Processed {results.Length} items");
    }
}

Key Differences: