// out 參數(shù)聲明語法
public void MethodName(out DataType parameterName)
{
    // 必須在方法返回前為 out 參數(shù)賦值
    parameterName = value;
}

┌───────────────────────────────────────────────────────┐
│                out 參數(shù)執(zhí)行流程                      │
├───────────────┬─────────────────┬─────────────────────┤
│  調(diào)用前狀態(tài)    │    方法執(zhí)行中    │     方法返回后       │
├───────────────┼─────────────────┼─────────────────────┤
│  變量未初始化   │  方法內(nèi)部賦值    │  變量已獲得新值      │
│  int value;    │  value = 42;   │  Console.WriteLine(value); // 42
└───────────────┴─────────────────┴─────────────────────┘

public class BasicOutExample
{
    // 定義帶有 out 參數(shù)的方法
    public static bool TryParseInt(string input, out int result)
    {
        // 必須為 out 參數(shù)賦值
        if (int.TryParse(input, out result))
        {
            return true;
        }
        else
        {
            result = 0; // 即使解析失敗，也必須賦值
            return false;
        }
    }
    
    // 調(diào)用示例
    public static void Main()
    {
        // 調(diào)用方無需初始化 out 參數(shù)
        if (TryParseInt("123", out int number))
        {
            Console.WriteLine($"解析成功: {number}"); // 輸出: 123
        }
        
        // 多個(gè) out 參數(shù)
        bool success = TryParseCoordinates("10,20", out int x, out int y);
        if (success) Console.WriteLine($"坐標(biāo): ({x}, {y})"); // (10, 20)
    }
    
    // 多個(gè) out 參數(shù)示例
    public static bool TryParseCoordinates(string input, out int x, out int y)
    {
        string[] parts = input.Split(',');
        if (parts.Length == 2 && 
            int.TryParse(parts[0], out x) && // 嵌套 out 參數(shù)
            int.TryParse(parts[1], out y))
        {
            return true;
        }
        
        // 為所有 out 參數(shù)賦值
        x = 0;
        y = 0;
        return false;
    }
}

public class ModernOutExamples
{
    public static void Demo()
    {
        string input = "42";
        
        // C# 7.0+：在方法調(diào)用中直接聲明 out 變量
        if (int.TryParse(input, out int result))
        {
            Console.WriteLine($"解析結(jié)果: {result}"); // 42
        }
        
        // 內(nèi)聯(lián)聲明多個(gè) out 變量
        if (DateTime.TryParse("2023-08-15", out var date))
        {
            Console.WriteLine($"日期: {date:yyyy-MM-dd}"); // 2023-08-15
        }
        
        // 使用 discard (_) 忽略不需要的 out 參數(shù)
        if (TryGetUserInfo("user123", out string name, out _, out int age))
        {
            Console.WriteLine($"{name} is {age} years old");
        }
        
        // out 變量在 if/else 范圍內(nèi)可見
        if (TryGetConfiguration(out var config))
        {
            Console.WriteLine($"配置值: {config.Value}");
        }
        else
        {
            // config 在這里仍然可見，但未初始化
            Console.WriteLine("無法獲取配置");
        }
        
        // out 變量在代碼塊外也可見
        Console.WriteLine($"配置對(duì)象: {config?.ToString() ?? "null"}");
    }
    
    public static bool TryGetUserInfo(string userId, out string name, out string email, out int age)
    {
        // 模擬數(shù)據(jù)庫查詢
        if (userId == "user123")
        {
            name = "John Doe";
            email = "john@example.com";
            age = 30;
            return true;
        }
        
        name = null;
        email = null;
        age = 0;
        return false;
    }
    
    public static bool TryGetConfiguration(out Configuration config)
    {
        // 模擬配置加載
        if (DateTime.Now.Second % 2 == 0)
        {
            config = new Configuration { Value = "Active" };
            return true;
        }
        
        config = null;
        return false;
    }
    
    public class Configuration
    {
        public string Value { get; set; }
        public override string ToString() => Value ?? "null";
    }
}

public class OutVsRef
{
    // out 參數(shù)：僅輸出
    public static void GetMinMax(int[] numbers, out int min, out int max)
    {
        if (numbers == null || numbers.Length == 0)
        {
            min = 0;
            max = 0;
            return;
        }
        
        min = numbers[0];
        max = numbers[0];
        
        foreach (int num in numbers)
        {
            if (num < min) min = num;
            if (num > max) max = num;
        }
    }
    
    // ref 參數(shù)：輸入+輸出
    public static void Swap(ref int a, ref int b)
    {
        int temp = a;
        a = b;
        b = temp;
    }
    
    public static void Demonstrate()
    {
        // out 參數(shù)：調(diào)用方無需初始化
        int[] values = { 3, 1, 4, 1, 5, 9 };
        GetMinMax(values, out int minValue, out int maxValue);
        Console.WriteLine($"Min: {minValue}, Max: {maxValue}"); // Min: 1, Max: 9
        
        // ref 參數(shù)：調(diào)用方必須初始化
        int x = 10, y = 20;
        Swap(ref x, ref y);
        Console.WriteLine($"After swap: x={x}, y={y}"); // x=20, y=10
        
        // out 參數(shù)不能接收未初始化變量 (錯(cuò)誤示例)
        // int uninitialized;
        // GetMinMax(values, out uninitialized, out int max); // 編譯錯(cuò)誤！
        
        // ref 參數(shù)必須接收已初始化變量 (錯(cuò)誤示例)
        // int uninitialized;
        // Swap(ref uninitialized, ref y); // 編譯錯(cuò)誤！
    }
}

public class TryParsePattern
{
    // 標(biāo)準(zhǔn) Try-Parse 模式
    public static bool TryParsePhoneNumber(string input, out PhoneNumber number)
    {
        // 清理輸入
        string digits = new string(input.Where(char.IsDigit).ToArray());
        
        if (digits.Length == 10) // 簡(jiǎn)化的美國號(hào)碼格式
        {
            number = new PhoneNumber
            {
                AreaCode = digits.Substring(0, 3),
                Exchange = digits.Substring(3, 3),
                Subscriber = digits.Substring(6, 4)
            };
            return true;
        }
        
        number = null;
        return false;
    }
    
    // 泛型 Try-Parse 擴(kuò)展方法
    public static class ParsingExtensions
    {
        public static bool TryParseEnum<T>(string value, out T result) where T : struct
        {
            return Enum.TryParse(value, out result);
        }
        
        public static bool TryParseJson<T>(string json, out T result)
        {
            try
            {
                result = JsonSerializer.Deserialize<T>(json);
                return true;
            }
            catch
            {
                result = default;
                return false;
            }
        }
    }
    
    public class PhoneNumber
    {
        public string AreaCode { get; set; }
        public string Exchange { get; set; }
        public string Subscriber { get; set; }
        
        public override string ToString() => $"({AreaCode}) {Exchange}-{Subscriber}";
    }
    
    public static void Demo()
    {
        if (TryParsePhoneNumber("(555) 123-4567", out var phone))
        {
            Console.WriteLine($"有效號(hào)碼: {phone}");
        }
        
        if (ParsingExtensions.TryParseEnum<ConsoleColor>("Blue", out var color))
        {
            Console.ForegroundColor = color;
            Console.WriteLine("顏色設(shè)置成功");
            Console.ResetColor();
        }
    }
}

public class DictionaryOperations
{
    private Dictionary<string, Product> _products = new();
    
    // 使用 out 避免雙重查找
    public bool TryGetProduct(string id, out Product product)
    {
        return _products.TryGetValue(id, out product);
    }
    
    // 高效的字典更新模式
    public void AddOrUpdate(string id, Product newProduct)
    {
        if (_products.TryGetValue(id, out Product existing))
        {
            // 更新現(xiàn)有產(chǎn)品
            existing.Name = newProduct.Name;
            existing.Price = newProduct.Price;
            Console.WriteLine($"產(chǎn)品 '{id}' 已更新");
        }
        else
        {
            // 添加新產(chǎn)品
            _products[id] = newProduct;
            Console.WriteLine($"產(chǎn)品 '{id}' 已添加");
        }
    }
    
    // 避免重復(fù)計(jì)算的模式
    public decimal CalculateTotal(Order order, out int itemCount)
    {
        itemCount = 0;
        decimal total = 0;
        
        foreach (var item in order.Items)
        {
            total += item.Price * item.Quantity;
            itemCount += item.Quantity;
        }
        
        return total;
    }
    
    public class Product
    {
        public string Id { get; set; }
        public string Name { get; set; }
        public decimal Price { get; set; }
    }
    
    public class OrderItem
    {
        public Product Product { get; set; }
        public int Quantity { get; set; }
        public decimal Price => Product.Price;
    }
    
    public class Order
    {
        public List<OrderItem> Items { get; } = new();
    }
    
    public static void Demo()
    {
        var ops = new DictionaryOperations();
        ops._products["P1"] = new Product { Id = "P1", Name = "Laptop", Price = 999.99m };
        
        if (ops.TryGetProduct("P1", out var product))
        {
            Console.WriteLine($"找到產(chǎn)品: {product.Name}");
        }
        
        var order = new Order();
        order.Items.Add(new OrderItem { Product = product, Quantity = 2 });
        
        decimal total = ops.CalculateTotal(order, out int count);
        Console.WriteLine($"總計(jì): ${total:F2}, 項(xiàng)目數(shù): {count}");
    }
}

public class DomainValidation
{
    // 驗(yàn)證模式，返回結(jié)果和錯(cuò)誤
    public static bool TryCreateUser(string name, string email, 
        out User user, out List<string> errors)
    {
        errors = new List<string>();
        user = null;
        
        if (string.IsNullOrWhiteSpace(name) || name.Length < 2)
        {
            errors.Add("名稱必須至少包含2個(gè)字符");
        }
        
        if (string.IsNullOrWhiteSpace(email) || !email.Contains("@"))
        {
            errors.Add("必須提供有效的電子郵件地址");
        }
        
        if (errors.Count > 0)
        {
            return false;
        }
        
        user = new User { Name = name, Email = email };
        return true;
    }
    
    // 事務(wù)處理模式
    public static bool TryExecuteTransaction(Action operation, 
        out Exception exception)
    {
        try
        {
            operation();
            exception = null;
            return true;
        }
        catch (Exception ex)
        {
            exception = ex;
            return false;
        }
    }
    
    public class User
    {
        public string Name { get; set; }
        public string Email { get; set; }
    }
    
    public static void Demo()
    {
        bool success = TryCreateUser("Alice", "alice@example.com", 
            out var user, out var validationErrors);
            
        if (success)
        {
            Console.WriteLine($"用戶創(chuàng)建成功: {user.Name}");
        }
        else
        {
            Console.WriteLine("驗(yàn)證失敗:");
            foreach (var error in validationErrors)
            {
                Console.WriteLine($"- {error}");
            }
        }
        
        // 事務(wù)示例
        success = TryExecuteTransaction(() => 
        {
            // 模擬數(shù)據(jù)庫操作
            throw new InvalidOperationException("數(shù)據(jù)庫連接失敗");
        }, out var ex);
        
        if (!success)
        {
            Console.WriteLine($"操作失敗: {ex.Message}");
        }
    }
}

public class PerformanceOptimization
{
    // 不良實(shí)踐：裝箱導(dǎo)致性能問題
    public static void BadTryGetValue(object value, out int result)
    {
        result = 0;
        if (value is int intValue)
        {
            result = intValue;
        }
    }
    
    // 良好實(shí)踐：使用泛型避免裝箱
    public static bool TryGetValue<T>(object value, out T result) where T : struct
    {
        if (value is T typedValue)
        {
            result = typedValue;
            return true;
        }
        
        result = default;
        return false;
    }
    
    // 值類型 vs 引用類型性能比較
    public static void ComparePerformance()
    {
        const int iterations = 1000000;
        int value = 42;
        object boxed = value;
        
        // 測(cè)試1：裝箱/拆箱
        var stopwatch = Stopwatch.StartNew();
        for (int i = 0; i < iterations; i++)
        {
            BadTryGetValue(boxed, out _);
        }
        stopwatch.Stop();
        Console.WriteLine($"裝箱方法耗時(shí): {stopwatch.ElapsedMilliseconds}ms");
        
        // 測(cè)試2：泛型方法
        stopwatch.Restart();
        for (int i = 0; i < iterations; i++)
        {
            TryGetValue<int>(boxed, out _);
        }
        stopwatch.Stop();
        Console.WriteLine($"泛型方法耗時(shí): {stopwatch.ElapsedMilliseconds}ms");
    }
    
    // 結(jié)構(gòu)體優(yōu)化
    public struct Vector3
    {
        public float X, Y, Z;
        
        public bool TryNormalize(out Vector3 normalized)
        {
            float length = (float)Math.Sqrt(X*X + Y*Y + Z*Z);
            
            if (length < 0.0001f)
            {
                normalized = default;
                return false;
            }
            
            normalized = new Vector3
            {
                X = X / length,
                Y = Y / length,
                Z = Z / length
            };
            return true;
        }
    }
    
    public static void Demo()
    {
        Vector3 v = new Vector3 { X = 1, Y = 2, Z = 3 };
        if (v.TryNormalize(out var normalized))
        {
            Console.WriteLine($"歸一化向量: ({normalized.X:F2}, {normalized.Y:F2}, {normalized.Z:F2})");
        }
    }
}

public class MemoryOptimization
{
    // 避免在循環(huán)中分配 out 變量
    public static void ProcessData(List<string> inputs)
    {
        // 好：在循環(huán)外聲明變量
        int parsedValue;
        List<int> results = new List<int>();
        
        foreach (var input in inputs)
        {
            if (int.TryParse(input, out parsedValue))
            {
                results.Add(parsedValue);
            }
        }
        
        // 不好：在每次迭代中創(chuàng)建新變量
        List<int> badResults = new List<int>();
        foreach (var input in inputs)
        {
            if (int.TryParse(input, out int tempValue)) // 每次創(chuàng)建新變量
            {
                badResults.Add(tempValue);
            }
        }
    }
    
    // 結(jié)構(gòu)體 vs 類的 out 參數(shù)
    public struct PointStruct
    {
        public int X { get; set; }
        public int Y { get; set; }
    }
    
    public class PointClass
    {
        public int X { get; set; }
        public int Y { get; set; }
    }
    
    // 結(jié)構(gòu)體 out 參數(shù) - 無堆分配
    public static void GetPointStruct(out PointStruct point)
    {
        point = new PointStruct { X = 10, Y = 20 };
    }
    
    // 類 out 參數(shù) - 有堆分配
    public static void GetPointClass(out PointClass point)
    {
        point = new PointClass { X = 10, Y = 20 }; // 堆分配
    }
    
    public static unsafe void Benchmark()
    {
        const int iterations = 1000000;
        
        // 結(jié)構(gòu)體測(cè)試
        var stopwatch = Stopwatch.StartNew();
        for (int i = 0; i < iterations; i++)
        {
            GetPointStruct(out var point);
        }
        stopwatch.Stop();
        Console.WriteLine($"結(jié)構(gòu)體 out 參數(shù): {stopwatch.ElapsedMilliseconds}ms");
        
        // 類測(cè)試
        stopwatch.Restart();
        for (int i = 0; i < iterations; i++)
        {
            GetPointClass(out var point);
        }
        stopwatch.Stop();
        Console.WriteLine($"類 out 參數(shù): {stopwatch.ElapsedMilliseconds}ms");
        
        // 使用 Span<T> 優(yōu)化緩沖區(qū)操作
        public static bool TryParseBuffer(ReadOnlySpan<char> buffer, out int value)
        {
            return int.TryParse(buffer, out value);
        }
    }
}

public class ErrorHandlingPatterns
{
    // 模式1：Try-Pattern (推薦)
    public static bool TryGetData(string key, out string value, out ErrorInfo error)
    {
        if (string.IsNullOrEmpty(key))
        {
            value = null;
            error = new ErrorInfo { Code = 400, Message = "鍵不能為空" };
            return false;
        }
        
        if (!_dataStore.TryGetValue(key, out value))
        {
            error = new ErrorInfo { Code = 404, Message = $"鍵 '{key}' 未找到" };
            return false;
        }
        
        error = null;
        return true;
    }
    
    // 模式2：Result 對(duì)象 (函數(shù)式風(fēng)格)
    public static Result<string> GetDataResult(string key)
    {
        if (string.IsNullOrEmpty(key))
        {
            return Result<string>.Failure("鍵不能為空");
        }
        
        if (!_dataStore.TryGetValue(key, out string value))
        {
            return Result<string>.Failure($"鍵 '{key}' 未找到");
        }
        
        return Result<string>.Success(value);
    }
    
    // 模式3：異常 vs out 參數(shù)
    public static string GetDataOrThrow(string key)
    {
        if (string.IsNullOrEmpty(key))
        {
            throw new ArgumentException("鍵不能為空", nameof(key));
        }
        
        if (!_dataStore.TryGetValue(key, out string value))
        {
            throw new KeyNotFoundException($"鍵 '{key}' 未找到");
        }
        
        return value;
    }
    
    private static Dictionary<string, string> _dataStore = new()
    {
        ["name"] = "John Doe",
        ["email"] = "john@example.com"
    };
    
    public class ErrorInfo
    {
        public int Code { get; set; }
        public string Message { get; set; }
    }
    
    public class Result<T>
    {
        public bool IsSuccess { get; }
        public T Value { get; }
        public string Error { get; }
        
        private Result(bool success, T value, string error)
        {
            IsSuccess = success;
            Value = value;
            Error = error;
        }
        
        public static Result<T> Success(T value) => 
            new Result<T>(true, value, null);
            
        public static Result<T> Failure(string error) => 
            new Result<T>(false, default, error);
    }
    
    public static void Demo()
    {
        // Try-Pattern
        if (TryGetData("name", out var value, out var error))
        {
            Console.WriteLine($"值: {value}");
        }
        else
        {
            Console.WriteLine($"錯(cuò)誤: {error.Message}");
        }
        
        // Result 對(duì)象
        var result = GetDataResult("email");
        if (result.IsSuccess)
        {
            Console.WriteLine($"結(jié)果: {result.Value}");
        }
        else
        {
            Console.WriteLine($"結(jié)果錯(cuò)誤: {result.Error}");
        }
        
        // 異常處理
        try
        {
            string data = GetDataOrThrow("invalid-key");
            Console.WriteLine($"數(shù)據(jù): {data}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"異常: {ex.Message}");
        }
    }
}

public class ApiDesignPrinciples
{
    // 原則1：?jiǎn)我宦氊?zé) - 每個(gè) out 參數(shù)有明確目的
    public static bool GetUserDetails(string userId, 
        out string name, 
        out string email, 
        out DateTime registrationDate)
    {
        // 模擬數(shù)據(jù)庫查詢
        if (_users.TryGetValue(userId, out var user))
        {
            name = user.Name;
            email = user.Email;
            registrationDate = user.RegistrationDate;
            return true;
        }
        
        name = null;
        email = null;
        registrationDate = default;
        return false;
    }
    
    // 原則2：避免過度使用 out 參數(shù)
    // 不推薦：太多 out 參數(shù)降低可讀性
    public static bool ProcessOrderBad(Order order, 
        out decimal subtotal, out decimal tax, out decimal shipping, 
        out decimal total, out string status, out List<string> errors)
    {
        // 復(fù)雜邏輯...
        subtotal = tax = shipping = total = 0;
        status = "Unknown";
        errors = new List<string>();
        return false;
    }
    
    // 推薦：使用結(jié)果對(duì)象
    public static OrderProcessingResult ProcessOrderGood(Order order)
    {
        try
        {
            decimal subtotal = CalculateSubtotal(order);
            decimal tax = CalculateTax(order, subtotal);
            decimal shipping = CalculateShipping(order);
            decimal total = subtotal + tax + shipping;
            
            return new OrderProcessingResult
            {
                IsSuccess = true,
                Subtotal = subtotal,
                Tax = tax,
                Shipping = shipping,
                Total = total,
                Status = "Processed"
            };
        }
        catch (Exception ex)
        {
            return new OrderProcessingResult
            {
                IsSuccess = false,
                Errors = new List<string> { ex.Message }
            };
        }
    }
    
    // 原則3：一致性 - 遵循框架模式
    // 與 Dictionary.TryGetValue() 保持一致
    public bool TryGetValue(string key, out TValue value)
    {
        return _internalDictionary.TryGetValue(key, out value);
    }
    
    // 原則4：文檔清晰
    /// <summary>
    /// 嘗試解析配置字符串
    /// </summary>
    /// <param name="configText">配置文本</param>
    /// <param name="config">解析成功的配置對(duì)象</param>
    /// <returns>如果成功解析配置，返回 true；否則返回 false</returns>
    /// <remarks>
    /// 即使方法返回 false，config 參數(shù)也會(huì)被賦值為默認(rèn)配置
    /// </remarks>
    public static bool TryParseConfig(string configText, out Config config)
    {
        // 實(shí)現(xiàn)細(xì)節(jié)...
        config = new Config();
        return false;
    }
    
    private static Dictionary<string, User> _users = new();
    
    public class User
    {
        public string Name { get; set; }
        public string Email { get; set; }
        public DateTime RegistrationDate { get; set; }
    }
    
    public class Order { /* ... */ }
    
    public class OrderProcessingResult
    {
        public bool IsSuccess { get; set; }
        public decimal Subtotal { get; set; }
        public decimal Tax { get; set; }
        public decimal Shipping { get; set; }
        public decimal Total { get; set; }
        public string Status { get; set; }
        public List<string> Errors { get; set; } = new();
    }
    
    private Dictionary<string, TValue> _internalDictionary = new();
    
    public class Config { /* ... */ }
}

public class CommonPitfalls
{
    // 陷阱1：忘記為所有 out 參數(shù)賦值
    public static bool BadMethod(string input, out int result1, out int result2)
    {
        if (int.TryParse(input, out result1))
        {
            // 忘記為 result2 賦值 - 編譯錯(cuò)誤！
            return true;
        }
        
        result1 = 0;
        result2 = 0; // 現(xiàn)在正確賦值
        return false;
    }
    
    // 陷阱2：在條件分支中未全部賦值
    public static void BadConditional(out int value)
    {
        if (DateTime.Now.Second % 2 == 0)
        {
            value = 42;
            return;
        }
        // 缺少 else 分支中的賦值 - 編譯錯(cuò)誤！
    }
    
    // 修復(fù)：確保所有路徑都賦值
    public static void FixedConditional(out int value)
    {
        if (DateTime.Now.Second % 2 == 0)
        {
            value = 42;
            return;
        }
        
        value = 0; // 默認(rèn)值
    }
    
    // 陷阱3：out 變量作用域混淆
    public static void ScopeProblem()
    {
        if (int.TryParse("42", out int number))
        {
            Console.WriteLine($"內(nèi)部: {number}");
        }
        
        // number 在這里可見，但未保證初始化
        Console.WriteLine($"外部: {number}"); // 可能未初始化！
    }
    
    // 陷阱4：異步方法中的 out 參數(shù)
    public static async Task<bool> BadAsyncMethod(string input, out int result)
    {
        // 在異步方法中，不能在 await 之后使用 out 參數(shù)
        result = 0;
        await Task.Delay(100);
        // 不能在這里修改 result - 編譯錯(cuò)誤！
        return true;
    }
    
    // 修復(fù)1：使用返回元組
    public static async Task<(bool Success, int Result)> GoodAsyncMethod(string input)
    {
        await Task.Delay(100);
        if (int.TryParse(input, out int result))
        {
            return (true, result);
        }
        return (false, 0);
    }
    
    // 修復(fù)2：使用包裝類
    public class AsyncResult
    {
        public bool Success { get; set; }
        public int Value { get; set; }
    }
    
    public static async Task<AsyncResult> AnotherAsyncMethod(string input)
    {
        await Task.Delay(100);
        if (int.TryParse(input, out int result))
        {
            return new AsyncResult { Success = true, Value = result };
        }
        return new AsyncResult { Success = false, Value = 0 };
    }
    
    // 陷阱5：out 參數(shù)與重載解析
    public static void Method(int value) { }
    public static void Method(out int value) { value = 42; }
    
    public static void OverloadProblem()
    {
        int x = 0;
        // Method(x); // 模棱兩可 - 編譯錯(cuò)誤！
        
        // 明確指定
        Method(out x); // 調(diào)用 out 版本
    }
}

public class BestPractices
{
    // 1. 優(yōu)先使用 Try-Pattern 進(jìn)行可能失敗的操作
    public static bool TryParsePhoneNumber(string input, out PhoneNumber number)
    {
        // 實(shí)現(xiàn)...
        number = null;
        return false;
    }
    
    // 2. 限制 out 參數(shù)數(shù)量 (建議不超過3個(gè))
    // 好的例子
    public static bool GetMinMax(IEnumerable<int> numbers, out int min, out int max)
    {
        // 實(shí)現(xiàn)...
        min = max = 0;
        return false;
    }
    
    // 3. 使用有意義的參數(shù)名
    public static bool TryFindUser(string userId, out User foundUser, out string errorMessage)
    {
        // 比使用 out1, out2 更清晰
        foundUser = null;
        errorMessage = "用戶未找到";
        return false;
    }
    
    // 4. 考慮使用元組或自定義類型代替多個(gè) out 參數(shù)
    public static (bool Success, int Value, string Error) ParseInt(string input)
    {
        if (int.TryParse(input, out int value))
        {
            return (true, value, null);
        }
        return (false, 0, "無效的整數(shù)格式");
    }
    
    // 5. 異步方法中避免 out 參數(shù)
    public static async Task<Result<int>> AsyncParseInt(string input)
    {
        await Task.Delay(10); // 模擬異步操作
        if (int.TryParse(input, out int value))
        {
            return Result<int>.Success(value);
        }
        return Result<int>.Failure("無效的整數(shù)格式");
    }
    
    // 6. 在公共 API 中保持一致性
    // 與 .NET 框架模式一致
    public bool TryGetValue(string key, out TValue value)
    {
        // 實(shí)現(xiàn)...
        value = default;
        return false;
    }
    
    public class PhoneNumber { /* ... */ }
    public class User { /* ... */ }
    public class Result<T> 
    {
        public bool Success { get; }
        public T Value { get; }
        public string Error { get; }
        // 實(shí)現(xiàn)...
    }
}

public class TupleAlternative
{
    // 傳統(tǒng) out 參數(shù)
    public static bool TryParseDateTime(string input, out DateTime result, out string errorMessage)
    {
        if (DateTime.TryParse(input, out result))
        {
            errorMessage = null;
            return true;
        }
        
        errorMessage = "無效的日期格式";
        return false;
    }
    
    // 現(xiàn)代元組替代
    public static (bool Success, DateTime Result, string Error) ParseDateTime(string input)
    {
        if (DateTime.TryParse(input, out var result))
        {
            return (true, result, null);
        }
        return (false, default, "無效的日期格式");
    }
    
    // 模式匹配增強(qiáng)
    public static void Demo()
    {
        // 傳統(tǒng)方式
        if (TryParseDateTime("2023-08-15", out var date1, out var error1))
        {
            Console.WriteLine($"成功: {date1}");
        }
        else
        {
            Console.WriteLine($"失敗: {error1}");
        }
        
        // 元組方式
        var result = ParseDateTime("2023-08-15");
        if (result.Success)
        {
            Console.WriteLine($"成功: {result.Result}");
        }
        else
        {
            Console.WriteLine($"失敗: {result.Error}");
        }
        
        // 元組解構(gòu)
        var (success, date2, error2) = ParseDateTime("invalid-date");
        Console.WriteLine(success ? $"日期: {date2}" : $"錯(cuò)誤: {error2}");
        
        // 模式匹配
        ParseDateTime("2023-08-15") switch
        {
            (true, var dt, _) => Console.WriteLine($"解析日期: {dt:yyyy-MM-dd}"),
            (false, _, var err) => Console.WriteLine($"解析錯(cuò)誤: {err}"),
        };
    }
}

public class ResultPattern
{
    // 泛型 Result 類
    public class Result<T>
    {
        public bool IsSuccess { get; }
        public T Value { get; }
        public string Error { get; }
        
        private Result(bool success, T value, string error)
        {
            IsSuccess = success;
            Value = value;
            Error = error;
        }
        
        public static Result<T> Success(T value) => new Result<T>(true, value, null);
        public static Result<T> Failure(string error) => new Result<T>(false, default, error);
        
        // 轉(zhuǎn)換方法
        public Result<TNew> Map<TNew>(Func<T, TNew> mapper) =>
            IsSuccess ? Success(mapper(Value)) : Failure<TNew>(Error);
            
        // 綁定方法
        public Result<TNew> Bind<TNew>(Func<T, Result<TNew>> binder) =>
            IsSuccess ? binder(Value) : Failure<TNew>(Error);
    }
    
    // 使用示例
    public static Result<int> ParseInt(string input)
    {
        if (int.TryParse(input, out int value))
        {
            return Result<int>.Success(value);
        }
        return Result<int>.Failure("無效的整數(shù)格式");
    }
    
    public static Result<decimal> CalculateTax(int amount)
    {
        if (amount < 0)
        {
            return Result<decimal>.Failure("金額不能為負(fù)數(shù)");
        }
        return Result<decimal>.Success(amount * 0.1m);
    }
    
    // 鏈?zhǔn)秸{(diào)用
    public static void Demo()
    {
        // 傳統(tǒng)方式 (嵌套)
        if (int.TryParse("100", out var amount))
        {
            decimal tax = amount * 0.1m;
            Console.WriteLine($"稅: {tax}");
        }
        
        // Result 模式 (鏈?zhǔn)?
        var result = ParseInt("100")
            .Bind(amount => CalculateTax(amount));
            
        if (result.IsSuccess)
        {
            Console.WriteLine($"稅: {result.Value}");
        }
        else
        {
            Console.WriteLine($"錯(cuò)誤: {result.Error}");
        }
        
        // 更復(fù)雜的鏈
        ParseInt("150")
            .Map(amount => amount * 2)
            .Bind(doubled => CalculateTax(doubled))
            .Match(
                success: tax => Console.WriteLine($"最終稅: {tax}"),
                failure: error => Console.WriteLine($"處理失敗: {error}")
            );
    }
    
    // 擴(kuò)展方法增強(qiáng)
    public static class ResultExtensions
    {
        public static void Match<T>(this Result<T> result, Action<T> success, Action<string> failure)
        {
            if (result.IsSuccess)
                success(result.Value);
            else
                failure(result.Error);
        }
        
        public static T GetOrThrow<T>(this Result<T> result)
        {
            if (result.IsSuccess)
                return result.Value;
            throw new InvalidOperationException(result.Error);
        }
    }
}