using System;
using System.Threading;
public class ThreadLifecycleExample
{
    // 線程工作方法
    private static void WorkerMethod(object state)
    {
        string threadName = (string)state;
        Console.WriteLine($"[{threadName}] 線程開始執(zhí)行，線程ID: {Thread.CurrentThread.ManagedThreadId}");
        for (int i = 0; i < 5; i++)
        {
            Console.WriteLine($"[{threadName}] 工作中... {i}");
            Thread.Sleep(1000);
        }
        Console.WriteLine($"[{threadName}] 線程執(zhí)行完成");
    }
    public static void BasicThreadExample()
    {
        // 創(chuàng)建線程的幾種方式
        // 方式1：使用ThreadStart委托
        Thread thread1 = new Thread(new ThreadStart(() => WorkerMethod("Thread1")));
        // 方式2：使用ParameterizedThreadStart委托
        Thread thread2 = new Thread(new ParameterizedThreadStart(WorkerMethod));
        // 方式3：直接傳遞方法
        Thread thread3 = new Thread(() => WorkerMethod("Thread3"));
        // 設置線程屬性
        thread1.Name = "Worker-1";
        thread1.IsBackground = false; // 前臺線程
        thread2.Name = "Worker-2";
        thread2.IsBackground = true;  // 后臺線程
        // 啟動線程
        thread1.Start();
        thread2.Start("Thread2");
        thread3.Start();
        // 等待線程完成
        thread1.Join();
        thread2.Join();
        thread3.Join();
    }
}

using System;
using System.Threading;
public class ThreadControlExample
{
    private static ManualResetEvent pauseEvent = new ManualResetEvent(true);
    private static ManualResetEvent shutdownEvent = new ManualResetEvent(false);
    private static CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
    // 可控制的工作線程
    private static void ControllableWorker(object state)
    {
        string workerName = (string)state;
        CancellationToken token = cancellationTokenSource.Token;
        Console.WriteLine($"[{workerName}] 線程啟動");
        try
        {
            while (!token.IsCancellationRequested)
            {
                // 等待暫停信號
                pauseEvent.WaitOne();
                // 檢查是否需要退出
                if (token.IsCancellationRequested)
                    break;
                // 執(zhí)行工作
                Console.WriteLine($"[{workerName}] 正在工作... 時間: {DateTime.Now:HH:mm:ss}");
                // 模擬工作負載
                Thread.Sleep(1000);
                // 檢查停止信號
                if (WaitHandle.WaitAny(new WaitHandle[] { shutdownEvent }, 0) == 0)
                {
                    Console.WriteLine($"[{workerName}] 收到停止信號");
                    break;
                }
            }
        }
        catch (OperationCanceledException)
        {
            Console.WriteLine($"[{workerName}] 操作被取消");
        }
        finally
        {
            Console.WriteLine($"[{workerName}] 線程退出");
        }
    }
    public static void ThreadControlDemo()
    {
        Thread workerThread = new Thread(ControllableWorker)
        {
            Name = "ControlledWorker",
            IsBackground = false
        };
        // 啟動線程
        workerThread.Start("Worker");
        // 讓線程運行3秒
        Thread.Sleep(3000);
        // 暫停線程
        Console.WriteLine("\n[主線程] 暫停工作線程...");
        pauseEvent.Reset();
        Thread.Sleep(2000);
        // 繼續(xù)線程
        Console.WriteLine("[主線程] 恢復工作線程...");
        pauseEvent.Set();
        Thread.Sleep(3000);
        // 停止線程（推薦方式：使用CancellationToken）
        Console.WriteLine("\n[主線程] 停止工作線程...");
        cancellationTokenSource.Cancel();
        // 等待線程結束
        workerThread.Join(5000);
        if (workerThread.IsAlive)
        {
            Console.WriteLine("[主線程] 強制終止線程");
            workerThread.Abort(); // 注意：不推薦使用，僅作為最后手段
        }
    }
}

using System;
using System.Threading;
using System.Collections.Concurrent;
public class SharedMemoryCommunication
{
    // 共享數(shù)據(jù)結構
    private static readonly ConcurrentQueue<string> messageQueue = new ConcurrentQueue<string>();
    private static readonly object lockObject = new object();
    private static int sharedCounter = 0;
    // 生產者線程
    private static void Producer(object state)
    {
        string producerName = (string)state;
        Random random = new Random();
        for (int i = 0; i < 10; i++)
        {
            string message = $"{producerName}-Message-{i}";
            messageQueue.Enqueue(message);
            // 使用lock保護共享變量
            lock (lockObject)
            {
                sharedCounter++;
                Console.WriteLine($"[生產者 {producerName}] 發(fā)送: {message}, 總計數(shù): {sharedCounter}");
            }
            Thread.Sleep(random.Next(100, 500));
        }
    }
    // 消費者線程
    private static void Consumer(object state)
    {
        string consumerName = (string)state;
        while (true)
        {
            if (messageQueue.TryDequeue(out string message))
            {
                Console.WriteLine($"[消費者 {consumerName}] 接收: {message}");
                Thread.Sleep(200);
            }
            else
            {
                // 隊列為空時等待
                Thread.Sleep(100);
                // 檢查是否所有生產者都完成了
                lock (lockObject)
                {
                    if (sharedCounter >= 20 && messageQueue.IsEmpty)
                        break;
                }
            }
        }
        Console.WriteLine($"[消費者 {consumerName}] 退出");
    }
    public static void RunSharedMemoryExample()
    {
        Thread producer1 = new Thread(Producer) { Name = "Producer1" };
        Thread producer2 = new Thread(Producer) { Name = "Producer2" };
        Thread consumer1 = new Thread(Consumer) { Name = "Consumer1" };
        Thread consumer2 = new Thread(Consumer) { Name = "Consumer2" };
        producer1.Start("P1");
        producer2.Start("P2");
        consumer1.Start("C1");
        consumer2.Start("C2");
        producer1.Join();
        producer2.Join();
        consumer1.Join();
        consumer2.Join();
    }
}

using System;
using System.Threading;
public class EventCommunication
{
    // 自動重置事件
    private static AutoResetEvent autoEvent = new AutoResetEvent(false);
    // 手動重置事件
    private static ManualResetEvent manualEvent = new ManualResetEvent(false);
    // 倒計時事件
    private static CountdownEvent countdownEvent = new CountdownEvent(3);
    // 等待事件的工作線程
    private static void WaitingWorker(object state)
    {
        string workerName = (string)state;
        Console.WriteLine($"[{workerName}] 等待事件信號...");
        // 等待自動重置事件
        autoEvent.WaitOne();
        Console.WriteLine($"[{workerName}] 收到自動重置事件信號");
        // 等待手動重置事件
        manualEvent.WaitOne();
        Console.WriteLine($"[{workerName}] 收到手動重置事件信號");
        // 通知倒計時事件
        countdownEvent.Signal();
        Console.WriteLine($"[{workerName}] 完成工作");
    }
    public static void RunEventExample()
    {
        Thread[] workers = new Thread[3];
        for (int i = 0; i < 3; i++)
        {
            workers[i] = new Thread(WaitingWorker);
            workers[i].Start($"Worker{i + 1}");
        }
        Thread.Sleep(1000);
        // 觸發(fā)自動重置事件（只有一個線程會收到信號）
        Console.WriteLine("\n[主線程] 觸發(fā)自動重置事件");
        autoEvent.Set();
        Thread.Sleep(500);
        autoEvent.Set();
        Thread.Sleep(500);
        autoEvent.Set();
        Thread.Sleep(1000);
        // 觸發(fā)手動重置事件（所有等待的線程都會收到信號）
        Console.WriteLine("\n[主線程] 觸發(fā)手動重置事件");
        manualEvent.Set();
        // 等待所有線程完成
        countdownEvent.Wait();
        Console.WriteLine("\n[主線程] 所有工作線程已完成");
    }
}

using System;
using System.Threading;
public class SemaphoreCommunication
{
    // 信號量：最多允許3個線程同時訪問
    private static Semaphore semaphore = new Semaphore(3, 3);
    // 互斥量
    private static Mutex mutex = new Mutex();
    // 使用信號量控制的工作方法
    private static void SemaphoreWorker(object state)
    {
        string workerName = (string)state;
        Console.WriteLine($"[{workerName}] 等待進入臨界區(qū)...");
        semaphore.WaitOne();
        try
        {
            Console.WriteLine($"[{workerName}] 進入臨界區(qū)，開始工作");
            Thread.Sleep(2000); // 模擬工作
            Console.WriteLine($"[{workerName}] 完成工作");
        }
        finally
        {
            Console.WriteLine($"[{workerName}] 離開臨界區(qū)");
            semaphore.Release();
        }
    }
    // 使用互斥量的工作方法
    private static void MutexWorker(object state)
    {
        string workerName = (string)state;
        Console.WriteLine($"[{workerName}] 嘗試獲取互斥量...");
        mutex.WaitOne();
        try
        {
            Console.WriteLine($"[{workerName}] 獲得互斥量，獨占訪問資源");
            Thread.Sleep(1000);
            Console.WriteLine($"[{workerName}] 完成獨占訪問");
        }
        finally
        {
            mutex.ReleaseMutex();
            Console.WriteLine($"[{workerName}] 釋放互斥量");
        }
    }
    public static void RunSemaphoreExample()
    {
        Console.WriteLine("=== 信號量示例 ===");
        Thread[] semaphoreThreads = new Thread[6];
        for (int i = 0; i < 6; i++)
        {
            semaphoreThreads[i] = new Thread(SemaphoreWorker);
            semaphoreThreads[i].Start($"SemWorker{i + 1}");
        }
        foreach (var thread in semaphoreThreads)
            thread.Join();
        Console.WriteLine("\n=== 互斥量示例 ===");
        Thread[] mutexThreads = new Thread[3];
        for (int i = 0; i < 3; i++)
        {
            mutexThreads[i] = new Thread(MutexWorker);
            mutexThreads[i].Start($"MutexWorker{i + 1}");
        }
        foreach (var thread in mutexThreads)
            thread.Join();
    }
}

using System;
using System.Threading;
public class ThreadSynchronization
{
    private static readonly object lockObject = new object();
    private static int balance = 1000;
    // 使用lock語句
    private static void TransferWithLock(int amount, string from, string to)
    {
        lock (lockObject)
        {
            Console.WriteLine($"[{Thread.CurrentThread.Name}] 轉賬開始: {from} -> {to}, 金額: {amount}");
            if (balance >= amount)
            {
                balance -= amount;
                Thread.Sleep(100); // 模擬處理時間
                Console.WriteLine($"[{Thread.CurrentThread.Name}] 轉賬成功，余額: {balance}");
            }
            else
            {
                Console.WriteLine($"[{Thread.CurrentThread.Name}] 余額不足，轉賬失敗");
            }
        }
    }
    // 使用Monitor類（更靈活的控制）
    private static void TransferWithMonitor(int amount, string from, string to)
    {
        bool lockTaken = false;
        try
        {
            Monitor.TryEnter(lockObject, TimeSpan.FromSeconds(1), ref lockTaken);
            if (lockTaken)
            {
                Console.WriteLine($"[{Thread.CurrentThread.Name}] 獲得鎖，執(zhí)行轉賬");
                if (balance >= amount)
                {
                    balance -= amount;
                    Thread.Sleep(100);
                    Console.WriteLine($"[{Thread.CurrentThread.Name}] 轉賬成功，余額: {balance}");
                    // 通知等待的線程
                    Monitor.Pulse(lockObject);
                }
                else
                {
                    Console.WriteLine($"[{Thread.CurrentThread.Name}] 余額不足，等待...");
                    Monitor.Wait(lockObject, 1000); // 等待最多1秒
                }
            }
            else
            {
                Console.WriteLine($"[{Thread.CurrentThread.Name}] 無法獲得鎖");
            }
        }
        finally
        {
            if (lockTaken)
            {
                Monitor.Exit(lockObject);
            }
        }
    }
    public static void RunSynchronizationExample()
    {
        Thread[] threads = new Thread[5];
        for (int i = 0; i < 5; i++)
        {
            int amount = (i + 1) * 100;
            threads[i] = new Thread(() => TransferWithLock(amount, "AccountA", "AccountB"))
            {
                Name = $"Transfer-Thread-{i + 1}"
            };
        }
        foreach (var thread in threads)
            thread.Start();
        foreach (var thread in threads)
            thread.Join();
        Console.WriteLine($"\n最終余額: {balance}");
    }
}

using System;
using System.Threading;
using System.Collections.Generic;
public class ReaderWriterExample
{
    private static ReaderWriterLockSlim rwLock = new ReaderWriterLockSlim();
    private static Dictionary<string, int> cache = new Dictionary<string, int>();
    private static Random random = new Random();
    // 讀操作
    private static void ReadData(object state)
    {
        string readerName = (string)state;
        for (int i = 0; i < 5; i++)
        {
            rwLock.EnterReadLock();
            try
            {
                Console.WriteLine($"[{readerName}] 讀取數(shù)據(jù)開始");
                foreach (var item in cache)
                {
                    Console.WriteLine($"[{readerName}] 讀取: {item.Key} = {item.Value}");
                }
                Thread.Sleep(100);
            }
            finally
            {
                Console.WriteLine($"[{readerName}] 讀取完成");
                rwLock.ExitReadLock();
            }
            Thread.Sleep(random.Next(100, 300));
        }
    }
    // 寫操作
    private static void WriteData(object state)
    {
        string writerName = (string)state;
        for (int i = 0; i < 3; i++)
        {
            rwLock.EnterWriteLock();
            try
            {
                string key = $"Data-{random.Next(100)}";
                int value = random.Next(1000);
                Console.WriteLine($"[{writerName}] 寫入數(shù)據(jù): {key} = {value}");
                cache[key] = value;
                Thread.Sleep(200);
            }
            finally
            {
                Console.WriteLine($"[{writerName}] 寫入完成");
                rwLock.ExitWriteLock();
            }
            Thread.Sleep(random.Next(200, 500));
        }
    }
    // 可升級讀鎖示例
    private static void UpgradeableReadExample()
    {
        rwLock.EnterUpgradeableReadLock();
        try
        {
            Console.WriteLine("[UpgradeableReader] 進入可升級讀鎖");
            // 先讀取
            foreach (var item in cache)
            {
                Console.WriteLine($"[UpgradeableReader] 讀取: {item.Key} = {item.Value}");
            }
            // 根據(jù)條件升級為寫鎖
            if (cache.Count < 5)
            {
                rwLock.EnterWriteLock();
                try
                {
                    Console.WriteLine("[UpgradeableReader] 升級為寫鎖");
                    cache[$"Upgraded-{DateTime.Now.Ticks}"] = random.Next(1000);
                }
                finally
                {
                    rwLock.ExitWriteLock();
                }
            }
        }
        finally
        {
            rwLock.ExitUpgradeableReadLock();
        }
    }
    public static void RunReaderWriterExample()
    {
        // 初始化一些數(shù)據(jù)
        cache["Initial1"] = 100;
        cache["Initial2"] = 200;
        Thread reader1 = new Thread(ReadData) { Name = "Reader1" };
        Thread reader2 = new Thread(ReadData) { Name = "Reader2" };
        Thread writer1 = new Thread(WriteData) { Name = "Writer1" };
        Thread writer2 = new Thread(WriteData) { Name = "Writer2" };
        Thread upgrader = new Thread(UpgradeableReadExample) { Name = "Upgrader" };
        reader1.Start("Reader1");
        reader2.Start("Reader2");
        writer1.Start("Writer1");
        writer2.Start("Writer2");
        Thread.Sleep(500);
        upgrader.Start();
        reader1.Join();
        reader2.Join();
        writer1.Join();
        writer2.Join();
        upgrader.Join();
        Console.WriteLine("\n最終緩存內容:");
        foreach (var item in cache)
        {
            Console.WriteLine($"{item.Key} = {item.Value}");
        }
    }
}

using System;
using System.Threading;
using System.Collections.Concurrent;
using System.Threading.Tasks;
public class ThreadSafeCollections
{
    // 線程安全的集合
    private static ConcurrentDictionary<string, int> concurrentDict = new ConcurrentDictionary<string, int>();
    private static ConcurrentQueue<string> concurrentQueue = new ConcurrentQueue<string>();
    private static ConcurrentStack<int> concurrentStack = new ConcurrentStack<int>();
    private static ConcurrentBag<string> concurrentBag = new ConcurrentBag<string>();
    private static BlockingCollection<string> blockingCollection = new BlockingCollection<string>(10);
    // 使用BlockingCollection的生產者-消費者模式
    private static void BlockingProducer()
    {
        for (int i = 0; i < 20; i++)
        {
            string item = $"Item-{i}";
            if (blockingCollection.TryAdd(item, TimeSpan.FromSeconds(1)))
            {
                Console.WriteLine($"[生產者] 添加: {item}");
            }
            else
            {
                Console.WriteLine($"[生產者] 添加失?。ǔ瑫r）: {item}");
            }
            Thread.Sleep(100);
        }
        blockingCollection.CompleteAdding();
        Console.WriteLine("[生產者] 完成添加");
    }
    private static void BlockingConsumer(object state)
    {
        string consumerName = (string)state;
        try
        {
            foreach (var item in blockingCollection.GetConsumingEnumerable())
            {
                Console.WriteLine($"[{consumerName}] 消費: {item}");
                Thread.Sleep(200);
            }
        }
        catch (InvalidOperationException)
        {
            Console.WriteLine($"[{consumerName}] 集合已完成");
        }
        Console.WriteLine($"[{consumerName}] 退出");
    }
    // 并發(fā)字典操作示例
    private static void ConcurrentDictionaryExample()
    {
        // 添加或更新
        concurrentDict.AddOrUpdate("key1", 1, (key, oldValue) => oldValue + 1);
        // 獲取或添加
        int value = concurrentDict.GetOrAdd("key2", 2);
        // 嘗試獲取
        if (concurrentDict.TryGetValue("key1", out int result))
        {
            Console.WriteLine($"獲取值: key1 = {result}");
        }
        // 嘗試移除
        if (concurrentDict.TryRemove("key1", out int removed))
        {
            Console.WriteLine($"移除值: key1 = {removed}");
        }
    }
    public static void RunThreadSafeCollectionExample()
    {
        Console.WriteLine("=== BlockingCollection 示例 ===");
        Thread producer = new Thread(BlockingProducer);
        Thread consumer1 = new Thread(BlockingConsumer);
        Thread consumer2 = new Thread(BlockingConsumer);
        producer.Start();
        consumer1.Start("Consumer1");
        consumer2.Start("Consumer2");
        producer.Join();
        consumer1.Join();
        consumer2.Join();
        Console.WriteLine("\n=== ConcurrentDictionary 示例 ===");
        ConcurrentDictionaryExample();
    }
}

using System;
using System.Threading;
using System.Threading.Tasks;
public class AdvancedSynchronization
{
    // Barrier：同步多個線程的執(zhí)行階段
    private static Barrier barrier = new Barrier(3, (b) =>
    {
        Console.WriteLine($"\n[Barrier] 階段 {b.CurrentPhaseNumber} 完成，所有線程已同步\n");
    });
    // SpinLock：自旋鎖（適用于短時間的鎖定）
    private static SpinLock spinLock = new SpinLock();
    private static int spinLockCounter = 0;
    // 使用Barrier的多階段任務
    private static void BarrierTask(object state)
    {
        string taskName = (string)state;
        for (int phase = 0; phase < 3; phase++)
        {
            Console.WriteLine($"[{taskName}] 階段 {phase} 開始工作");
            Thread.Sleep(new Random().Next(1000, 3000));
            Console.WriteLine($"[{taskName}] 階段 {phase} 工作完成，等待其他線程...");
            // 等待所有線程完成當前階段
            barrier.SignalAndWait();
        }
        Console.WriteLine($"[{taskName}] 所有階段完成");
    }
    // 使用SpinLock的快速操作
    private static void SpinLockTask(object state)
    {
        string taskName = (string)state;
        bool lockTaken = false;
        for (int i = 0; i < 1000; i++)
        {
            try
            {
                spinLock.Enter(ref lockTaken);
                // 快速的臨界區(qū)操作
                spinLockCounter++;
                if (i % 100 == 0)
                {
                    Console.WriteLine($"[{taskName}] 計數(shù)器: {spinLockCounter}");
                }
            }
            finally
            {
                if (lockTaken)
                {
                    spinLock.Exit();
                    lockTaken = false;
                }
            }
            // 模擬其他工作
            if (i % 10 == 0)
                Thread.Yield();
        }
    }
    public static void RunAdvancedSynchronizationExample()
    {
        Console.WriteLine("=== Barrier 示例 ===");
        Thread[] barrierThreads = new Thread[3];
        for (int i = 0; i < 3; i++)
        {
            barrierThreads[i] = new Thread(BarrierTask);
            barrierThreads[i].Start($"Task{i + 1}");
        }
        foreach (var thread in barrierThreads)
            thread.Join();
        Console.WriteLine("\n=== SpinLock 示例 ===");
        Thread[] spinThreads = new Thread[4];
        for (int i = 0; i < 4; i++)
        {
            spinThreads[i] = new Thread(SpinLockTask);
            spinThreads[i].Start($"SpinTask{i + 1}");
        }
        foreach (var thread in spinThreads)
            thread.Join();
        Console.WriteLine($"\n最終計數(shù)器值: {spinLockCounter}");
    }
}

using System;
using System.Threading;
public class Program
{
    public static void Main(string[] args)
    {
        while (true)
        {
            Console.Clear();
            Console.WriteLine("===== .NET Framework 4.8 多線程編程示例 =====");
            Console.WriteLine("1. 基礎線程操作");
            Console.WriteLine("2. 線程控制（暫停/繼續(xù)/停止）");
            Console.WriteLine("3. 共享內存通信");
            Console.WriteLine("4. 事件通信機制");
            Console.WriteLine("5. 信號量和互斥量");
            Console.WriteLine("6. 線程同步（Lock/Monitor）");
            Console.WriteLine("7. 讀寫鎖示例");
            Console.WriteLine("8. 線程安全集合");
            Console.WriteLine("9. 高級同步（Barrier/SpinLock）");
            Console.WriteLine("0. 退出");
            Console.Write("\n請選擇示例 (0-9): ");
            string choice = Console.ReadLine();
            Console.Clear();
            switch (choice)
            {
                case "1":
                    ThreadLifecycleExample.BasicThreadExample();
                    break;
                case "2":
                    ThreadControlExample.ThreadControlDemo();
                    break;
                case "3":
                    SharedMemoryCommunication.RunSharedMemoryExample();
                    break;
                case "4":
                    EventCommunication.RunEventExample();
                    break;
                case "5":
                    SemaphoreCommunication.RunSemaphoreExample();
                    break;
                case "6":
                    ThreadSynchronization.RunSynchronizationExample();
                    break;
                case "7":
                    ReaderWriterExample.RunReaderWriterExample();
                    break;
                case "8":
                    ThreadSafeCollections.RunThreadSafeCollectionExample();
                    break;
                case "9":
                    AdvancedSynchronization.RunAdvancedSynchronizationExample();
                    break;
                case "0":
                    return;
                default:
                    Console.WriteLine("無效選擇");
                    break;
            }
            Console.WriteLine("\n按任意鍵繼續(xù)...");
            Console.ReadKey();
        }
    }
}

// 使用線程名稱便于調試
Thread.CurrentThread.Name = "WorkerThread";
// 使用Trace輸出線程信息
System.Diagnostics.Trace.WriteLine($"Thread {Thread.CurrentThread.ManagedThreadId}: Starting work");
// 使用條件斷點調試特定線程
if (Thread.CurrentThread.Name == "SpecificThread")
{
    System.Diagnostics.Debugger.Break();
}

using System;
using System.Threading;
using System.Threading.Tasks;
using System.Net.Http;
using System.IO;
public class TaskBasics
{
    // 創(chuàng)建和運行Task的不同方式
    public static void TaskCreationExamples()
    {
        Console.WriteLine("=== Task創(chuàng)建示例 ===");
        // 方式1：使用Task.Run
        Task task1 = Task.Run(() =>
        {
            Console.WriteLine($"Task1 運行在線程 {Thread.CurrentThread.ManagedThreadId}");
            Thread.Sleep(1000);
            Console.WriteLine("Task1 完成");
        });
        // 方式2：使用Task.Factory.StartNew（更多控制選項）
        Task task2 = Task.Factory.StartNew(() =>
        {
            Console.WriteLine($"Task2 運行在線程 {Thread.CurrentThread.ManagedThreadId}");
            Thread.Sleep(500);
        }, CancellationToken.None, 
           TaskCreationOptions.LongRunning, 
           TaskScheduler.Default);
        // 方式3：使用new Task（需要手動啟動）
        Task task3 = new Task(() =>
        {
            Console.WriteLine($"Task3 運行在線程 {Thread.CurrentThread.ManagedThreadId}");
        });
        task3.Start();
        // 方式4：返回結果的Task
        Task<int> task4 = Task.Run(() =>
        {
            Console.WriteLine("Task4 計算中...");
            Thread.Sleep(1000);
            return 42;
        });
        // 等待所有任務完成
        Task.WaitAll(task1, task2, task3, task4);
        Console.WriteLine($"Task4 結果: {task4.Result}");
    }
    // Task的連續(xù)任務（ContinueWith）
    public static void TaskContinuationExample()
    {
        Console.WriteLine("\n=== Task連續(xù)任務示例 ===");
        Task<int> firstTask = Task.Run(() =>
        {
            Console.WriteLine("第一個任務執(zhí)行中...");
            Thread.Sleep(1000);
            return 10;
        });
        // 單個連續(xù)任務
        Task<int> continuationTask = firstTask.ContinueWith(antecedent =>
        {
            Console.WriteLine($"第一個任務結果: {antecedent.Result}");
            return antecedent.Result * 2;
        });
        // 多個連續(xù)任務鏈
        continuationTask
            .ContinueWith(t => 
            {
                Console.WriteLine($"第二個連續(xù)任務，結果: {t.Result}");
                return t.Result + 5;
            })
            .ContinueWith(t => 
            {
                Console.WriteLine($"最終結果: {t.Result}");
            });
        // 條件連續(xù)任務
        Task faultedTask = Task.Run(() => 
        {
            throw new Exception("任務失敗");
        });
        faultedTask.ContinueWith(t =>
        {
            Console.WriteLine($"任務失敗: {t.Exception?.GetBaseException().Message}");
        }, TaskContinuationOptions.OnlyOnFaulted);
        faultedTask.ContinueWith(t =>
        {
            Console.WriteLine("任務成功完成");
        }, TaskContinuationOptions.OnlyOnRanToCompletion);
        Thread.Sleep(3000);
    }
    // Task異常處理
    public static void TaskExceptionHandling()
    {
        Console.WriteLine("\n=== Task異常處理示例 ===");
        // 方式1：使用Wait或Result捕獲異常
        Task taskWithError = Task.Run(() =>
        {
            throw new InvalidOperationException("任務中的異常");
        });
        try
        {
            taskWithError.Wait();
        }
        catch (AggregateException ae)
        {
            foreach (var ex in ae.InnerExceptions)
            {
                Console.WriteLine($"捕獲異常: {ex.Message}");
            }
        }
        // 方式2：使用ContinueWith處理異常
        Task.Run(() =>
        {
            throw new Exception("另一個異常");
        }).ContinueWith(t =>
        {
            if (t.IsFaulted)
            {
                Console.WriteLine($"任務失敗: {t.Exception?.Flatten().InnerException?.Message}");
            }
        });
        Thread.Sleep(1000);
    }
}

using System;
using System.Threading;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Diagnostics;
public class AsyncAwaitPatterns
{
    // 基礎async/await使用
    public static async Task BasicAsyncExample()
    {
        Console.WriteLine("=== 基礎Async/Await示例 ===");
        Console.WriteLine($"開始方法，線程: {Thread.CurrentThread.ManagedThreadId}");
        // 異步延遲
        await Task.Delay(1000);
        Console.WriteLine($"延遲后，線程: {Thread.CurrentThread.ManagedThreadId}");
        // 異步運行CPU密集型任務
        int result = await Task.Run(() =>
        {
            Console.WriteLine($"Task.Run內部，線程: {Thread.CurrentThread.ManagedThreadId}");
            Thread.Sleep(500);
            return 42;
        });
        Console.WriteLine($"結果: {result}");
    }
    // 異步方法返回值
    public static async Task<string> GetDataAsync(string input)
    {
        Console.WriteLine($"獲取數(shù)據(jù): {input}");
        await Task.Delay(1000);
        return $"處理結果: {input.ToUpper()}";
    }
    // 并發(fā)執(zhí)行多個異步操作
    public static async Task ConcurrentAsyncOperations()
    {
        Console.WriteLine("\n=== 并發(fā)異步操作示例 ===");
        Stopwatch sw = Stopwatch.StartNew();
        // 順序執(zhí)行（較慢）
        string result1 = await GetDataAsync("first");
        string result2 = await GetDataAsync("second");
        string result3 = await GetDataAsync("third");
        sw.Stop();
        Console.WriteLine($"順序執(zhí)行耗時: {sw.ElapsedMilliseconds}ms");
        sw.Restart();
        // 并發(fā)執(zhí)行（較快）
        Task<string> task1 = GetDataAsync("first");
        Task<string> task2 = GetDataAsync("second");
        Task<string> task3 = GetDataAsync("third");
        string[] results = await Task.WhenAll(task1, task2, task3);
        sw.Stop();
        Console.WriteLine($"并發(fā)執(zhí)行耗時: {sw.ElapsedMilliseconds}ms");
        Console.WriteLine($"結果: {string.Join(", ", results)}");
    }
    // 異步流處理（使用IAsyncEnumerable需要.NET Core 3.0+，這里使用Task<IEnumerable>模擬）
    public static async Task<IEnumerable<int>> GetNumbersAsync()
    {
        List<int> numbers = new List<int>();
        for (int i = 0; i < 5; i++)
        {
            await Task.Delay(200);
            numbers.Add(i);
            Console.WriteLine($"生成數(shù)字: {i}");
        }
        return numbers;
    }
    // 異步異常處理
    public static async Task AsyncExceptionHandling()
    {
        Console.WriteLine("\n=== 異步異常處理示例 ===");
        try
        {
            await ThrowExceptionAsync();
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine($"捕獲異步異常: {ex.Message}");
        }
        // 處理多個任務的異常
        Task failedTask1 = ThrowExceptionAsync();
        Task failedTask2 = ThrowExceptionAsync();
        Task successTask = Task.Delay(100);
        try
        {
            await Task.WhenAll(failedTask1, failedTask2, successTask);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"WhenAll異常: {ex.Message}");
            // 獲取所有異常
            if (failedTask1.IsFaulted)
                Console.WriteLine($"Task1異常: {failedTask1.Exception?.GetBaseException().Message}");
            if (failedTask2.IsFaulted)
                Console.WriteLine($"Task2異常: {failedTask2.Exception?.GetBaseException().Message}");
        }
    }
    private static async Task ThrowExceptionAsync()
    {
        await Task.Delay(100);
        throw new InvalidOperationException("異步方法中的異常");
    }
    // 取消異步操作
    public static async Task CancellationExample()
    {
        Console.WriteLine("\n=== 異步取消示例 ===");
        CancellationTokenSource cts = new CancellationTokenSource();
        // 設置超時
        cts.CancelAfter(2000);
        try
        {
            await LongRunningOperationAsync(cts.Token);
        }
        catch (OperationCanceledException)
        {
            Console.WriteLine("操作被取消");
        }
        // 手動取消
        CancellationTokenSource manualCts = new CancellationTokenSource();
        Task longTask = LongRunningOperationAsync(manualCts.Token);
        await Task.Delay(500);
        Console.WriteLine("手動取消操作...");
        manualCts.Cancel();
        try
        {
            await longTask;
        }
        catch (OperationCanceledException)
        {
            Console.WriteLine("操作被手動取消");
        }
    }
    private static async Task LongRunningOperationAsync(CancellationToken cancellationToken)
    {
        for (int i = 0; i < 10; i++)
        {
            cancellationToken.ThrowIfCancellationRequested();
            Console.WriteLine($"工作進度: {i + 1}/10");
            await Task.Delay(500, cancellationToken);
        }
        Console.WriteLine("操作完成");
    }
}

using System;
using System.Threading;
using System.Threading.Tasks;
using System.Threading.Tasks.Dataflow;
using System.Collections.Generic;
using System.Linq;
public class AdvancedAsyncPatterns
{
    // 使用TaskCompletionSource創(chuàng)建自定義異步操作
    public static Task<int> CreateCustomAsyncOperation()
    {
        TaskCompletionSource<int> tcs = new TaskCompletionSource<int>();
        // 模擬異步操作
        Timer timer = null;
        timer = new Timer(_ =>
        {
            tcs.SetResult(42);
            timer?.Dispose();
        }, null, 1000, Timeout.Infinite);
        return tcs.Task;
    }
    // 異步信號量（SemaphoreSlim）
    private static SemaphoreSlim semaphore = new SemaphoreSlim(2, 2);
    public static async Task AsyncSemaphoreExample()
    {
        Console.WriteLine("=== 異步信號量示例 ===");
        List<Task> tasks = new List<Task>();
        for (int i = 0; i < 5; i++)
        {
            int taskId = i;
            tasks.Add(Task.Run(async () =>
            {
                await semaphore.WaitAsync();
                try
                {
                    Console.WriteLine($"任務 {taskId} 進入臨界區(qū)");
                    await Task.Delay(2000);
                    Console.WriteLine($"任務 {taskId} 離開臨界區(qū)");
                }
                finally
                {
                    semaphore.Release();
                }
            }));
        }
        await Task.WhenAll(tasks);
    }
    // 異步鎖（AsyncLock實現(xiàn)）
    public class AsyncLock
    {
        private readonly SemaphoreSlim semaphore = new SemaphoreSlim(1, 1);
        public async Task<IDisposable> LockAsync()
        {
            await semaphore.WaitAsync();
            return new LockReleaser(semaphore);
        }
        private class LockReleaser : IDisposable
        {
            private readonly SemaphoreSlim semaphore;
            public LockReleaser(SemaphoreSlim semaphore)
            {
                this.semaphore = semaphore;
            }
            public void Dispose()
            {
                semaphore.Release();
            }
        }
    }
    // 使用異步鎖
    private static AsyncLock asyncLock = new AsyncLock();
    private static int sharedResource = 0;
    public static async Task AsyncLockExample()
    {
        Console.WriteLine("\n=== 異步鎖示例 ===");
        List<Task> tasks = new List<Task>();
        for (int i = 0; i < 10; i++)
        {
            tasks.Add(Task.Run(async () =>
            {
                using (await asyncLock.LockAsync())
                {
                    int temp = sharedResource;
                    await Task.Delay(10);
                    sharedResource = temp + 1;
                    Console.WriteLine($"共享資源值: {sharedResource}");
                }
            }));
        }
        await Task.WhenAll(tasks);
        Console.WriteLine($"最終值: {sharedResource}");
    }
    // 異步生產者-消費者模式
    public static async Task ProducerConsumerAsync()
    {
        Console.WriteLine("\n=== 異步生產者-消費者模式 ===");
        // 使用Channel作為隊列（.NET Core 3.0+）
        // 這里使用BlockingCollection模擬
        var queue = new System.Collections.Concurrent.BlockingCollection<int>(10);
        // 生產者
        Task producer = Task.Run(async () =>
        {
            for (int i = 0; i < 20; i++)
            {
                queue.Add(i);
                Console.WriteLine($"生產: {i}");
                await Task.Delay(100);
            }
            queue.CompleteAdding();
        });
        // 消費者
        Task consumer = Task.Run(async () =>
        {
            while (!queue.IsCompleted)
            {
                if (queue.TryTake(out int item, 100))
                {
                    Console.WriteLine($"消費: {item}");
                    await Task.Delay(200);
                }
            }
        });
        await Task.WhenAll(producer, consumer);
    }
    // 批量異步操作with限流
    public static async Task ThrottledAsyncOperations()
    {
        Console.WriteLine("\n=== 限流異步操作示例 ===");
        // 要處理的數(shù)據(jù)
        List<int> data = Enumerable.Range(1, 20).ToList();
        // 最大并發(fā)數(shù)
        int maxConcurrency = 3;
        SemaphoreSlim throttler = new SemaphoreSlim(maxConcurrency);
        List<Task> tasks = new List<Task>();
        foreach (var item in data)
        {
            tasks.Add(Task.Run(async () =>
            {
                await throttler.WaitAsync();
                try
                {
                    Console.WriteLine($"開始處理: {item}");
                    await ProcessItemAsync(item);
                    Console.WriteLine($"完成處理: {item}");
                }
                finally
                {
                    throttler.Release();
                }
            }));
        }
        await Task.WhenAll(tasks);
    }
    private static async Task ProcessItemAsync(int item)
    {
        await Task.Delay(1000);
    }
}

using System;
using System.Threading;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Linq;
using System.Collections.Concurrent;
using System.Diagnostics;
public class ParallelProgramming
{
    // Parallel.For和Parallel.ForEach
    public static void ParallelLoops()
    {
        Console.WriteLine("=== Parallel循環(huán)示例 ===");
        // Parallel.For
        Console.WriteLine("\nParallel.For示例:");
        Parallel.For(0, 10, i =>
        {
            Console.WriteLine($"處理索引 {i}, 線程: {Thread.CurrentThread.ManagedThreadId}");
            Thread.Sleep(100);
        });
        // Parallel.ForEach
        Console.WriteLine("\nParallel.ForEach示例:");
        List<string> items = new List<string> { "A", "B", "C", "D", "E", "F", "G", "H" };
        Parallel.ForEach(items, item =>
        {
            Console.WriteLine($"處理項目 {item}, 線程: {Thread.CurrentThread.ManagedThreadId}");
            Thread.Sleep(200);
        });
        // 帶有ParallelOptions的控制
        Console.WriteLine("\n帶選項的Parallel.ForEach:");
        ParallelOptions options = new ParallelOptions
        {
            MaxDegreeOfParallelism = 2,
            CancellationToken = CancellationToken.None
        };
        Parallel.ForEach(items, options, item =>
        {
            Console.WriteLine($"限制并發(fā)處理 {item}, 線程: {Thread.CurrentThread.ManagedThreadId}");
            Thread.Sleep(500);
        });
    }
    // Parallel.Invoke
    public static void ParallelInvoke()
    {
        Console.WriteLine("\n=== Parallel.Invoke示例 ===");
        Parallel.Invoke(
            () => DoWork("任務1", 1000),
            () => DoWork("任務2", 1500),
            () => DoWork("任務3", 800),
            () => DoWork("任務4", 1200)
        );
        Console.WriteLine("所有并行任務完成");
    }
    private static void DoWork(string taskName, int delay)
    {
        Console.WriteLine($"{taskName} 開始, 線程: {Thread.CurrentThread.ManagedThreadId}");
        Thread.Sleep(delay);
        Console.WriteLine($"{taskName} 完成");
    }
    // PLINQ（并行LINQ）
    public static void PLINQExamples()
    {
        Console.WriteLine("\n=== PLINQ示例 ===");
        // 生成測試數(shù)據(jù)
        List<int> numbers = Enumerable.Range(1, 100).ToList();
        // 基本PLINQ查詢
        var parallelQuery = numbers
            .AsParallel()
            .Where(n => n % 2 == 0)
            .Select(n => n * n)
            .ToList();
        Console.WriteLine($"偶數(shù)平方結果數(shù)量: {parallelQuery.Count}");
        // 控制并行度
        var controlledQuery = numbers
            .AsParallel()
            .WithDegreeOfParallelism(2)
            .Where(n => IsPrime(n))
            .ToList();
        Console.WriteLine($"質數(shù)數(shù)量: {controlledQuery.Count}");
        // 保持順序
        var orderedQuery = numbers
            .AsParallel()
            .AsOrdered()
            .Where(n => n > 50)
            .Select(n => n * 2)
            .Take(10)
            .ToList();
        Console.WriteLine($"有序結果: {string.Join(", ", orderedQuery)}");
        // 聚合操作
        int sum = numbers
            .AsParallel()
            .Where(n => n % 3 == 0)
            .Sum();
        Console.WriteLine($"能被3整除的數(shù)之和: {sum}");
        // 性能比較
        Stopwatch sw = Stopwatch.StartNew();
        // 順序執(zhí)行
        var sequentialResult = numbers
            .Where(n => ExpensiveOperation(n))
            .ToList();
        sw.Stop();
        Console.WriteLine($"順序執(zhí)行時間: {sw.ElapsedMilliseconds}ms");
        sw.Restart();
        // 并行執(zhí)行
        var parallelResult = numbers
            .AsParallel()
            .Where(n => ExpensiveOperation(n))
            .ToList();
        sw.Stop();
        Console.WriteLine($"并行執(zhí)行時間: {sw.ElapsedMilliseconds}ms");
    }
    private static bool IsPrime(int number)
    {
        if (number <= 1) return false;
        if (number == 2) return true;
        if (number % 2 == 0) return false;
        for (int i = 3; i * i <= number; i += 2)
        {
            if (number % i == 0) return false;
        }
        return true;
    }
    private static bool ExpensiveOperation(int number)
    {
        Thread.Sleep(10);
        return number % 7 == 0;
    }
    // 并行聚合
    public static void ParallelAggregation()
    {
        Console.WriteLine("\n=== 并行聚合示例 ===");
        int[] numbers = Enumerable.Range(1, 1000000).ToArray();
        object lockObj = new object();
        double total = 0;
        // 使用Parallel.ForEach with local state
        Parallel.ForEach(
            numbers,
            () => 0.0, // 局部初始值
            (number, loop, localTotal) => // 局部計算
            {
                return localTotal + Math.Sqrt(number);
            },
            localTotal => // 合并局部結果
            {
                lock (lockObj)
                {
                    total += localTotal;
                }
            }
        );
        Console.WriteLine($"并行聚合結果: {total:F2}");
        // 使用PLINQ聚合
        double plinqTotal = numbers
            .AsParallel()
            .Select(n => Math.Sqrt(n))
            .Sum();
        Console.WriteLine($"PLINQ聚合結果: {plinqTotal:F2}");
    }
}

using System;
using System.Threading;
using System.Threading.Tasks;
using System.Threading.Tasks.Dataflow;
using System.Collections.Generic;
public class DataflowPipeline
{
    // 簡單的數(shù)據(jù)流管道
    public static async Task SimpleDataflowExample()
    {
        Console.WriteLine("=== 數(shù)據(jù)流管道示例 ===");
        // 創(chuàng)建數(shù)據(jù)流塊
        var transformBlock = new TransformBlock<int, string>(
            async n =>
            {
                await Task.Delay(100);
                Console.WriteLine($"轉換: {n} -> {n * n}");
                return $"Result: {n * n}";
            },
            new ExecutionDataflowBlockOptions
            {
                MaxDegreeOfParallelism = 2
            }
        );
        var actionBlock = new ActionBlock<string>(
            async s =>
            {
                await Task.Delay(50);
                Console.WriteLine($"處理: {s}");
            }
        );
        // 鏈接塊
        transformBlock.LinkTo(actionBlock, new DataflowLinkOptions { PropagateCompletion = true });
        // 發(fā)送數(shù)據(jù)
        for (int i = 1; i <= 10; i++)
        {
            await transformBlock.SendAsync(i);
        }
        // 標記完成
        transformBlock.Complete();
        // 等待完成
        await actionBlock.Completion;
        Console.WriteLine("數(shù)據(jù)流管道完成");
    }
    // 復雜的數(shù)據(jù)處理管道
    public static async Task ComplexPipelineExample()
    {
        Console.WriteLine("\n=== 復雜數(shù)據(jù)處理管道 ===");
        // 廣播塊（一對多）
        var broadcastBlock = new BroadcastBlock<int>(n => n);
        // 批處理塊
        var batchBlock = new BatchBlock<int>(3);
        // 轉換塊
        var multiplyBlock = new TransformBlock<int, int>(n => n * 2);
        var addBlock = new TransformBlock<int, int>(n => n + 100);
        // 合并塊
        var joinBlock = new JoinBlock<int, int>();
        // 動作塊
        var finalBlock = new ActionBlock<Tuple<int, int>>(
            tuple => Console.WriteLine($"結果: {tuple.Item1}, {tuple.Item2}")
        );
        var batchPrintBlock = new ActionBlock<int[]>(
            batch => Console.WriteLine($"批次: [{string.Join(", ", batch)}]")
        );
        // 構建管道
        broadcastBlock.LinkTo(multiplyBlock);
        broadcastBlock.LinkTo(addBlock);
        broadcastBlock.LinkTo(batchBlock);
        multiplyBlock.LinkTo(joinBlock.Target1);
        addBlock.LinkTo(joinBlock.Target2);
        joinBlock.LinkTo(finalBlock);
        batchBlock.LinkTo(batchPrintBlock);
        // 發(fā)送數(shù)據(jù)
        for (int i = 1; i <= 9; i++)
        {
            await broadcastBlock.SendAsync(i);
        }
        broadcastBlock.Complete();
        await Task.Delay(2000);
    }
}

using System;
using System.Threading;
using System.Threading.Tasks;
using System.IO;
using System.Net.Http;
public class AsyncBestPractices
{
    // 避免async void（除了事件處理器）
    // 錯誤示例
    public async void BadAsyncMethod()
    {
        await Task.Delay(1000);
        throw new Exception("無法捕獲的異常");
    }
    // 正確示例
    public async Task GoodAsyncMethod()
    {
        await Task.Delay(1000);
        throw new Exception("可以捕獲的異常");
    }
    // 配置await
    public async Task ConfigureAwaitExample()
    {
        // 不需要捕獲上下文時使用ConfigureAwait(false)
        await Task.Delay(1000).ConfigureAwait(false);
        // 這在庫代碼中特別重要，可以提高性能
        await SomeLibraryMethodAsync().ConfigureAwait(false);
    }
    private Task SomeLibraryMethodAsync() => Task.CompletedTask;
    // 避免阻塞異步代碼
    public class AvoidBlockingExample
    {
        // 錯誤：可能導致死鎖
        public void BadExample()
        {
            var result = GetDataAsync().Result; // 避免這樣做
            GetDataAsync().Wait(); // 也要避免這樣
        }
        // 正確：使用async/await
        public async Task GoodExample()
        {
            var result = await GetDataAsync();
        }
        private async Task<string> GetDataAsync()
        {
            await Task.Delay(100);
            return "data";
        }
    }
    // 使用ValueTask優(yōu)化性能
    public async ValueTask<int> GetCachedValueAsync()
    {
        // 如果有緩存值，直接返回（沒有分配）
        if (_cache.ContainsKey("key"))
            return _cache["key"];
        // 否則異步獲取
        var value = await ComputeValueAsync();
        _cache["key"] = value;
        return value;
    }
    private Dictionary<string, int> _cache = new Dictionary<string, int>();
    private async Task<int> ComputeValueAsync()
    {
        await Task.Delay(1000);
        return 42;
    }
    // 正確處理多個異步操作
    public async Task HandleMultipleOperationsCorrectly()
    {
        // 錯誤：順序等待（慢）
        var result1 = await Operation1Async();
        var result2 = await Operation2Async();
        var result3 = await Operation3Async();
        // 正確：并發(fā)執(zhí)行（快）
        var task1 = Operation1Async();
        var task2 = Operation2Async();
        var task3 = Operation3Async();
        await Task.WhenAll(task1, task2, task3);
        var results = new[] { task1.Result, task2.Result, task3.Result };
    }
    private Task<int> Operation1Async() => Task.FromResult(1);
    private Task<int> Operation2Async() => Task.FromResult(2);
    private Task<int> Operation3Async() => Task.FromResult(3);
    // 使用IAsyncDisposable（.NET Standard 2.1+）
    public class AsyncDisposableExample : IDisposable
    {
        private readonly HttpClient httpClient = new HttpClient();
        private readonly FileStream fileStream;
        public AsyncDisposableExample(string filePath)
        {
            fileStream = new FileStream(filePath, FileMode.Create);
        }
        public async Task WriteAsync(byte[] data)
        {
            await fileStream.WriteAsync(data, 0, data.Length);
        }
        // 異步清理資源
        public async ValueTask DisposeAsync()
        {
            if (fileStream != null)
            {
                await fileStream.FlushAsync();
                fileStream.Dispose();
            }
            httpClient?.Dispose();
        }
        public void Dispose()
        {
            fileStream?.Dispose();
            httpClient?.Dispose();
        }
    }
}

public class AsyncProgrammingDemo
{
    public static async Task Main(string[] args)
    {
        while (true)
        {
            Console.Clear();
            Console.WriteLine("===== .NET異步編程示例 =====");
            Console.WriteLine("1. Task基礎操作");
            Console.WriteLine("2. Task連續(xù)和異常處理");
            Console.WriteLine("3. 基礎Async/Await");
            Console.WriteLine("4. 并發(fā)異步操作");
            Console.WriteLine("5. 異步取消操作");
            Console.WriteLine("6. 高級異步模式");
            Console.WriteLine("7. Parallel循環(huán)");
            Console.WriteLine("8. PLINQ示例");
            Console.WriteLine("9. 數(shù)據(jù)流管道");
            Console.WriteLine("0. 返回主菜單");
            Console.Write("\n請選擇 (0-9): ");
            string choice = Console.ReadLine();
            Console.Clear();
            try
            {
                switch (choice)
                {
                    case "1":
                        TaskBasics.TaskCreationExamples();
                        break;
                    case "2":
                        TaskBasics.TaskContinuationExample();
                        TaskBasics.TaskExceptionHandling();
                        break;
                    case "3":
                        await AsyncAwaitPatterns.BasicAsyncExample();
                        break;
                    case "4":
                        await AsyncAwaitPatterns.ConcurrentAsyncOperations();
                        break;
                    case "5":
                        await AsyncAwaitPatterns.CancellationExample();
                        break;
                    case "6":
                        await AdvancedAsyncPatterns.AsyncSemaphoreExample();
                        await AdvancedAsyncPatterns.AsyncLockExample();
                        break;
                    case "7":
                        ParallelProgramming.ParallelLoops();
                        ParallelProgramming.ParallelInvoke();
                        break;
                    case "8":
                        ParallelProgramming.PLINQExamples();
                        break;
                    case "9":
                        await DataflowPipeline.SimpleDataflowExample();
                        await DataflowPipeline.ComplexPipelineExample();
                        break;
                    case "0":
                        return;
                    default:
                        Console.WriteLine("無效選擇");
                        break;
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"發(fā)生錯誤: {ex.Message}");
            }
            Console.WriteLine("\n按任意鍵繼續(xù)...");
            Console.ReadKey();
        }
    }
}