FBro浏览器Cookie管理完全指南

概述

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

核心概念

Cookie管理器类型

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

Cookie数据结构

csharp

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管理器

csharp

/// <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访问回调类

csharp

/// <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

csharp

/// <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

csharp

/// <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

csharp

/// <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

csharp

/// <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

csharp

/// <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

csharp

/// <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. 刷新和同步

csharp

/// <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. 网站登录状态管理

csharp

/// <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备份和恢复

csharp

/// <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：网站自动登录

csharp

/// <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同步

csharp

/// <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备份恢复

csharp

/// <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自动化和数据管理需求。

FBro浏览器Cookie管理完全指南 ​

概述 ​

核心概念 ​

Cookie管理器类型 ​

Cookie数据结构 ​

基础用法 ​

1. 获取Cookie管理器 ​

2. Cookie访问回调类 ​

Cookie查询操作 ​

1. 查询指定URL的Cookie ​

2. 查询全部Cookie ​

Cookie设置操作 ​

1. 设置单个Cookie ​

2. 批量设置Cookie ​

Cookie删除操作 ​

1. 删除Cookie ​

2. 条件删除Cookie ​

Cookie维护操作 ​

1. 刷新和同步 ​

实际应用场景 ​

1. 网站登录状态管理 ​

2. Cookie备份和恢复 ​

使用场景示例 ​

场景1：网站自动登录 ​

场景2：跨浏览器Cookie同步 ​

场景3：Cookie备份恢复 ​

最佳实践和注意事项 ​

1. 性能优化 ​

2. 安全考虑 ​

3. 错误处理 ​

4. 内存管理 ​

5. 跨域名管理 ​

FBro浏览器Cookie管理完全指南

概述

核心概念

Cookie管理器类型

Cookie数据结构

基础用法

1. 获取Cookie管理器

2. Cookie访问回调类

Cookie查询操作

1. 查询指定URL的Cookie

2. 查询全部Cookie

Cookie设置操作

1. 设置单个Cookie

2. 批量设置Cookie

Cookie删除操作

1. 删除Cookie

2. 条件删除Cookie

Cookie维护操作

1. 刷新和同步

实际应用场景

1. 网站登录状态管理

2. Cookie备份和恢复

使用场景示例

场景1：网站自动登录

场景2：跨浏览器Cookie同步

场景3：Cookie备份恢复

最佳实践和注意事项

1. 性能优化

2. 安全考虑

3. 错误处理

4. 内存管理

5. 跨域名管理