WPF 互操作与集成

SunnyFan大约 13 分钟约 3914 字

WPF 互操作与集成

简介

在实际的企业开发中，WPF 应用往往需要与各种现有系统和遗留代码进行互操作。无论是嵌入旧的 Win32 控件、集成 WinForms 组件、调用 COM 接口，还是与 C++ 本地代码交互，WPF 都提供了完善的互操作机制。理解这些互操作技术，是构建复杂企业级应用的关键能力。

WPF 基于 DirectX 渲染，而传统 Win32/WinForms 基于 GDI/GDI+，两者在渲染模型上有本质差异。互操作的核心挑战在于如何在这两种渲染体系之间建立桥梁，同时保持良好的用户体验和性能表现。

特点

双向互操作：WPF 可以嵌入 WinForms 控件，WinForms 也可以嵌入 WPF 控件
Win32 原生支持：通过 HwndSource/HwndHost 与 Win32 窗口系统对接
COM 互操作：完整的 COM 组件调用能力，支持 Office 自动化等场景
C++/CLI 混合编程：可在托管代码和本地代码之间无缝切换
WebView2 集成：嵌入 Chromium 内核浏览器控件
跨框架拖放：支持 WPF 与其他框架之间的拖放操作
剪贴板/OLE 集成：与系统剪贴板和 OLE 协议互操作

实现

WinForms 控件托管（WindowsFormsHost）

WindowsFormsHost 允许在 WPF 中嵌入 WinForms 控件。

基础用法

<!-- 添加 WinForms 命名空间 -->
xmlns:wfi="clr-namespace:System.Windows.Forms.Integration;assembly=WindowsFormsIntegration"
xmlns:wf="clr-namespace:System.Windows.Forms;assembly=System.Windows.Forms"

<!-- 嵌入 WinForms DataGridView -->
<wfi:WindowsFormsHost Name="formsHost" Margin="10">
    <wf:DataGridView
        x:Name="winFormsGrid"
        AutoGenerateColumns="true"
        SelectionMode="FullRowSelect"
        AllowUserToAddRows="true" />
</wfi:WindowsFormsHost>

// 代码中初始化 WinForms 控件
public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();

        // 必须在 InitializeComponent 之前或之中初始化 WinForms
        System.Windows.Forms.Application.EnableVisualStyles();

        // 配置 DataGridView
        winFormsGrid.DataSource = GetSampleData();
        winFormsGrid.AutoSizeColumnsMode =
            System.Windows.Forms.DataGridViewAutoSizeColumnsMode.Fill;
    }
}

嵌入第三方 WinForms 控件

// 嵌入 WinForms Chart 控件
public void EmbedWinFormsChart()
{
    var host = new WindowsFormsHost();
    var chart = new System.Windows.Forms.DataVisualization.Charting.Chart();

    chart.ChartAreas.Add(new ChartArea("MainArea"));
    chart.Series.Add(new Series("Sales")
    {
        ChartType = SeriesChartType.Column
    });

    chart.Series["Sales"].Points.AddXY("Q1", 1000);
    chart.Series["Sales"].Points.AddXY("Q2", 1500);
    chart.Series["Sales"].Points.AddXY("Q3", 1200);
    chart.Series["Sales"].Points.AddXY("Q4", 1800);

    host.Child = chart;
    ChartPanel.Children.Add(host);
}

处理 WinForms 控件事件

// WinForms 控件事件与 WPF 事件系统的桥接
winFormsGrid.CellClick += (sender, e) =>
{
    // 在 WPF ViewModel 中处理
    var selectedRow = winFormsGrid.Rows[e.RowIndex];
    var data = selectedRow.DataBoundItem;

    // 通过 Dispatcher 切换到 WPF 线程
    Dispatcher.Invoke(() =>
    {
        ViewModel.SelectedRecord = data;
    });
};

// 键盘事件处理
winFormsGrid.KeyDown += (sender, e) =>
{
    if (e.KeyCode == System.Windows.Forms.Keys.Enter)
    {
        e.Handled = true;
        // 执行 WPF 命令
        ViewModel.SaveCommand.Execute(null);
    }
};

WPF 控件嵌入 WinForms（ElementHost）

ElementHost 允许在 WinForms 窗体中嵌入 WPF 控件。

// 在 WinForms 中嵌入 WPF UserControl
public class LegacyForm : System.Windows.Forms.Form
{
    public LegacyForm()
    {
        var elementHost = new ElementHost
        {
            Dock = System.Windows.Forms.DockStyle.Fill
        };

        // 创建 WPF 控件
        var wpfControl = new MyWpfUserControl();
        wpfControl.DataContext = new MyViewModel();

        elementHost.Child = wpfControl;
        this.Controls.Add(elementHost);
    }
}

// 渐进式迁移方案：逐步替换 WinForms 界面
public class MigrationHelper
{
    public static ElementHost CreateHostedWpfControl(
        System.Windows.Forms.Control oldControl)
    {
        var host = new ElementHost
        {
            Location = oldControl.Location,
            Size = oldControl.Size,
            Visible = true
        };

        return host;
    }
}

Win32 互操作（HwndHost）

HwndHost 是 WPF 托管 Win32 窗口的基类。

托管 Win32 窗口

public class Win32Host : HwndSource
{
    private IntPtr hwnd;
    private const string WindowClassName = "Win32HostWindow";

    public Win32Host()
    {
        // 注册 Win32 窗口类
        RegisterWindowClass();
    }

    private void RegisterWindowClass()
    {
        var wc = new WNDCLASS
        {
            hInstance = GetModuleHandle(IntPtr.Zero),
            lpszClassName = WindowClassName,
            lpfnWndProc = WndProc
        };
        RegisterClass(wc);
    }

    private IntPtr WndProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam)
    {
        switch (msg)
        {
            case 0x000F: // WM_PAINT
                // 处理绘制
                break;
            case 0x0002: // WM_DESTROY
                // 清理
                break;
        }
        return DefWindowProc(hWnd, msg, wParam, lParam);
    }

    [DllImport("user32.dll")]
    static extern IntPtr DefWindowProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam);

    [DllImport("user32.dll")]
    static extern ushort RegisterClass(WNDCLASS wc);

    [DllImport("kernel32.dll")]
    static extern IntPtr GetModuleHandle(IntPtr lpModuleName);
}

// 自定义 HwndHost 实现
public class NativeWindowHost : HwndHost
{
    private IntPtr _hwnd;
    public string WindowTitle { get; set; }

    protected override HandleRef BuildWindowCore(HandleRef hwndParent)
    {
        // 创建 Win32 子窗口
        _hwnd = CreateWindowEx(
            0,
            "STATIC",
            WindowTitle ?? "Native Window",
            WS_CHILD | WS_VISIBLE,
            0, 0,
            (int)ActualWidth,
            (int)ActualHeight,
            hwndParent.Handle,
            IntPtr.Zero,
            IntPtr.Zero,
            IntPtr.Zero);

        return new HandleRef(this, _hwnd);
    }

    protected override void DestroyWindowCore(HandleRef hwnd)
    {
        DestroyWindow(hwnd.Handle);
    }

    [DllImport("user32.dll")]
    static extern IntPtr CreateWindowEx(
        uint dwExStyle, string lpClassName, string lpWindowName,
        uint dwStyle, int x, int y, int nWidth, int nHeight,
        IntPtr hWndParent, IntPtr hMenu, IntPtr hInstance, IntPtr lpParam);

    [DllImport("user32.dll")]
    static extern bool DestroyWindow(IntPtr hWnd);

    private const uint WS_CHILD = 0x40000000;
    private const uint WS_VISIBLE = 0x10000000;
}

HwndSource：在 Win32 中嵌入 WPF

// 在 Win32 应用中创建 WPF 内容
public class WpfInWin32
{
    public void CreateWpfContent(IntPtr parentHwnd)
    {
        var parameters = new HwndSourceParameters("WpfContent")
        {
            ParentWindow = parentHwnd,
            WindowStyle = 0x40000000 | 0x10000000, // WS_CHILD | WS_VISIBLE
            PositionX = 0,
            PositionY = 0,
            Width = 800,
            Height = 600
        };

        var source = new HwndSource(parameters);
        var wpfPage = new MyWpfPage();
        source.RootVisual = wpfPage;

        // 处理 Win32 消息转发
        source.AddHook(WpfMessageHook);
    }

    private IntPtr WpfMessageHook(IntPtr hwnd, int msg, IntPtr wParam,
        IntPtr lParam, ref bool handled)
    {
        // 在此处理需要转发的 Win32 消息
        return IntPtr.Zero;
    }
}

COM 互操作

基础 COM 调用

// 通过 COM 互操作调用 COM 组件
[ComImport]
[Guid("000209FF-0000-0000-C000-000000000046")]
[InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
interface _Application
{
    void Quit();
    bool Visible { get; set; }
}

public class ComInteropService
{
    public void CallComComponent()
    {
        Type type = Type.GetTypeFromProgID("Scripting.FileSystemObject");
        dynamic fso = Activator.CreateInstance(type);

        // 使用 dynamic 简化 COM 调用
        dynamic folder = fso.GetFolder(@"C:\Temp");
        Console.WriteLine($"文件数: {folder.Files.Count}");

        // 释放 COM 对象
        Marshal.ReleaseComObject(folder);
        Marshal.ReleaseComObject(fso);
    }
}

Office 自动化

// Excel 自动化示例
public class ExcelInteropService : IDisposable
{
    private dynamic _excelApp;
    private bool _disposed;

    public void Initialize()
    {
        Type type = Type.GetTypeFromProgID("Excel.Application");
        _excelApp = Activator.CreateInstance(type);
        _excelApp.Visible = false;
        _excelApp.DisplayAlerts = false;
    }

    public void ExportData(string filePath, DataTable data)
    {
        dynamic workbooks = _excelApp.Workbooks;
        dynamic workbook = workbooks.Add();
        dynamic worksheet = workbook.Sheets[1];

        try
        {
            // 写入表头
            for (int col = 0; col < data.Columns.Count; col++)
            {
                worksheet.Cells[1, col + 1] = data.Columns[col].ColumnName;
            }

            // 写入数据
            for (int row = 0; row < data.Rows.Count; row++)
            {
                for (int col = 0; col < data.Columns.Count; col++)
                {
                    worksheet.Cells[row + 2, col + 1] = data.Rows[row][col];
                }
            }

            // 设置格式
            dynamic range = worksheet.UsedRange;
            range.Columns.AutoFit();

            workbook.SaveAs(filePath);
        }
        finally
        {
            // 逐一释放 COM 对象
            Marshal.ReleaseComObject(worksheet);
            Marshal.ReleaseComObject(workbook);
            Marshal.ReleaseComObject(workbooks);
        }
    }

    public void Dispose()
    {
        if (!_disposed)
        {
            if (_excelApp != null)
            {
                _excelApp.Quit();
                Marshal.ReleaseComObject(_excelApp);
            }
            _disposed = true;
        }
    }
}

C++/CLI 混合模式编程

C++/CLI 是连接托管代码和本地 C++ 代码的桥梁。

C++/CLI 包装器

// NativeLibrary.h - 纯 C++ 类
#pragma once
#include <string>

namespace NativeLib
{
    class __declspec(dllexport) NativeProcessor
    {
    public:
        double ProcessData(const double* data, int length);
        std::string GetResult();
    };
}

// ManagedWrapper.h - C++/CLI 包装器
#pragma once
#include "NativeLibrary.h"

using namespace System;
using namespace System::Collections::Generic;

namespace ManagedWrapper
{
    public ref class ProcessorWrapper
    {
    private:
        NativeLib::NativeProcessor* _native;

    public:
        ProcessorWrapper()
        {
            _native = new NativeLib::NativeProcessor();
        }

        ~ProcessorWrapper()
        {
            this->!ProcessorWrapper();
        }

        // 终结器
        !ProcessorWrapper()
        {
            if (_native != nullptr)
            {
                delete _native;
                _native = nullptr;
            }
        }

        double ProcessData(List<double>^ data)
        {
            // 托管数组 -> 本地数组
            pin_ptr<double> pinnedPtr = &data[0];
            double* nativeData = pinnedPtr;

            return _native->ProcessData(nativeData, data->Count);
        }

        String^ GetResult()
        {
            std::string result = _native->GetResult();
            return gcnew String(result.c_str());
        }
    };
}

// C# 中调用 C++/CLI 包装器
public class NativeIntegrationService
{
    public double ProcessWithNative(List<double> data)
    {
        using (var processor = new ManagedWrapper.ProcessorWrapper())
        {
            double result = processor.ProcessData(data);
            string details = processor.GetResult();
            return result;
        }
    }
}

P/Invoke 平台调用

// 常用 Win32 API 调用
public static class NativeMethods
{
    [DllImport("user32.dll", SetLastError = true)]
    public static extern IntPtr FindWindow(string lpClassName, string lpWindowName);

    [DllImport("user32.dll", SetLastError = true)]
    public static extern bool SetForegroundWindow(IntPtr hWnd);

    [DllImport("user32.dll")]
    public static extern bool GetWindowRect(IntPtr hWnd, out RECT lpRect);

    [DllImport("user32.dll")]
    public static extern int GetSystemMetrics(int nIndex);

    [DllImport("kernel32.dll")]
    public static extern uint GetTickCount();

    [StructLayout(LayoutKind.Sequential)]
    public struct RECT
    {
        public int Left, Top, Right, Bottom;
        public int Width => Right - Left;
        public int Height => Bottom - Top;
    }
}

// 使用示例
public class WindowManager
{
    public void BringWindowToFront(string title)
    {
        IntPtr hwnd = NativeMethods.FindWindow(null, title);
        if (hwnd != IntPtr.Zero)
        {
            NativeMethods.SetForegroundWindow(hwnd);
        }
    }

    public Rect GetWindowBounds(IntPtr hwnd)
    {
        NativeMethods.GetWindowRect(hwnd, out var rect);
        return new Rect(rect.Left, rect.Top, rect.Width, rect.Height);
    }
}

WebView2 集成

WebView2 基于 Chromium 内核，是现代 WPF 应用的 Web 嵌入方案。

基础集成

<!-- 安装 NuGet：Microsoft.Web.WebView2 -->
xmlns:wv2="clr-namespace:Microsoft.Web.WebView2.Wpf;assembly=Microsoft.Web.WebView2.Wpf"

<wv2:WebView2
    Name="webView"
    Source="https://www.example.com"
    Margin="10" />

public partial class WebBrowserWindow : Window
{
    public WebBrowserWindow()
    {
        InitializeComponent();
        InitializeWebView();
    }

    private async void InitializeWebView()
    {
        try
        {
            // 初始化 WebView2 环境
            var env = await CoreWebView2Environment.CreateAsync(
                browserExecutableFolder: null,
                userDataFolder: Path.Combine(
                    Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
                    "MyApp", "WebView2"));

            await webView.EnsureCoreWebView2Async(env);

            // 配置 WebView2 设置
            webView.CoreWebView2.Settings.AreDefaultContextMenusEnabled = true;
            webView.CoreWebView2.Settings.AreDevToolsEnabled = true;
            webView.CoreWebView2.Settings.IsScriptEnabled = true;

            // 注册消息处理
            webView.CoreWebView2.WebMessageReceived += OnWebMessageReceived;

            // 加载本地 HTML
            webView.CoreWebView2.NavigateToLocal("web/index.html");
        }
        catch (WebView2RuntimeNotFoundException)
        {
            MessageBox.Show("请安装 WebView2 Runtime");
        }
    }

    private void OnWebMessageReceived(object sender, CoreWebView2WebMessageReceivedEventArgs e)
    {
        string message = e.TryGetWebMessageAsString();
        // 处理来自 Web 的消息
        Dispatcher.Invoke(() =>
        {
            ViewModel.HandleWebMessage(message);
        });
    }

    // 从 WPF 调用 JavaScript
    public async Task<string> ExecuteScriptAsync(string script)
    {
        return await webView.CoreWebView2.ExecuteScriptAsync(script);
    }

    // 从 JavaScript 调用 WPF
    public void RegisterWpfBridge()
    {
        webView.CoreWebView2.AddHostObjectToScript(
            "wpfBridge",
            new WpfBridge());
    }
}

// 暴露给 JavaScript 的 C# 对象
[ClassInterface(ClassInterfaceType.AutoDual)]
[ComVisible(true)]
public class WpfBridge
{
    public string GetAppVersion() => "1.0.0";

    public void ShowNotification(string message)
    {
        Application.Current.Dispatcher.Invoke(() =>
        {
            MessageBox.Show(message);
        });
    }
}

双向通信完整方案

// WPF 与 WebView2 双向通信服务
public class WebViewCommunicationService
{
    private CoreWebView2 _coreWebView;

    public event Action<string, string> MessageReceived;

    public async Task InitializeAsync(WebView2 webView)
    {
        await webView.EnsureCoreWebView2Async();
        _coreWebView = webView.CoreWebView2;

        _coreWebView.WebMessageReceived += (s, e) =>
        {
            string type = e.TryGetWebMessageAsString();
            MessageReceived?.Invoke("message", type);
        };
    }

    public async Task SendToWebAsync(string type, object data)
    {
        var json = JsonSerializer.Serialize(data);
        var script = $"window.handleWpfMessage('{type}', {json})";
        await _coreWebView.ExecuteScriptAsync(script);
    }

    public async Task<T> CallWebFunctionAsync<T>(string functionName, params object[] args)
    {
        var argsJson = string.Join(",", args.Select(a => JsonSerializer.Serialize(a)));
        var script = $"JSON.stringify({functionName}({argsJson}))";
        var result = await _coreWebView.ExecuteScriptAsync(script);
        return JsonSerializer.Deserialize<T>(result);
    }
}

剪贴板与 OLE 互操作

// 跨框架剪贴板操作
public class ClipboardInteropService
{
    // WPF 剪贴板操作
    public void CopyToClipboard(string text)
    {
        // WPF 方式
        Clipboard.SetText(text);

        // 或使用 WinForms 方式（更兼容）
        System.Windows.Forms.Clipboard.SetText(text);
    }

    // 复制富文本
    public void CopyRichText(string rtfText)
    {
        var data = new DataObject();
        data.SetData(DataFormats.Rtf, rtfText);
        data.SetData(DataFormats.Text, StripRtf(rtfText));
        Clipboard.SetDataObject(data, true);
    }

    // 从剪贴板获取图片
    public BitmapSource GetClipboardImage()
    {
        if (Clipboard.ContainsImage())
        {
            return Clipboard.GetImage();
        }
        return null;
    }

    // 监听剪贴板变化
    public void StartClipboardMonitor()
    {
        // 使用 Win32 API 监听剪贴板
        var hwndSource = PresentationSource.FromVisual(Application.Current.MainWindow)
            as HwndSource;
        hwndSource?.AddHook(ClipboardHook);

        // 注册为剪贴板查看器
        IntPtr hwnd = hwndSource.Handle;
        IntPtr nextViewer = SetClipboardViewer(hwnd);
    }

    private IntPtr ClipboardHook(IntPtr hwnd, int msg, IntPtr wParam,
        IntPtr lParam, ref bool handled)
    {
        if (msg == 0x0308) // WM_DRAWCLIPBOARD
        {
            // 剪贴板内容变化
            OnClipboardChanged();
        }
        return IntPtr.Zero;
    }

    [DllImport("user32.dll")]
    static extern IntPtr SetClipboardViewer(IntPtr hWndNewViewer);

    private string StripRtf(string rtf) { /* 实现 */ return rtf; }
    protected virtual void OnClipboardChanged() { }
}

跨框架拖放

// WPF 接收来自外部应用的拖放
public partial class DropTargetWindow : Window
{
    public DropTargetWindow()
    {
        InitializeComponent();
        AllowDrop = true;
        Drop += OnDrop;
        DragOver += OnDragOver;
    }

    private void OnDragOver(object sender, DragEventArgs e)
    {
        // 检查拖放数据类型
        if (e.Data.GetDataPresent(DataFormats.FileDrop))
        {
            e.Effects = DragDropEffects.Copy;
        }
        else
        {
            e.Effects = DragDropEffects.None;
        }
        e.Handled = true;
    }

    private void OnDrop(object sender, DragEventArgs e)
    {
        if (e.Data.GetDataPresent(DataFormats.FileDrop))
        {
            string[] files = (string[])e.Data.GetData(DataFormats.FileDrop);
            foreach (string file in files)
            {
                ProcessDroppedFile(file);
            }
        }
        else if (e.Data.GetDataPresent(DataFormats.Text))
        {
            string text = (string)e.Data.GetData(DataFormats.Text);
            ProcessDroppedText(text);
        }
    }

    private void ProcessDroppedFile(string file)
    {
        // 处理拖入的文件
    }

    private void ProcessDroppedText(string text)
    {
        // 处理拖入的文本
    }
}

// 从 WPF 拖出到外部应用
public class DragSourceHelper
{
    public static void StartDrag(FrameworkElement element, string filePath)
    {
        var data = new DataObject(DataFormats.FileDrop, new string[] { filePath });
        DragDrop.DoDragDrop(element, data, DragDropEffects.Copy);
    }
}

遗留系统集成服务

// 统一的互操作服务接口
public interface IInteropService
{
    Task<object> CallLegacyApiAsync(string endpoint, object parameters);
    IntPtr GetNativeWindowHandle();
    void RegisterMessageHandler(int messageId, Action<IntPtr, IntPtr> handler);
}

public class LegacySystemService : IInteropService
{
    private HwndSource _hwndSource;
    private Dictionary<int, Action<IntPtr, IntPtr>> _messageHandlers;

    public LegacySystemService()
    {
        _messageHandlers = new Dictionary<int, Action<IntPtr, IntPtr>>();
    }

    public void Initialize(Window wpfWindow)
    {
        _hwndSource = PresentationSource.FromVisual(wpfWindow) as HwndSource;
        _hwndSource?.AddHook(WindowMessageHook);
    }

    private IntPtr WindowMessageHook(IntPtr hwnd, int msg, IntPtr wParam,
        IntPtr lParam, ref bool handled)
    {
        if (_messageHandlers.TryGetValue(msg, out var handler))
        {
            handler(wParam, lParam);
        }
        return IntPtr.Zero;
    }

    public async Task<object> CallLegacyApiAsync(string endpoint, object parameters)
    {
        // 通过命名管道、共享内存或 TCP 调用遗留系统
        using var client = new NamedPipeClientStream(".", endpoint,
            PipeDirection.InOut);
        await client.ConnectAsync(5000);

        using var reader = new StreamReader(client);
        using var writer = new StreamWriter(client) { AutoFlush = true };

        var request = JsonSerializer.Serialize(parameters);
        await writer.WriteLineAsync(request);

        var response = await reader.ReadLineAsync();
        return JsonSerializer.Deserialize<object>(response);
    }

    public IntPtr GetNativeWindowHandle()
    {
        return _hwndSource?.Handle ?? IntPtr.Zero;
    }

    public void RegisterMessageHandler(int messageId, Action<IntPtr, IntPtr> handler)
    {
        _messageHandlers[messageId] = handler;
    }
}

优点

保护现有投资：无需重写遗留代码即可迁移到 WPF
渐进式迁移：可以逐个模块从 WinForms 迁移到 WPF
功能互补：利用各框架的优势解决特定问题
丰富生态：可以复用大量 WinForms 和 Win32 组件
WebView2 现代化：在桌面应用中嵌入现代 Web 技术

缺点

渲染冲突：WPF（DirectX）与 Win32/WinForms（GDI）的渲染模型不同，可能产生视觉瑕疵
** airspace 问题**：WPF 和 Win32 窗口在 Z 轴上不能互相穿插
性能开销：跨边界调用有额外开销
调试复杂：涉及多层互操作，问题定位困难
线程模型差异：WinForms 和 WPF 的 UI 线程模型不完全一致
COM 引用泄漏：COM 对象需要手动释放，容易造成内存泄漏

性能注意事项

Airspace 问题

// Airspace 问题：WinForms/WPF 控件不能在同一区域内重叠
// 解决方案：使用互操作区域隔离
public class AirspaceHelper
{
    // 方案 1：将 WinForms 控件放在独立的区域
    public static void IsolateWinFormsControl(
        WindowsFormsHost host, Panel container)
    {
        // 确保 WinFormsHost 不会被 WPF 控件遮挡
        Panel.SetZIndex(host, 999);
    }

    // 方案 2：截图渲染（适用于静态内容）
    public static RenderTargetBitmap CaptureWinFormsControl(
        System.Windows.Forms.Control control)
    {
        var bmp = new System.Drawing.Bitmap(
            control.Width, control.Height);
        control.DrawToBitmap(bmp,
            new System.Drawing.Rectangle(0, 0, control.Width, control.Height));

        // 转换为 WPF BitmapSource
        var hBitmap = bmp.GetHbitmap();
        try
        {
            return Imaging.CreateBitmapSourceFromHBitmap(
                hBitmap, IntPtr.Zero, Int32Rect.Empty,
                BitmapSizeOptions.FromEmptyOptions());
        }
        finally
        {
            DeleteObject(hBitmap);
        }
    }

    [DllImport("gdi32.dll")]
    static extern bool DeleteObject(IntPtr hObject);
}

跨边界调用优化

// 减少跨边界调用次数
public class InteropOptimizer
{
    // 错误做法：频繁的单次调用
    public void SlowApproach(dynamic comObject, List<string> items)
    {
        foreach (var item in items)
        {
            comObject.AddItem(item); // 每次 COM 调用都有开销
        }
    }

    // 正确做法：批量传递数据
    public void FastApproach(dynamic comObject, List<string> items)
    {
        object[] array = items.ToArray();
        comObject.AddItems(array); // 一次调用传递所有数据
    }

    // 缓存 COM 对象引用
    private Dictionary<string, object> _comCache = new();

    public T GetComObject<T>(string progId) where T : class
    {
        if (!_comCache.TryGetValue(progId, out var obj))
        {
            var type = Type.GetTypeFromProgID(progId);
            obj = Activator.CreateInstance(type);
            _comCache[progId] = obj;
        }
        return (T)obj;
    }
}

WPF 互操作是企业应用开发中不可或缺的能力。通过 WindowsFormsHost/ElementHost 实现 WinForms 双向集成，通过 HwndHost/HwndSource 实现 Win32 窗口托管，通过 COM 互操作集成 Office 和遗留组件，通过 WebView2 嵌入现代 Web 内容。理解各互操作方案的限制（特别是 airspace 问题），并在架构设计中合理规划互操作边界，是成功的关键。

关键知识点

Airspace 限制：WPF 和 Win32/WinForms 控件在 Z 轴上不能混合
COM 引用计数：必须显式释放 COM 对象（Marshal.ReleaseComObject）
Dispatcher 切换：跨框架操作需要切换到正确的 UI 线程
WindowsFormsHost 限制：不支持 WPF 的透明度、变换等特性
WebView2 Runtime：需要用户安装 WebView2 运行时
C++/CLI 内存管理：需要同时管理托管堆和本地堆的内存

常见误区

忘记释放 COM 对象：导致 Excel/Word 进程残留
忽略 Airspace 限制：导致布局异常或渲染错误
在错误的线程操作 UI：WinForms 和 WPF 控件需要在各自的 UI 线程操作
过度使用 dynamic：COM 调用使用 dynamic 虽然方便但缺乏编译时检查
WebView2 同步调用：WebView2 是异步 API，不能在同步上下文中使用
P/Invoke 签名错误：错误的 DllImport 签名可能导致崩溃

进阶路线

深入 Win32 API：学习 Windows 消息机制、窗口管理
DirectX 互操作：WPF 与 Direct3D/Direct2D 的共享表面
混合模式调试：学习使用 SOS 扩展和 WinDbg 调试互操作问题
NuGet 包迁移：将 COM 组件打包为 NuGet 包
跨平台迁移：使用 .NET MAUI 或 Avalonia 替代互操作方案
现代化改造：逐步替换遗留组件，减少互操作依赖

适用场景

企业应用现代化：从 WinForms/VB6 渐进式迁移到 WPF
Office 插件开发：WPF 界面 + Office 对象模型
工业控制软件：WPF 界面 + 本地硬件驱动
数据分析平台：WPF 界面 + 本地计算引擎
嵌入式 Web 内容：桌面应用中显示 Web 页面或图表
遗留系统集成：对接已有的 COM/Win32 组件

落地建议

制定迁移策略：优先使用纯 WPF 方案，仅在必要时引入互操作
封装互操作层：将所有互操作代码封装在独立的服务层中
统一错误处理：互操作调用的异常需要统一捕获和转换
内存泄漏检测：使用工具定期检测 COM 对象泄漏
线程模型文档化：明确记录各组件的线程要求
集成测试：对互操作场景编写专门的集成测试

// 推荐的互操作服务注册
public static class InteropServiceExtensions
{
    public static void AddInteropServices(this IServiceCollection services)
    {
        services.AddSingleton<IInteropService, LegacySystemService>();
        services.AddSingleton<IClipboardService, ClipboardInteropService>();
        services.AddSingleton<IWebViewService, WebViewCommunicationService>();
        services.AddTransient<IExcelService, ExcelInteropService>();
    }
}

排错清单

复盘问题

你的互操作方案是否是最简方案？有没有纯 WPF 替代方案？
COM 对象的生命周期管理策略是什么？
互操作层是否与业务逻辑解耦？
你如何检测和诊断互操作导致的内存泄漏？
是否需要支持多平台？如果是，互操作代码如何处理？
性能瓶颈是否在跨边界调用？如何优化？

WPF 互操作与集成

WPF 互操作与集成

简介

特点

实现

WinForms 控件托管（WindowsFormsHost）

基础用法

嵌入第三方 WinForms 控件

处理 WinForms 控件事件

WPF 控件嵌入 WinForms（ElementHost）

Win32 互操作（HwndHost）

托管 Win32 窗口

HwndSource：在 Win32 中嵌入 WPF

COM 互操作

基础 COM 调用

Office 自动化

C++/CLI 混合模式编程

C++/CLI 包装器

P/Invoke 平台调用

WebView2 集成

基础集成

双向通信完整方案

剪贴板与 OLE 互操作

跨框架拖放

遗留系统集成服务

优点

缺点

性能注意事项

Airspace 问题

跨边界调用优化

总结

关键知识点

常见误区

进阶路线

适用场景

落地建议

排错清单

复盘问题

延伸阅读