FlaUI.UIA3避坑指南：微信自动化消息发送中的5个常见错误

FlaUI.UIA3微信自动化实战：从原理到避坑的深度解析

如果你正在用C#和FlaUI.UIA3捣鼓微信自动化，大概率已经踩过不少坑了。微信PC版的UI结构不算复杂，但用自动化工具操作时，各种意想不到的问题会接踵而至——进程附加失败、元素定位不准、消息发送不出去，这些我都经历过。今天这篇文章，我想从一个实际开发者的角度，分享我在微信自动化项目中积累的经验，特别是那些容易掉进去的“坑”，以及如何系统性地解决它们。

微信自动化不是简单的模拟点击，它涉及到Windows UI自动化技术的深入理解、微信客户端UI结构的准确分析，以及健壮的错误处理机制。很多人照着网上的代码抄一遍，运行时却发现完全不是那么回事。这是因为微信的UI结构在不同版本间会有微调，而且自动化操作对时机和状态的依赖非常敏感。

1. 环境搭建与基础配置：避开第一个雷区

开始之前，得先把环境弄对。很多人第一步就栽了跟头——FlaUI的版本选择和引用方式。

1.1 项目配置与依赖管理

我强烈建议不要直接从NuGet安装FlaUI的预编译包，特别是当你需要调试或深入定制时。微信的UI结构比较特殊，某些情况下需要修改FlaUI的源码来适配。直接从GitHub克隆源码，自己编译引用，这样最稳妥。

<!-- 项目文件中的引用示例 -->
<Reference Include="FlaUI.Core">
  <HintPath>..\lib\FlaUI.Core.dll</HintPath>
</Reference>
<Reference Include="FlaUI.UIA3">
  <HintPath>..\lib\FlaUI.UIA3.dll</HintPath>
</Reference>

编译时要注意目标框架版本。微信PC版目前还是基于传统的Win32技术，所以你的项目最好选择.NET Framework 4.6.1或更高版本，确保对Windows API有完整的支持。

注意：如果你遇到“无法加载DLL‘UIAutomationCore.dll’”之类的错误，大概率是系统缺少必要的运行时组件。确保安装了最新版本的.NET Framework运行时，并且系统是Windows 10或更高版本。

1.2 微信进程的可靠附加

附加到微信进程是第一步，但这里就有好几个坑等着你。

using FlaUI.Core;
using FlaUI.Core.AutomationElements;
using FlaUI.UIA3;

// 错误示例：直接获取第一个进程
var processes = Process.GetProcessesByName("WeChat");
if (processes.Length == 0)
{
    Console.WriteLine("微信未启动");
    return;
}

// 这样写有问题：如果用户开了多个微信实例呢？
using var app = Application.Attach(processes[0].Id);

更健壮的做法是让用户选择，或者处理多实例的情况：

public static Application GetWeChatApplication()
{
    var processes = Process.GetProcessesByName("WeChat");
    
    if (processes.Length == 0)
    {
        // 尝试启动微信
        var wechatPath = @"C:\Program Files (x86)\Tencent\WeChat\WeChat.exe";
        if (File.Exists(wechatPath))
        {
            return Application.Launch(wechatPath);
        }
        throw new InvalidOperationException("微信未运行且无法自动启动");
    }
    
    if (processes.Length == 1)
    {
        return Application.Attach(processes[0].Id);
    }
    
    // 多实例处理：让用户选择或者使用特定逻辑
    Console.WriteLine("检测到多个微信实例，请选择：");
    for (int i = 0; i < processes.Length; i++)
    {
        Console.WriteLine($"{i}: PID={processes[i].Id}, 启动时间={processes[i].StartTime}");
    }
    
    // 这里可以添加更复杂的逻辑，比如根据窗口标题选择
    return Application.Attach(processes[0].Id);
}

1.3 自动化实例的创建与管理

创建UIA3Automation实例时，很多人忽略了一个重要细节：一定要使用using语句或者确保正确释放。UI自动化会占用系统资源，不释放的话可能导致内存泄漏。

// 正确做法：使用using确保资源释放
using var automation = new UIA3Automation();
var mainWindow = app.GetMainWindow(automation);

// 或者，如果你需要长时间保持自动化实例
var automation = new UIA3Automation();
try
{
    var mainWindow = app.GetMainWindow(automation);
    // 执行操作...
}
finally
{
    automation.Dispose();
}

2. 微信UI元素定位：精准找到目标控件

微信的UI结构不算复杂，但元素定位的准确性直接决定了自动化脚本的稳定性。我见过太多因为定位不准而失败的案例。

2.1 理解微信的UI层次结构

先用FlaUInspect工具分析微信的UI结构，这是必不可少的一步。微信主窗口的基本结构通常是这样的：

Window (微信主窗口)
├── Pane (左侧导航栏)
│   ├── Button (聊天)
│   ├── Button (通讯录)
│   └── Button (朋友圈)
├── Pane (主内容区)
│   ├── List (会话列表/联系人列表)
│   └── Edit (搜索框)
└── Pane (聊天区域)
    ├── Edit (消息输入框)
    └── Button (发送按钮)

但要注意，不同版本的微信，这个结构可能有细微差别。我建议在代码中加入版本检测逻辑：

public class WeChatUIMapper
{
    private readonly Window _mainWindow;
    
    // 微信版本检测
    public string DetectWeChatVersion()
    {
        var versionInfo = _mainWindow.FindFirstDescendant(
            cf => cf.ByControlType(ControlType.Text).And(cf.ByName.Contains("微信"))
        );
        
        if (versionInfo != null)
        {
            // 从窗口标题或其他地方提取版本信息
            return ExtractVersionFromText(versionInfo.Name);
        }
        return "未知版本";
    }
    
    // 根据版本调整元素定位策略
    public AutomationElement GetSearchBox()
    {
        var version = DetectWeChatVersion();
        
        if (version.StartsWith("3."))
        {
            // 微信3.x版本的搜索框定位方式
            return _mainWindow.FindFirstDescendant(
                cf => cf.ByControlType(ControlType.Edit).And(cf.ByName("搜索"))
            );
        }
        else
        {
            // 较新版本的定位方式
            return _mainWindow.FindFirstDescendant(
                cf => cf.ByControlType(ControlType.Edit).And(
                    cf.ByAutomationId("SearchEditBox")
                )
            );
        }
    }
}

2.2 元素定位的多种策略

不要只依赖一种定位方式。我总结了几种策略，按优先级使用：

定位策略	优点	缺点	适用场景
ByName	最直观，微信很多元素有明确名称	名称可能变化，多语言版本不同	聊天、通讯录、朋友圈等导航按钮
ByAutomationId	最稳定，ID通常不变	微信很多元素没有设置AutomationId	输入框、按钮等标准控件
ByControlType	通用性强	可能匹配到多个元素	需要结合其他条件使用
FindAllDescendants + 条件过滤	最灵活	性能较差	复杂或动态变化的UI
XPath	精准定位	依赖特定结构，易受UI变化影响	已知固定结构的元素

实际代码中，我通常会写一个包装方法，尝试多种方式：

public static AutomationElement FindWeChatElement(
    Window mainWindow, 
    string elementName, 
    ControlType? expectedType = null)
{
    // 策略1：按名称查找
    var element = mainWindow.FindFirstDescendant(cf => cf.ByName(elementName));
    if (element != null && (expectedType == null || element.ControlType == expectedType))
    {
        return element;
    }
    
    // 策略2：按类型和名称组合查找
    if (expectedType != null)
    {
        element = mainWindow.FindFirstDescendant(
            cf => cf.ByControlType(expectedType.Value).And(cf.ByName(elementName))
        );
        if (element != null) return element;
    }
    
    // 策略3：查找所有后代然后过滤
    var allElements = mainWindow.FindAllDescendants();
    element = allElements.FirstOrDefault(e => 
        e.Name == elementName && 
        (expectedType == null || e.ControlType == expectedType)
    );
    
    if (element != null) return element;
    
    // 策略4：使用XPath作为后备方案
    // 这里需要根据实际情况编写XPath
    throw new ElementNotFoundException($"未找到元素: {elementName}");
}

2.3 处理动态加载和延迟渲染

微信的UI元素不是一次性全部加载的，特别是聊天列表、联系人列表这种可能很长的列表。直接查找可能找不到，需要等待。

public static AutomationElement WaitForElement(
    Window mainWindow, 
    Func<AutomationElement> findFunc, 
    int timeoutMs = 5000, 
    int intervalMs = 200)
{
    var startTime = DateTime.Now;
    
    while ((DateTime.Now - startTime).TotalMilliseconds < timeoutMs)
    {
        var element = findFunc();
        if (element != null && element.IsAvailable)
        {
            // 额外检查：元素是否可见且可交互
            if (element.BoundingRectangle.Width > 0 && 
                element.BoundingRectangle.Height > 0)
            {
                return element;
            }
        }
        
        Thread.Sleep(intervalMs);
    }
    
    throw new TimeoutException($"等待元素超时: {timeoutMs}ms");
}

// 使用示例
var chatButton = WaitForElement(
    mainWindow, 
    () => mainWindow.FindFirstDescendant(cf => cf.ByName("聊天"))
);

3. 消息发送流程的完整实现与优化

发送消息看起来简单，但每个环节都可能出问题。我从最简单的发送到文件传输助手开始，逐步构建健壮的发送逻辑。

3.1 基础消息发送流程

先看一个基础的发送流程，这里有很多需要注意的细节：

public class WeChatMessageSender
{
    private readonly Window _mainWindow;
    private readonly UIA3Automation _automation;
    
    public bool SendMessageToContact(string contactName, string message)
    {
        try
        {
            // 1. 确保微信窗口激活
            ActivateWeChatWindow();
            
            // 2. 切换到搜索模式
            SwitchToSearchMode();
            
            // 3. 搜索联系人
            SearchContact(contactName);
            
            // 4. 等待搜索结果并选择
            SelectContactFromResults(contactName);
            
            // 5. 输入消息
            InputMessage(message);
            
            // 6. 发送
            return SendMessage();
        }
        catch (Exception ex)
        {
            LogError($"发送消息失败: {ex.Message}");
            return false;
        }
    }
    
    private void ActivateWeChatWindow()
    {
        // 使用Windows API确保窗口激活
        var handle = new IntPtr(_mainWindow.Properties.NativeWindowHandle);
        if (handle != IntPtr.Zero)
        {
            // 先恢复窗口（如果最小化）
            User32.ShowWindow(handle, User32.SW_RESTORE);
            
            // 激活窗口
            User32.SetForegroundWindow(handle);
            
            // 等待窗口完全激活
            Thread.Sleep(300);
        }
    }
}

3.2 搜索联系人的正确姿势

搜索功能最容易出问题，特别是当微信有大量联系人时：

private void SearchContact(string contactName)
{
    // 查找搜索框
    var searchBox = _mainWindow.FindFirstDescendant(
        cf => cf.ByControlType(ControlType.Edit).And(
            cf.ByName("搜索").Or(cf.ByName("搜索联系人"))
        )
    );
    
    if (searchBox == null)
    {
        // 尝试点击搜索图标
        var searchIcon = _mainWindow.FindFirstDescendant(
            cf => cf.ByControlType(ControlType.Button).And(cf.ByName("搜索"))
        );
        if (searchIcon != null)
        {
            searchIcon.Click();
            Thread.Sleep(500); // 等待搜索框出现
            searchBox = _mainWindow.FindFirstDescendant(
                cf => cf.ByControlType(ControlType.Edit)
            );
        }
    }
    
    if (searchBox == null)
        throw new ElementNotFoundException("找不到搜索框");
    
    // 清空搜索框（重要！）
    searchBox.AsTextBox().Text = "";
    
    // 输入联系人名称
    Keyboard.Type(contactName);
    
    // 等待搜索结果加载
    Thread.Sleep(800); // 这个等待时间很关键
    
    // 按回车确认搜索
    Keyboard.Type(VirtualKeyShort.RETURN);
    
    // 额外等待搜索结果渲染
    Thread.Sleep(1000);
}

提示：搜索后的等待时间需要根据联系人数量调整。如果联系人很多，可能需要更长的等待时间。我通常会在代码中加入动态等待逻辑，检测搜索结果是否已经出现。

3.3 处理搜索结果的选择

搜索结果可能包含多个匹配项，需要准确选择：

private void SelectContactFromResults(string contactName)
{
    // 等待搜索结果容器出现
    var resultsContainer = WaitForElement(
        _mainWindow,
        () => _mainWindow.FindFirstDescendant(
            cf => cf.ByName("搜索结果").Or(cf.ByName("搜索"))
        ),
        timeoutMs: 3000
    );
    
    if (resultsContainer == null)
    {
        // 可能没有单独的搜索结果容器，直接在主窗口查找
        var contactItems = _mainWindow.FindAllDescendants()
            .Where(e => e.ControlType == ControlType.ListItem &&
                       e.Name.Contains(contactName))
            .ToList();
        
        if (contactItems.Count == 0)
            throw new ContactNotFoundException($"未找到联系人: {contactName}");
        
        // 选择第一个匹配的联系人
        contactItems[0].Click();
    }
    else
    {
        // 在搜索结果容器中查找
        var contactItem = resultsContainer.FindFirstDescendant(
            cf => cf.ByControlType(ControlType.ListItem).And(cf.ByName(contactName))
        );
        
        if (contactItem == null)
            throw new ContactNotFoundException($"在搜索结果中未找到联系人: {contactName}");
        
        contactItem.Click();
    }
    
    // 等待聊天界面加载完成
    Thread.Sleep(1000);
}

3.4 消息输入与发送的细节处理

输入消息时，直接设置文本框文本可能不如模拟键盘输入稳定：

private void InputMessage(string message)
{
    // 查找消息输入框
    var messageInput = WaitForElement(
        _mainWindow,
        () => _mainWindow.FindFirstDescendant(
            cf => cf.ByControlType(ControlType.Edit).And(
                cf.ByName("输入").Or(cf.ByAutomationId("ChatInput"))
            )
        ),
        timeoutMs: 2000
    );
    
    if (messageInput == null)
    {
        // 备用方案：查找任何可编辑的文本框
        messageInput = _mainWindow.FindFirstDescendant(
            cf => cf.ByControlType(ControlType.Edit).And(
                cf.ByClassName("Edit").Or(cf.ByAutomationId("Edit"))
            )
        );
    }
    
    if (messageInput == null)
        throw new ElementNotFoundException("找不到消息输入框");
    
    // 点击输入框获取焦点
    messageInput.Click();
    Thread.Sleep(200);
    
    // 清空可能存在的旧内容
    var textBox = messageInput.AsTextBox();
    if (!string.IsNullOrEmpty(textBox.Text))
    {
        // 全选删除
        Keyboard.TypeSimultaneously(VirtualKeyShort.CONTROL, VirtualKeyShort.KEY_A);
        Thread.Sleep(100);
        Keyboard.Type(VirtualKeyShort.DELETE);
        Thread.Sleep(100);
    }
    
    // 输入消息
    if (message.Length > 100)
    {
        // 长文本使用剪贴板，更稳定
        System.Windows.Forms.Clipboard.SetText(message);
        Keyboard.TypeSimultaneously(VirtualKeyShort.CONTROL, VirtualKeyShort.KEY_V);
    }
    else
    {
        // 短文本直接键盘输入
        Keyboard.Type(message);
    }
    
    // 等待输入完成
    Thread.Sleep(300);
}

private bool SendMessage()
{
    // 查找发送按钮
    var sendButton = _mainWindow.FindFirstDescendant(
        cf => cf.ByControlType(ControlType.Button).And(
            cf.ByName("发送").Or(cf.ByName("Send")).Or(cf.ByName("发送(S)"))
        )
    );
    
    if (sendButton == null)
    {
        // 备用方案：按Ctrl+Enter发送
        Keyboard.TypeSimultaneously(VirtualKeyShort.CONTROL, VirtualKeyShort.RETURN);
        return true;
    }
    
    // 检查按钮是否可用
    if (sendButton.IsEnabled)
    {
        sendButton.Click();
        return true;
    }
    
    return false;
}

4. 高级功能与异常处理

基础功能实现后，我们需要考虑更复杂的场景和健壮性。

4.1 批量消息发送的实现

批量发送不是简单的循环，需要考虑速率限制和错误恢复：

public class BatchMessageSender
{
    private readonly WeChatMessageSender _sender;
    private readonly int _delayBetweenMessages;
    
    public BatchMessageSender(int delayMs = 1000)
    {
        _sender = new WeChatMessageSender();
        _delayBetweenMessages = delayMs;
    }
    
    public BatchSendResult SendToMultipleContacts(
        List<string> contacts, 
        string message,
        Action<string, bool> progressCallback = null)
    {
        var result = new BatchSendResult();
        
        foreach (var contact in contacts)
        {
            try
            {
                var success = _sender.SendMessageToContact(contact, message);
                
                result.TotalAttempts++;
                if (success)
                {
                    result.SuccessCount++;
                    progressCallback?.Invoke($"{contact}: 发送成功", true);
                }
                else
                {
                    result.FailedContacts.Add(contact);
                    progressCallback?.Invoke($"{contact}: 发送失败", false);
                }
                
                // 避免发送过快被限制
                Thread.Sleep(_delayBetweenMessages);
                
                // 每发送10条消息，额外休息一下
                if (result.SuccessCount % 10 == 0)
                {
                    Thread.Sleep(3000);
                }
            }
            catch (Exception ex)
            {
                result.FailedContacts.Add(contact);
                result.Errors.Add($"{contact}: {ex.Message}");
                progressCallback?.Invoke($"{contact}: 异常 - {ex.Message}", false);
                
                // 严重错误时暂停
                if (ex is ElementNotFoundException || ex is TimeoutException)
                {
                    Thread.Sleep(5000);
                }
            }
        }
        
        return result;
    }
}

public class BatchSendResult
{
    public int TotalAttempts { get; set; }
    public int SuccessCount { get; set; }
    public List<string> FailedContacts { get; } = new();
    public List<string> Errors { get; } = new();
    
    public double SuccessRate => TotalAttempts > 0 ? 
        (double)SuccessCount / TotalAttempts * 100 : 0;
}

4.2 处理微信的多标签页和弹出窗口

微信有时会有各种弹出窗口（登录验证、新消息提示等），需要处理：

public class WeChatWindowManager
{
    private readonly Application _app;
    private readonly UIA3Automation _automation;
    
    public bool ClosePopupWindows()
    {
        var allWindows = _app.GetAllTopLevelWindows(_automation);
        var closedCount = 0;
        
        foreach (var window in allWindows)
        {
            var title = window.Title;
            
            // 识别并关闭常见的弹出窗口
            if (IsPopupWindow(title))
            {
                try
                {
                    // 查找关闭按钮
                    var closeButton = window.FindFirstDescendant(
                        cf => cf.ByControlType(ControlType.Button).And(
                            cf.ByName("关闭").Or(cf.ByName("取消")).Or(cf.ByName("确定"))
                        )
                    );
                    
                    if (closeButton != null)
                    {
                        closeButton.Click();
                        closedCount++;
                        Thread.Sleep(500);
                    }
                }
                catch
                {
                    // 忽略关闭失败的情况
                }
            }
        }
        
        return closedCount > 0;
    }
    
    private bool IsPopupWindow(string title)
    {
        var popupKeywords = new[]
        {
            "提示", "确认", "警告", "错误", "登录", "验证",
            "安全", "升级", "更新", "网络"
        };
        
        return popupKeywords.Any(keyword => 
            title.Contains(keyword, StringComparison.OrdinalIgnoreCase));
    }
    
    public void EnsureMainWindowActive()
    {
        var mainWindow = _app.GetMainWindow(_automation);
        if (mainWindow != null)
        {
            // 切换到主窗口
            mainWindow.Focus();
            
            // 关闭可能的弹出窗口
            ClosePopupWindows();
            
            // 再次激活主窗口
            mainWindow.Focus();
            Thread.Sleep(300);
        }
    }
}

4.3 监控与日志系统

完善的日志系统对于调试和问题排查至关重要：

public class WeChatAutomationLogger
{
    private readonly string _logFilePath;
    private readonly bool _enableScreenshots;
    
    public WeChatAutomationLogger(string logDir = null, bool enableScreenshots = true)
    {
        _enableScreenshots = enableScreenshots;
        
        if (string.IsNullOrEmpty(logDir))
        {
            logDir = Path.Combine(
                Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
                "WeChatAutomation",
                "Logs"
            );
        }
        
        Directory.CreateDirectory(logDir);
        _logFilePath = Path.Combine(logDir, $"wechat_auto_{DateTime.Now:yyyyMMdd_HHmmss}.log");
    }
    
    public void LogOperation(string operation, bool success, string details = null)
    {
        var logEntry = $"[{DateTime.Now:HH:mm:ss}] {operation} - {(success ? "成功" : "失败")}";
        
        if (!string.IsNullOrEmpty(details))
        {
            logEntry += $" | {details}";
        }
        
        File.AppendAllText(_logFilePath, logEntry + Environment.NewLine);
        Console.WriteLine(logEntry);
        
        // 失败时截图
        if (!success && _enableScreenshots)
        {
            CaptureScreenshot(operation);
        }
    }
    
    private void CaptureScreenshot(string operationName)
    {
        try
        {
            var screenshotDir = Path.Combine(
                Path.GetDirectoryName(_logFilePath),
                "Screenshots"
            );
            Directory.CreateDirectory(screenshotDir);
            
            var screenshotPath = Path.Combine(
                screenshotDir,
                $"{DateTime.Now:yyyyMMdd_HHmmss}_{operationName}.png"
            );
            
            // 使用FlaUI的截图功能
            var mainWindow = GetWeChatMainWindow();
            if (mainWindow != null)
            {
                var screenshot = mainWindow.Capture();
                screenshot.ToFile(screenshotPath);
            }
        }
        catch (Exception ex)
        {
            File.AppendAllText(_logFilePath, 
                $"[{DateTime.Now:HH:mm:ss}] 截图失败: {ex.Message}{Environment.NewLine}");
        }
    }
}

5. 性能优化与最佳实践

当自动化脚本需要长时间运行时，性能优化就变得很重要。

5.1 减少不必要的元素查找

元素查找是性能瓶颈，要尽量减少查找次数：

public class WeChatUICache
{
    private readonly Dictionary<string, AutomationElement> _elementCache = new();
    private readonly Window _mainWindow;
    private DateTime _lastCacheRefresh = DateTime.MinValue;
    
    public AutomationElement GetCachedElement(string elementKey, Func<AutomationElement> findFunc)
    {
        // 缓存有效期：5分钟
        if (_elementCache.ContainsKey(elementKey) && 
            (DateTime.Now - _lastCacheRefresh).TotalMinutes < 5)
        {
            var element = _elementCache[elementKey];
            if (element != null && element.IsAvailable)
            {
                return element;
            }
        }
        
        // 缓存失效或元素不可用，重新查找
        var newElement = findFunc();
        if (newElement != null)
        {
            _elementCache[elementKey] = newElement;
            _lastCacheRefresh = DateTime.Now;
        }
        
        return newElement;
    }
    
    public void InvalidateCache()
    {
        _elementCache.Clear();
        _lastCacheRefresh = DateTime.MinValue;
    }
    
    // 常用元素的缓存访问方法
    public AutomationElement GetSearchBox() => 
        GetCachedElement("SearchBox", () => 
            _mainWindow.FindFirstDescendant(cf => cf.ByName("搜索")));
    
    public AutomationElement GetChatList() => 
        GetCachedElement("ChatList", () => 
            _mainWindow.FindFirstDescendant(cf => cf.ByName("会话")));
}

5.2 异步操作与超时控制

避免脚本卡死，必须设置合理的超时：

public static async Task<AutomationElement> FindElementWithTimeoutAsync(
    Window mainWindow,
    Func<AutomationElement> findFunc,
    int timeoutMs = 5000,
    CancellationToken cancellationToken = default)
{
    var startTime = DateTime.Now;
    
    while (!cancellationToken.IsCancellationRequested)
    {
        var element = findFunc();
        if (element != null && element.IsAvailable)
        {
            return element;
        }
        
        if ((DateTime.Now - startTime).TotalMilliseconds > timeoutMs)
        {
            break;
        }
        
        await Task.Delay(200, cancellationToken);
    }
    
    return null;
}

public static async Task<bool> WaitForConditionAsync(
    Func<bool> condition,
    int timeoutMs = 5000,
    int checkIntervalMs = 200,
    CancellationToken cancellationToken = default)
{
    var startTime = DateTime.Now;
    
    while (!cancellationToken.IsCancellationRequested)
    {
        if (condition())
        {
            return true;
        }
        
        if ((DateTime.Now - startTime).TotalMilliseconds > timeoutMs)
        {
            return false;
        }
        
        await Task.Delay(checkIntervalMs, cancellationToken);
    }
    
    return false;
}

5.3 错误恢复与重试机制

自动化脚本必须有自我恢复能力：

public class RetryExecutor
{
    private readonly int _maxRetries;
    private readonly int _retryDelayMs;
    
    public RetryExecutor(int maxRetries = 3, int retryDelayMs = 1000)
    {
        _maxRetries = maxRetries;
        _retryDelayMs = retryDelayMs;
    }
    
    public async Task<T> ExecuteWithRetryAsync<T>(
        Func<Task<T>> operation,
        Func<Exception, bool> shouldRetry = null,
        Action<int, Exception> onRetry = null)
    {
        var lastException = new Exception();
        
        for (int attempt = 1; attempt <= _maxRetries; attempt++)
        {
            try
            {
                return await operation();
            }
            catch (Exception ex)
            {
                lastException = ex;
                
                // 检查是否应该重试
                if (shouldRetry != null && !shouldRetry(ex))
                {
                    throw;
                }
                
                onRetry?.Invoke(attempt, ex);
                
                if (attempt < _maxRetries)
                {
                    await Task.Delay(_retryDelayMs * attempt); // 指数退避
                }
            }
        }
        
        throw new AggregateException(
            $"操作在{_maxRetries}次重试后失败", 
            lastException);
    }
    
    public bool ShouldRetryOnCommonErrors(Exception ex)
    {
        // 这些错误通常可以重试
        return ex is ElementNotFoundException ||
               ex is TimeoutException ||
               ex.Message.Contains("无法访问") ||
               ex.Message.Contains("超时") ||
               ex.Message.Contains("不可用");
    }
}

6. 实际项目中的架构设计

对于需要长期维护的微信自动化项目，良好的架构设计能让代码更易维护。

6.1 分层架构设计

我推荐的分层架构：

WeChatAutomation.Core (核心层)
├── Interfaces (接口定义)
├── Models (数据模型)
├── Services (核心服务)
└── Utilities (工具类)

WeChatAutomation.Implementation (实现层)
├── UIA3 (FlaUI具体实现)
├── ElementLocators (元素定位器)
└── Operations (具体操作)

WeChatAutomation.Client (客户端)
├── ConsoleApp (控制台应用)
├── WinFormsApp (窗体应用)
└── Service (Windows服务)

6.2 配置化管理

把容易变化的配置提取出来：

{
  "WeChatAutomation": {
    "Timeouts": {
      "ElementFind": 5000,
      "PageLoad": 3000,
      "Operation": 10000
    },
    "RetrySettings": {
      "MaxRetries": 3,
      "RetryDelay": 1000
    },
    "ElementSelectors": {
      "SearchBox": {
        "Strategies": [
          { "Type": "ByName", "Value": "搜索" },
          { "Type": "ByAutomationId", "Value": "SearchEditBox" },
          { "Type": "ByControlType", "Value": "Edit" }
        ]
      },
      "SendButton": {
        "Strategies": [
          { "Type": "ByName", "Value": "发送(S)" },
          { "Type": "ByName", "Value": "发送" },
          { "Type": "ByAutomationId", "Value": "SendButton" }
        ]
      }
    },
    "WeChatPaths": {
      "Default": "C:\\Program Files (x86)\\Tencent\\WeChat\\WeChat.exe",
      "Alternatives": [
        "D:\\WeChat\\WeChat.exe",
        "C:\\Users\\%USERNAME%\\AppData\\Local\\Tencent\\WeChat\\WeChat.exe"
      ]
    }
  }
}

6.3 插件化设计

支持不同的微信版本和功能扩展：

public interface IWeChatAutomationPlugin
{
    string PluginName { get; }
    Version SupportedWeChatVersion { get; }
    
    bool CanHandle(Window mainWindow);
    void Initialize(Window mainWindow, UIA3Automation automation);
    
    // 插件提供的功能
    IEnumerable<string> GetAvailableContacts();
    bool SendMessage(string contact, string message);
    // ... 其他功能
}

public class WeChatAutomationHost
{
    private readonly List<IWeChatAutomationPlugin> _plugins = new();
    private IWeChatAutomationPlugin _activePlugin;
    
    public void RegisterPlugin(IWeChatAutomationPlugin plugin)
    {
        _plugins.Add(plugin);
    }
    
    public bool Initialize(Window mainWindow, UIA3Automation automation)
    {
        foreach (var plugin in _plugins.OrderByDescending(p => p.SupportedWeChatVersion))
        {
            if (plugin.CanHandle(mainWindow))
            {
                _activePlugin = plugin;
                plugin.Initialize(mainWindow, automation);
                return true;
            }
        }
        
        return false;
    }
    
    // 通过活动插件执行操作
    public bool SendMessage(string contact, string message)
    {
        if (_activePlugin == null)
            throw new InvalidOperationException("没有可用的插件");
        
        return _activePlugin.SendMessage(contact, message);
    }
}

微信自动化确实有很多坑，但一旦掌握了正确的方法，就能构建出稳定可靠的自动化脚本。关键是要理解UI自动化的原理，而不是盲目复制代码。每个微信版本、每台电脑的环境都可能不同，所以你的代码需要有足够的灵活性和容错能力。

我在实际项目中发现，最稳定的方案往往是最简单直接的方案。不要过度设计，但要确保每个操作都有错误处理和恢复机制。多使用等待和重试，少依赖固定的延迟时间。最重要的是，要有一套完善的日志系统，这样当出现问题时，你能快速定位原因。

自动化工具应该让工作更轻松，而不是制造更多问题。花时间构建一个健壮的基础框架，后续的开发会顺利很多。记住，好的自动化脚本是经过大量测试和调整的产物，不要指望一次就能写完美。