FBro浏览器Cookie管理完全指南

概述

FBro浏览器提供了强大的Cookie管理功能，支持全局Cookie和独立环境Cookie的完整操作。通过FBroSharpCookieManager类，您可以实现Cookie的增删改查、批量操作、域名过滤等高级功能。

核心概念

Cookie管理器类型

1. 全局Cookie管理器：管理所有浏览器实例共享的Cookie
2. 独立环境Cookie管理器：管理特定浏览器实例的独立Cookie

Cookie数据结构

public class FBroSharpCookieData
{
    public string name { get; set; }              // Cookie名称
    public string value { get; set; }             // Cookie值
    public string domain { get; set; }            // 域名（如：.baidu.com）
    public string path { get; set; }              // 路径（如：/）
    public bool httponly { get; set; }            // 是否仅HTTP访问
    public bool secure { get; set; }              // 是否仅HTTPS传输
    public bool has_expires { get; set; }         // 是否设置过期时间
    public DateTime expires_time { get; set; }    // 过期时间
    public DateTime last_access_time { get; set; }// 最后访问时间
}

基础用法

1. 获取Cookie管理器

/// <summary>
/// 获取全局Cookie管理器
/// </summary>
/// <returns>全局Cookie管理器实例</returns>
public static FBroSharpCookieManager GetGlobalCookieManager()
{
    try
    {
        var manager = FBroSharpCookieManager.GetGlobalManager();
        Console.WriteLine("全局Cookie管理器获取成功");
        return manager;
    }
    catch (Exception ex)
    {
        Console.WriteLine($"获取全局Cookie管理器失败: {ex.Message}");
        return null;
    }
}

/// <summary>
/// 获取独立环境Cookie管理器
/// </summary>
/// <param name="browser">浏览器实例</param>
/// <returns>独立环境Cookie管理器实例</returns>
public static FBroSharpCookieManager GetIndependentCookieManager(IFBroSharpBrowser browser)
{
    try
    {
        if (browser != null && browser.IsValid)
        {
            var manager = (FBroSharpCookieManager)browser.GetRequestContext().GetCookieManager();
            Console.WriteLine("独立环境Cookie管理器获取成功");
            return manager;
        }
        else
        {
            Console.WriteLine("浏览器实例无效，无法获取Cookie管理器");
            return null;
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"获取独立环境Cookie管理器失败: {ex.Message}");
        return null;
    }
}

2. Cookie访问回调类

/// <summary>
/// Cookie访问回调类 - 基础版本
/// </summary>
public class FBroSharpCookieVisitorBasic : FBroSharpCookieVisitor
{
    public List<FBroSharpCookieData> Cookies { get; private set; }

    public FBroSharpCookieVisitorBasic()
    {
        Cookies = new List<FBroSharpCookieData>();
    }

    public override bool Visit(FBroSharpCookieData cookie, int count, int total, out bool deleteCookie)
    {
        // 收集Cookie数据
        Cookies.Add(cookie);
        
        Console.WriteLine($"[{count}/{total}] {cookie.name}={cookie.value} (域名: {cookie.domain})");
        
        // 不删除Cookie
        deleteCookie = false;
        
        // 继续访问下一个Cookie
        return true;
    }
}

/// <summary>
/// Cookie访问回调类 - 高级版本
/// </summary>
public class FBroSharpCookieVisitorAdvanced : FBroSharpCookieVisitor
{
    public List<FBroSharpCookieData> Cookies { get; private set; }
    public Dictionary<string, List<FBroSharpCookieData>> CookiesByDomain { get; private set; }
    public int TotalCount { get; private set; }
    public DateTime ScanStartTime { get; private set; }

    public FBroSharpCookieVisitorAdvanced()
    {
        Cookies = new List<FBroSharpCookieData>();
        CookiesByDomain = new Dictionary<string, List<FBroSharpCookieData>>();
        ScanStartTime = DateTime.Now;
    }

    public override bool Visit(FBroSharpCookieData cookie, int count, int total, out bool deleteCookie)
    {
        TotalCount = total;
        
        // 收集Cookie数据
        Cookies.Add(cookie);
        
        // 按域名分组
        if (!CookiesByDomain.ContainsKey(cookie.domain))
        {
            CookiesByDomain[cookie.domain] = new List<FBroSharpCookieData>();
        }
        CookiesByDomain[cookie.domain].Add(cookie);
        
        // 详细信息输出
        Console.WriteLine($"Cookie详情 [{count}/{total}]:");
        Console.WriteLine($"  名称: {cookie.name}");
        Console.WriteLine($"  值: {cookie.value}");
        Console.WriteLine($"  域名: {cookie.domain}");
        Console.WriteLine($"  路径: {cookie.path}");
        Console.WriteLine($"  仅HTTP: {cookie.httponly}");
        Console.WriteLine($"  仅HTTPS: {cookie.secure}");
        Console.WriteLine($"  过期时间: {(cookie.has_expires ? cookie.expires_time.ToString() : "会话Cookie")}");
        Console.WriteLine($"  最后访问: {cookie.last_access_time}");
        Console.WriteLine();
        
        // 不删除Cookie
        deleteCookie = false;
        
        // 继续访问
        return true;
    }

    /// <summary>
    /// 获取扫描统计信息
    /// </summary>
    public void PrintScanSummary()
    {
        var scanDuration = DateTime.Now - ScanStartTime;
        Console.WriteLine("=== Cookie扫描统计 ===");
        Console.WriteLine($"总Cookie数量: {Cookies.Count}");
        Console.WriteLine($"涉及域名数量: {CookiesByDomain.Count}");
        Console.WriteLine($"扫描耗时: {scanDuration.TotalMilliseconds:F2}ms");
        Console.WriteLine($"域名分布:");
        
        foreach (var domain in CookiesByDomain.OrderByDescending(x => x.Value.Count))
        {
            Console.WriteLine($"  {domain.Key}: {domain.Value.Count} 个Cookie");
        }
    }
}

Cookie查询操作

1. 查询指定URL的Cookie

/// <summary>
/// 获取指定URL的Cookie
/// </summary>
/// <param name="url">目标URL</param>
/// <param name="includeHttpOnly">是否包含HttpOnly Cookie</param>
/// <returns>Cookie列表</returns>
public static List<FBroSharpCookieData> GetCookiesByUrl(string url, bool includeHttpOnly = false)
{
    try
    {
        var manager = FBroSharpCookieManager.GetGlobalManager();
        var callback = new FBroSharpCookieVisitorBasic();
        
        Console.WriteLine($"开始获取URL [{url}] 的Cookie...");
        manager.VisitUrlCookies(url, includeHttpOnly, callback);
        
        Console.WriteLine($"获取到 {callback.Cookies.Count} 个Cookie");
        return callback.Cookies;
    }
    catch (Exception ex)
    {
        Console.WriteLine($"获取URL Cookie失败: {ex.Message}");
        return new List<FBroSharpCookieData>();
    }
}

/// <summary>
/// 获取指定域名的所有Cookie
/// </summary>
/// <param name="domain">域名（如：.baidu.com）</param>
/// <returns>Cookie列表</returns>
public static List<FBroSharpCookieData> GetCookiesByDomain(string domain)
{
    try
    {
        var manager = FBroSharpCookieManager.GetGlobalManager();
        var callback = new FBroSharpCookieVisitorAdvanced();
        
        Console.WriteLine($"开始扫描域名 [{domain}] 的Cookie...");
        manager.VisitAllCookies(callback);
        
        // 过滤指定域名的Cookie
        var domainCookies = callback.Cookies
            .Where(c => c.domain.Equals(domain, StringComparison.OrdinalIgnoreCase) || 
                       c.domain.EndsWith(domain, StringComparison.OrdinalIgnoreCase))
            .ToList();
        
        Console.WriteLine($"域名 [{domain}] 共找到 {domainCookies.Count} 个Cookie");
        return domainCookies;
    }
    catch (Exception ex)
    {
        Console.WriteLine($"获取域名Cookie失败: {ex.Message}");
        return new List<FBroSharpCookieData>();
    }
}

2. 查询全部Cookie

/// <summary>
/// 获取全部Cookie
/// </summary>
/// <param name="useAdvancedCallback">是否使用高级回调（包含详细信息）</param>
/// <returns>Cookie列表</returns>
public static List<FBroSharpCookieData> GetAllCookies(bool useAdvancedCallback = false)
{
    try
    {
        var manager = FBroSharpCookieManager.GetGlobalManager();
        
        if (useAdvancedCallback)
        {
            var advancedCallback = new FBroSharpCookieVisitorAdvanced();
            Console.WriteLine("开始扫描全部Cookie（高级模式）...");
            manager.VisitAllCookies(advancedCallback);
            advancedCallback.PrintScanSummary();
            return advancedCallback.Cookies;
        }
        else
        {
            var basicCallback = new FBroSharpCookieVisitorBasic();
            Console.WriteLine("开始扫描全部Cookie（基础模式）...");
            manager.VisitAllCookies(basicCallback);
            Console.WriteLine($"扫描完成，共获取 {basicCallback.Cookies.Count} 个Cookie");
            return basicCallback.Cookies;
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"获取全部Cookie失败: {ex.Message}");
        return new List<FBroSharpCookieData>();
    }
}

/// <summary>
/// 查找特定名称的Cookie
/// </summary>
/// <param name="cookieName">Cookie名称</param>
/// <param name="domain">可选的域名过滤</param>
/// <returns>匹配的Cookie列表</returns>
public static List<FBroSharpCookieData> FindCookiesByName(string cookieName, string domain = null)
{
    try
    {
        var allCookies = GetAllCookies(false);
        var matchedCookies = allCookies.Where(c => c.name.Equals(cookieName, StringComparison.OrdinalIgnoreCase));
        
        if (!string.IsNullOrEmpty(domain))
        {
            matchedCookies = matchedCookies.Where(c => 
                c.domain.Equals(domain, StringComparison.OrdinalIgnoreCase) ||
                c.domain.EndsWith(domain, StringComparison.OrdinalIgnoreCase));
        }
        
        var result = matchedCookies.ToList();
        Console.WriteLine($"找到 {result.Count} 个名称为 '{cookieName}' 的Cookie");
        return result;
    }
    catch (Exception ex)
    {
        Console.WriteLine($"查找Cookie失败: {ex.Message}");
        return new List<FBroSharpCookieData>();
    }
}

Cookie设置操作

1. 设置单个Cookie

/// <summary>
/// 设置Cookie
/// </summary>
/// <param name="url">目标URL</param>
/// <param name="name">Cookie名称</param>
/// <param name="value">Cookie值</param>
/// <param name="domain">域名</param>
/// <param name="path">路径</param>
/// <param name="expiresHours">过期小时数（0表示会话Cookie）</param>
/// <param name="httpOnly">是否仅HTTP访问</param>
/// <param name="secure">是否仅HTTPS传输</param>
/// <returns>是否设置成功</returns>
public static bool SetCookie(string url, string name, string value, string domain = null, 
    string path = "/", int expiresHours = 0, bool httpOnly = false, bool secure = false)
{
    try
    {
        var manager = FBroSharpCookieManager.GetGlobalManager();
        
        var cookieData = new FBroSharpCookieData
        {
            name = name,
            value = value,
            domain = domain ?? ExtractDomainFromUrl(url),
            path = path,
            httponly = httpOnly,
            secure = secure,
            has_expires = expiresHours > 0,
            expires_time = expiresHours > 0 ? DateTime.Now.AddHours(expiresHours) : DateTime.MinValue,
            last_access_time = DateTime.Now
        };
        
        manager.SetCookie(url, cookieData);
        Console.WriteLine($"Cookie设置成功: {name}={value} (域名: {cookieData.domain})");
        return true;
    }
    catch (Exception ex)
    {
        Console.WriteLine($"设置Cookie失败: {ex.Message}");
        return false;
    }
}

/// <summary>
/// 从URL提取域名
/// </summary>
/// <param name="url">URL地址</param>
/// <returns>域名</returns>
private static string ExtractDomainFromUrl(string url)
{
    try
    {
        var uri = new Uri(url);
        return $".{uri.Host}";
    }
    catch
    {
        return null;
    }
}

/// <summary>
/// 设置会话Cookie
/// </summary>
/// <param name="url">目标URL</param>
/// <param name="name">Cookie名称</param>
/// <param name="value">Cookie值</param>
/// <returns>是否设置成功</returns>
public static bool SetSessionCookie(string url, string name, string value)
{
    return SetCookie(url, name, value, expiresHours: 0);
}

/// <summary>
/// 设置持久Cookie
/// </summary>
/// <param name="url">目标URL</param>
/// <param name="name">Cookie名称</param>
/// <param name="value">Cookie值</param>
/// <param name="expiresHours">过期小时数</param>
/// <returns>是否设置成功</returns>
public static bool SetPersistentCookie(string url, string name, string value, int expiresHours = 24)
{
    return SetCookie(url, name, value, expiresHours: expiresHours);
}

2. 批量设置Cookie

/// <summary>
/// 批量设置Cookie
/// </summary>
/// <param name="url">目标URL</param>
/// <param name="cookies">Cookie字典</param>
/// <param name="domain">可选域名</param>
/// <param name="expiresHours">过期小时数</param>
/// <returns>成功设置的数量</returns>
public static int SetMultipleCookies(string url, Dictionary<string, string> cookies, 
    string domain = null, int expiresHours = 24)
{
    int successCount = 0;
    
    try
    {
        var manager = FBroSharpCookieManager.GetGlobalManager();
        var targetDomain = domain ?? ExtractDomainFromUrl(url);
        
        Console.WriteLine($"开始批量设置 {cookies.Count} 个Cookie...");
        
        foreach (var cookie in cookies)
        {
            try
            {
                var cookieData = new FBroSharpCookieData
                {
                    name = cookie.Key,
                    value = cookie.Value,
                    domain = targetDomain,
                    path = "/",
                    httponly = false,
                    secure = url.StartsWith("https://", StringComparison.OrdinalIgnoreCase),
                    has_expires = expiresHours > 0,
                    expires_time = expiresHours > 0 ? DateTime.Now.AddHours(expiresHours) : DateTime.MinValue,
                    last_access_time = DateTime.Now
                };
                
                manager.SetCookie(url, cookieData);
                successCount++;
                Console.WriteLine($"  设置成功: {cookie.Key}={cookie.Value}");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"  设置失败: {cookie.Key} - {ex.Message}");
            }
        }
        
        Console.WriteLine($"批量设置完成，成功: {successCount}/{cookies.Count}");
        return successCount;
    }
    catch (Exception ex)
    {
        Console.WriteLine($"批量设置Cookie失败: {ex.Message}");
        return successCount;
    }
}

/// <summary>
/// 从Cookie字符串设置Cookie
/// </summary>
/// <param name="url">目标URL</param>
/// <param name="cookieString">Cookie字符串（如：name1=value1; name2=value2）</param>
/// <returns>成功设置的数量</returns>
public static int SetCookiesFromString(string url, string cookieString)
{
    try
    {
        var cookies = new Dictionary<string, string>();
        var pairs = cookieString.Split(';');
        
        foreach (var pair in pairs)
        {
            var trimmedPair = pair.Trim();
            var equalIndex = trimmedPair.IndexOf('=');
            
            if (equalIndex > 0)
            {
                var name = trimmedPair.Substring(0, equalIndex).Trim();
                var value = trimmedPair.Substring(equalIndex + 1).Trim();
                cookies[name] = value;
            }
        }
        
        return SetMultipleCookies(url, cookies);
    }
    catch (Exception ex)
    {
        Console.WriteLine($"从字符串设置Cookie失败: {ex.Message}");
        return 0;
    }
}

Cookie删除操作

1. 删除Cookie

/// <summary>
/// 删除所有Cookie
/// </summary>
/// <returns>是否删除成功</returns>
public static bool DeleteAllCookies()
{
    try
    {
        var manager = FBroSharpCookieManager.GetGlobalManager();
        manager.DeleteCookies("", "");
        Console.WriteLine("所有Cookie已删除");
        return true;
    }
    catch (Exception ex)
    {
        Console.WriteLine($"删除所有Cookie失败: {ex.Message}");
        return false;
    }
}

/// <summary>
/// 删除指定域名的Cookie
/// </summary>
/// <param name="domain">域名</param>
/// <returns>是否删除成功</returns>
public static bool DeleteCookiesByDomain(string domain)
{
    try
    {
        var manager = FBroSharpCookieManager.GetGlobalManager();
        manager.DeleteCookies(domain, "");
        Console.WriteLine($"域名 [{domain}] 的Cookie已删除");
        return true;
    }
    catch (Exception ex)
    {
        Console.WriteLine($"删除域名Cookie失败: {ex.Message}");
        return false;
    }
}

/// <summary>
/// 删除指定名称的Cookie
/// </summary>
/// <param name="domain">域名</param>
/// <param name="cookieName">Cookie名称</param>
/// <returns>是否删除成功</returns>
public static bool DeleteSpecificCookie(string domain, string cookieName)
{
    try
    {
        var manager = FBroSharpCookieManager.GetGlobalManager();
        manager.DeleteCookies(domain, cookieName);
        Console.WriteLine($"Cookie [{cookieName}] 在域名 [{domain}] 下已删除");
        return true;
    }
    catch (Exception ex)
    {
        Console.WriteLine($"删除指定Cookie失败: {ex.Message}");
        return false;
    }
}

/// <summary>
/// 清理过期Cookie
/// </summary>
/// <returns>清理的Cookie数量</returns>
public static int CleanupExpiredCookies()
{
    try
    {
        var allCookies = GetAllCookies(false);
        var expiredCookies = allCookies.Where(c => 
            c.has_expires && c.expires_time < DateTime.Now).ToList();
        
        int cleanedCount = 0;
        foreach (var cookie in expiredCookies)
        {
            if (DeleteSpecificCookie(cookie.domain, cookie.name))
            {
                cleanedCount++;
            }
        }
        
        Console.WriteLine($"清理过期Cookie完成，共清理 {cleanedCount} 个");
        return cleanedCount;
    }
    catch (Exception ex)
    {
        Console.WriteLine($"清理过期Cookie失败: {ex.Message}");
        return 0;
    }
}

2. 条件删除Cookie

/// <summary>
/// 根据条件删除Cookie的回调类
/// </summary>
public class FBroSharpCookieVisitorWithDelete : FBroSharpCookieVisitor
{
    private readonly Func<FBroSharpCookieData, bool> _deleteCondition;
    public int DeletedCount { get; private set; }

    public FBroSharpCookieVisitorWithDelete(Func<FBroSharpCookieData, bool> deleteCondition)
    {
        _deleteCondition = deleteCondition;
        DeletedCount = 0;
    }

    public override bool Visit(FBroSharpCookieData cookie, int count, int total, out bool deleteCookie)
    {
        deleteCookie = _deleteCondition(cookie);
        
        if (deleteCookie)
        {
            DeletedCount++;
            Console.WriteLine($"删除Cookie: {cookie.name}={cookie.value} (域名: {cookie.domain})");
        }
        
        return true; // 继续访问
    }
}

/// <summary>
/// 根据条件删除Cookie
/// </summary>
/// <param name="deleteCondition">删除条件</param>
/// <returns>删除的Cookie数量</returns>
public static int DeleteCookiesByCondition(Func<FBroSharpCookieData, bool> deleteCondition)
{
    try
    {
        var manager = FBroSharpCookieManager.GetGlobalManager();
        var callback = new FBroSharpCookieVisitorWithDelete(deleteCondition);
        
        Console.WriteLine("开始根据条件删除Cookie...");
        manager.VisitAllCookies(callback);
        
        Console.WriteLine($"条件删除完成，共删除 {callback.DeletedCount} 个Cookie");
        return callback.DeletedCount;
    }
    catch (Exception ex)
    {
        Console.WriteLine($"条件删除Cookie失败: {ex.Message}");
        return 0;
    }
}

/// <summary>
/// 删除包含指定关键词的Cookie
/// </summary>
/// <param name="keyword">关键词</param>
/// <returns>删除的Cookie数量</returns>
public static int DeleteCookiesContainingKeyword(string keyword)
{
    return DeleteCookiesByCondition(cookie => 
        cookie.name.Contains(keyword, StringComparison.OrdinalIgnoreCase) ||
        cookie.value.Contains(keyword, StringComparison.OrdinalIgnoreCase));
}

Cookie维护操作

1. 刷新和同步

/// <summary>
/// 刷新Cookie存储
/// </summary>
/// <returns>是否刷新成功</returns>
public static bool FlushCookieStore()
{
    try
    {
        var manager = FBroSharpCookieManager.GetGlobalManager();
        manager.FlushStore();
        Console.WriteLine("Cookie存储已刷新");
        return true;
    }
    catch (Exception ex)
    {
        Console.WriteLine($"刷新Cookie存储失败: {ex.Message}");
        return false;
    }
}

/// <summary>
/// 同步Cookie到独立环境
/// </summary>
/// <param name="sourceBrowser">源浏览器</param>
/// <param name="targetBrowser">目标浏览器</param>
/// <param name="domain">可选的域名过滤</param>
/// <returns>同步的Cookie数量</returns>
public static int SyncCookiesBetweenBrowsers(IFBroSharpBrowser sourceBrowser, 
    IFBroSharpBrowser targetBrowser, string domain = null)
{
    try
    {
        var sourceManager = GetIndependentCookieManager(sourceBrowser);
        var targetManager = GetIndependentCookieManager(targetBrowser);
        
        if (sourceManager == null || targetManager == null)
        {
            Console.WriteLine("无法获取Cookie管理器，同步失败");
            return 0;
        }
        
        var sourceCallback = new FBroSharpCookieVisitorBasic();
        sourceManager.VisitAllCookies(sourceCallback);
        
        var cookiesToSync = sourceCallback.Cookies;
        if (!string.IsNullOrEmpty(domain))
        {
            cookiesToSync = cookiesToSync.Where(c => 
                c.domain.Contains(domain, StringComparison.OrdinalIgnoreCase)).ToList();
        }
        
        int syncedCount = 0;
        foreach (var cookie in cookiesToSync)
        {
            try
            {
                var url = $"http{(cookie.secure ? "s" : "")}://{cookie.domain.TrimStart('.')}{cookie.path}";
                targetManager.SetCookie(url, cookie);
                syncedCount++;
                Console.WriteLine($"同步Cookie: {cookie.name} -> {cookie.domain}");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"同步Cookie失败: {cookie.name} - {ex.Message}");
            }
        }
        
        Console.WriteLine($"Cookie同步完成，成功同步 {syncedCount} 个");
        return syncedCount;
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Cookie同步失败: {ex.Message}");
        return 0;
    }
}

实际应用场景

1. 网站登录状态管理

/// <summary>
/// 网站登录Cookie管理器
/// </summary>
public class WebsiteLoginManager
{
    private readonly string _domain;
    private readonly string _baseUrl;

    public WebsiteLoginManager(string domain, string baseUrl)
    {
        _domain = domain;
        _baseUrl = baseUrl;
    }

    /// <summary>
    /// 保存登录Cookie
    /// </summary>
    /// <param name="loginData">登录数据字典</param>
    /// <returns>是否保存成功</returns>
    public bool SaveLoginCookies(Dictionary<string, string> loginData)
    {
        try
        {
            Console.WriteLine($"保存 {_domain} 的登录Cookie...");
            
            // 设置较长的过期时间（30天）
            var successCount = SetMultipleCookies(_baseUrl, loginData, _domain, 30 * 24);
            
            if (successCount == loginData.Count)
            {
                Console.WriteLine("登录Cookie保存成功");
                FlushCookieStore(); // 立即刷新存储
                return true;
            }
            else
            {
                Console.WriteLine($"登录Cookie部分保存失败: {successCount}/{loginData.Count}");
                return false;
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"保存登录Cookie失败: {ex.Message}");
            return false;
        }
    }

    /// <summary>
    /// 检查登录状态
    /// </summary>
    /// <param name="requiredCookies">必需的Cookie名称列表</param>
    /// <returns>是否已登录</returns>
    public bool CheckLoginStatus(List<string> requiredCookies)
    {
        try
        {
            var domainCookies = GetCookiesByDomain(_domain);
            var existingCookieNames = domainCookies.Select(c => c.name).ToHashSet();
            
            foreach (var requiredCookie in requiredCookies)
            {
                if (!existingCookieNames.Contains(requiredCookie))
                {
                    Console.WriteLine($"缺少必需的Cookie: {requiredCookie}");
                    return false;
                }
            }
            
            Console.WriteLine($"{_domain} 登录状态检查通过");
            return true;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"检查登录状态失败: {ex.Message}");
            return false;
        }
    }

    /// <summary>
    /// 清除登录状态
    /// </summary>
    /// <returns>是否清除成功</returns>
    public bool ClearLoginStatus()
    {
        return DeleteCookiesByDomain(_domain);
    }
}

2. Cookie备份和恢复

/// <summary>
/// Cookie备份和恢复管理器
/// </summary>
public class CookieBackupManager
{
    /// <summary>
    /// 备份Cookie到文件
    /// </summary>
    /// <param name="filePath">备份文件路径</param>
    /// <param name="domain">可选的域名过滤</param>
    /// <returns>是否备份成功</returns>
    public static bool BackupCookiesToFile(string filePath, string domain = null)
    {
        try
        {
            var cookies = string.IsNullOrEmpty(domain) ? 
                GetAllCookies(false) : GetCookiesByDomain(domain);
            
            var backupData = new
            {
                BackupTime = DateTime.Now,
                Domain = domain ?? "All",
                Count = cookies.Count,
                Cookies = cookies.Select(c => new
                {
                    c.name,
                    c.value,
                    c.domain,
                    c.path,
                    c.httponly,
                    c.secure,
                    c.has_expires,
                    expires_time = c.has_expires ? c.expires_time : (DateTime?)null,
                    c.last_access_time
                }).ToList()
            };
            
            var json = System.Text.Json.JsonSerializer.Serialize(backupData, new JsonSerializerOptions 
            { 
                WriteIndented = true 
            });
            
            File.WriteAllText(filePath, json);
            Console.WriteLine($"Cookie备份完成: {cookies.Count} 个Cookie -> {filePath}");
            return true;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"备份Cookie失败: {ex.Message}");
            return false;
        }
    }

    /// <summary>
    /// 从文件恢复Cookie
    /// </summary>
    /// <param name="filePath">备份文件路径</param>
    /// <param name="overwrite">是否覆盖现有Cookie</param>
    /// <returns>恢复的Cookie数量</returns>
    public static int RestoreCookiesFromFile(string filePath, bool overwrite = false)
    {
        try
        {
            if (!File.Exists(filePath))
            {
                Console.WriteLine($"备份文件不存在: {filePath}");
                return 0;
            }
            
            var json = File.ReadAllText(filePath);
            var backupData = System.Text.Json.JsonSerializer.Deserialize<JsonElement>(json);
            
            var cookies = backupData.GetProperty("Cookies");
            int restoredCount = 0;
            
            Console.WriteLine("开始恢复Cookie...");
            
            foreach (var cookieElement in cookies.EnumerateArray())
            {
                try
                {
                    var domain = cookieElement.GetProperty("domain").GetString();
                    var name = cookieElement.GetProperty("name").GetString();
                    var value = cookieElement.GetProperty("value").GetString();
                    var path = cookieElement.GetProperty("path").GetString();
                    var httponly = cookieElement.GetProperty("httponly").GetBoolean();
                    var secure = cookieElement.GetProperty("secure").GetBoolean();
                    var has_expires = cookieElement.GetProperty("has_expires").GetBoolean();
                    
                    var url = $"http{(secure ? "s" : "")}://{domain.TrimStart('.')}{path}";
                    
                    if (!overwrite)
                    {
                        // 检查是否已存在
                        var existing = FindCookiesByName(name, domain);
                        if (existing.Count > 0)
                        {
                            Console.WriteLine($"跳过已存在的Cookie: {name}");
                            continue;
                        }
                    }
                    
                    var cookieData = new FBroSharpCookieData
                    {
                        name = name,
                        value = value,
                        domain = domain,
                        path = path,
                        httponly = httponly,
                        secure = secure,
                        has_expires = has_expires,
                        expires_time = has_expires && cookieElement.TryGetProperty("expires_time", out var expiresElement) && 
                                      expiresElement.ValueKind != JsonValueKind.Null ? 
                                      expiresElement.GetDateTime() : DateTime.MinValue,
                        last_access_time = DateTime.Now
                    };
                    
                    var manager = FBroSharpCookieManager.GetGlobalManager();
                    manager.SetCookie(url, cookieData);
                    restoredCount++;
                    Console.WriteLine($"恢复Cookie: {name} -> {domain}");
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"恢复单个Cookie失败: {ex.Message}");
                }
            }
            
            FlushCookieStore();
            Console.WriteLine($"Cookie恢复完成，成功恢复 {restoredCount} 个");
            return restoredCount;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"恢复Cookie失败: {ex.Message}");
            return 0;
        }
    }
}

使用场景示例

场景1：网站自动登录

/// <summary>
/// 网站自动登录示例
/// </summary>
public void AutoLoginExample()
{
    var loginManager = new WebsiteLoginManager(".example.com", "https://www.example.com");
    
    // 模拟登录后获得的Cookie
    var loginCookies = new Dictionary<string, string>
    {
        { "session_id", "abc123xyz789" },
        { "user_token", "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..." },
        { "remember_me", "true" },
        { "user_preferences", "theme=dark&lang=zh" }
    };
    
    // 保存登录Cookie
    if (loginManager.SaveLoginCookies(loginCookies))
    {
        Console.WriteLine("登录状态已保存");
        
        // 检查登录状态
        var requiredCookies = new List<string> { "session_id", "user_token" };
        if (loginManager.CheckLoginStatus(requiredCookies))
        {
            Console.WriteLine("自动登录准备就绪");
        }
    }
}

场景2：跨浏览器Cookie同步

/// <summary>
/// 跨浏览器Cookie同步示例
/// </summary>
public void CrossBrowserSyncExample()
{
    // 假设有两个浏览器实例
    var browser1 = FBroSharp.FBroSharpBrowserListControl.GetBrowserFromFlag("浏览器1");
    var browser2 = FBroSharp.FBroSharpBrowserListControl.GetBrowserFromFlag("浏览器2");
    
    // 同步特定域名的Cookie
    var syncedCount = SyncCookiesBetweenBrowsers(browser1, browser2, ".taobao.com");
    Console.WriteLine($"已同步 {syncedCount} 个淘宝Cookie到浏览器2");
    
    // 验证同步结果
    var browser2Manager = GetIndependentCookieManager(browser2);
    var browser2Callback = new FBroSharpCookieVisitorBasic();
    browser2Manager?.VisitAllCookies(browser2Callback);
    
    var taobaoeCookies = browser2Callback.Cookies
        .Where(c => c.domain.Contains("taobao.com")).ToList();
    Console.WriteLine($"浏览器2现在有 {taobaoeCookies.Count} 个淘宝Cookie");
}

场景3：Cookie备份恢复

/// <summary>
/// Cookie备份恢复示例
/// </summary>
public void CookieBackupRestoreExample()
{
    var backupPath = @"C:\Backup\cookies_backup.json";
    
    // 备份所有Cookie
    if (CookieBackupManager.BackupCookiesToFile(backupPath))
    {
        Console.WriteLine("Cookie备份完成");
        
        // 清除所有Cookie（模拟重置）
        DeleteAllCookies();
        Console.WriteLine("所有Cookie已清除");
        
        // 恢复Cookie
        var restoredCount = CookieBackupManager.RestoreCookiesFromFile(backupPath);
        Console.WriteLine($"已恢复 {restoredCount} 个Cookie");
        
        // 验证恢复结果
        var allCookies = GetAllCookies(false);
        Console.WriteLine($"当前共有 {allCookies.Count} 个Cookie");
    }
}

最佳实践和注意事项

1. 性能优化

• 避免频繁的全量Cookie扫描，使用域名过滤来减少查询范围
• 对于大量Cookie操作，考虑使用批量设置方法
• 及时调用FlushStore()确保Cookie持久化存储

2. 安全考虑

• 谨慎处理包含敏感信息的Cookie值
• 对于重要的Cookie，建议设置httponly和secure标志
• 定期清理过期和不必要的Cookie

3. 错误处理

• 始终使用try-catch包围Cookie操作
• 检查Cookie管理器的有效性
• 验证URL格式的正确性

4. 内存管理

• 对于长期运行的应用，注意Cookie数据的内存占用
• 适当使用回调模式来处理大量Cookie数据
• 避免在内存中长期保存大量Cookie对象

5. 跨域名管理

• 注意Cookie的域名作用范围
• 使用域名前缀点（如.example.com）来设置子域名Cookie
• 理解同站Cookie的安全限制

通过这个完整的Cookie管理指南，您可以在FBro浏览器中实现强大的Cookie管理功能，满足各种Web自动化和数据管理需求。