Làm thế nào để xử lý các thông báo WndProc trong WPF?

Trong Windows Forms, tôi chỉ cần ghi đè WndProcvà bắt đầu xử lý các thông báo khi chúng đến.

Ai đó có thể chỉ cho tôi một ví dụ về cách đạt được điều tương tự trong WPF không?

Trên thực tế, theo như tôi hiểu, một điều như vậy thực sự có thể xảy ra trong WPF bằng cách sử dụng HwndSourcevà HwndSourceHook. Hãy xem chuỗi này trên MSDN làm ví dụ. (Mã liên quan bao gồm bên dưới)

// 'this' is a Window
HwndSource source = HwndSource.FromHwnd(new WindowInteropHelper(this).Handle);
source.AddHook(new HwndSourceHook(WndProc));

private static IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
{
    //  do stuff

    return IntPtr.Zero;
}

Bây giờ, tôi không chắc tại sao bạn lại muốn xử lý tin nhắn Windows Messaging trong ứng dụng WPF (trừ khi đó là dạng tương tác rõ ràng nhất để làm việc với một ứng dụng WinForms khác). Tư tưởng thiết kế và bản chất của API rất khác trong WPF với WinForms, vì vậy tôi khuyên bạn chỉ cần tự làm quen với WPF nhiều hơn để biết chính xác tại sao không có WndProc tương đương.

Bạn có thể làm điều này thông qua System.Windows.Interopkhông gian tên có chứa một lớp được đặt tên HwndSource.

Ví dụ về việc sử dụng cái này

using System;
using System.Windows;
using System.Windows.Interop;

namespace WpfApplication1
{
    public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();
        }

        protected override void OnSourceInitialized(EventArgs e)
        {
            base.OnSourceInitialized(e);
            HwndSource source = PresentationSource.FromVisual(this) as HwndSource;
            source.AddHook(WndProc);
        }

        private IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
        {
            // Handle messages...

            return IntPtr.Zero;
        }
    }
}

Hoàn toàn được lấy từ bài đăng trên blog xuất sắc: Sử dụng WndProc tùy chỉnh trong ứng dụng WPF của Steve Rands

HwndSource src = HwndSource.FromHwnd(new WindowInteropHelper(this).Handle);
src.AddHook(new HwndSourceHook(WndProc));


.......


public IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
{

  if(msg == THEMESSAGEIMLOOKINGFOR)
    {
      //Do something here
    }

  return IntPtr.Zero;
}

Nếu bạn không phiền khi tham khảo WinForms, bạn có thể sử dụng giải pháp hướng MVVM hơn mà không kết hợp dịch vụ với chế độ xem. Bạn cần tạo và khởi tạo System.Windows.Forms.NativeWindow, một cửa sổ nhẹ có thể nhận tin nhắn.

public abstract class WinApiServiceBase : IDisposable
{
    /// <summary>
    /// Sponge window absorbs messages and lets other services use them
    /// </summary>
    private sealed class SpongeWindow : NativeWindow
    {
        public event EventHandler<Message> WndProced;

        public SpongeWindow()
        {
            CreateHandle(new CreateParams());
        }

        protected override void WndProc(ref Message m)
        {
            WndProced?.Invoke(this, m);
            base.WndProc(ref m);
        }
    }

    private static readonly SpongeWindow Sponge;
    protected static readonly IntPtr SpongeHandle;

    static WinApiServiceBase()
    {
        Sponge = new SpongeWindow();
        SpongeHandle = Sponge.Handle;
    }

    protected WinApiServiceBase()
    {
        Sponge.WndProced += LocalWndProced;
    }

    private void LocalWndProced(object sender, Message message)
    {
        WndProc(message);
    }

    /// <summary>
    /// Override to process windows messages
    /// </summary>
    protected virtual void WndProc(Message message)
    { }

    public virtual void Dispose()
    {
        Sponge.WndProced -= LocalWndProced;
    }
}

Sử dụng SpongeHandle để đăng ký các thư bạn quan tâm và sau đó ghi đè WndProc để xử lý chúng:

public class WindowsMessageListenerService : WinApiServiceBase
{
    protected override void WndProc(Message message)
    {
        Debug.WriteLine(message.msg);
    }
}

Nhược điểm duy nhất là bạn phải bao gồm tham chiếu System.Windows.Forms, nhưng nếu không thì đây là một giải pháp rất đóng gói.

Có thể đọc thêm về điều này ở đây

Đây là liên kết về việc ghi đè WindProc bằng Behaviors: http://10rem.net/blog/2010/01/09/a-wpf-behavior-for-window-resize-events-in-net-35

[Chỉnh sửa: muộn còn hơn không] Dưới đây là cách thực hiện của tôi dựa trên liên kết trên. Mặc dù xem lại điều này, tôi thích triển khai AddHook hơn. Tôi có thể chuyển sang điều đó.

Trong trường hợp của tôi, tôi muốn biết khi nào cửa sổ được thay đổi kích thước và một số thứ khác. Việc triển khai này kết nối với Window xaml và gửi các sự kiện.

using System;
using System.Windows.Interactivity;
using System.Windows; // For Window in behavior
using System.Windows.Interop; // For Hwnd

public class WindowResizeEvents : Behavior<Window>
    {
        public event EventHandler Resized;
        public event EventHandler Resizing;
        public event EventHandler Maximized;
        public event EventHandler Minimized;
        public event EventHandler Restored;

        public static DependencyProperty IsAppAskCloseProperty =  DependencyProperty.RegisterAttached("IsAppAskClose", typeof(bool), typeof(WindowResizeEvents));
        public Boolean IsAppAskClose
        {
            get { return (Boolean)this.GetValue(IsAppAskCloseProperty); }
            set { this.SetValue(IsAppAskCloseProperty, value); }
        }

        // called when the behavior is attached
        // hook the wndproc
        protected override void OnAttached()
        {
            base.OnAttached();

            AssociatedObject.Loaded += (s, e) =>
            {
                WireUpWndProc();
            };
        }

        // call when the behavior is detached
        // clean up our winproc hook
        protected override void OnDetaching()
        {
            RemoveWndProc();

            base.OnDetaching();
        }

        private HwndSourceHook _hook;

        private void WireUpWndProc()
        {
            HwndSource source = HwndSource.FromVisual(AssociatedObject) as HwndSource;

            if (source != null)
            {
                _hook = new HwndSourceHook(WndProc);
                source.AddHook(_hook);
            }
        }

        private void RemoveWndProc()
        {
            HwndSource source = HwndSource.FromVisual(AssociatedObject) as HwndSource;

            if (source != null)
            {
                source.RemoveHook(_hook);
            }
        }

        private const Int32 WM_EXITSIZEMOVE = 0x0232;
        private const Int32 WM_SIZING = 0x0214;
        private const Int32 WM_SIZE = 0x0005;

        private const Int32 SIZE_RESTORED = 0x0000;
        private const Int32 SIZE_MINIMIZED = 0x0001;
        private const Int32 SIZE_MAXIMIZED = 0x0002;
        private const Int32 SIZE_MAXSHOW = 0x0003;
        private const Int32 SIZE_MAXHIDE = 0x0004;

        private const Int32 WM_QUERYENDSESSION = 0x0011;
        private const Int32 ENDSESSION_CLOSEAPP = 0x1;
        private const Int32 WM_ENDSESSION = 0x0016;

        private IntPtr WndProc(IntPtr hwnd, Int32 msg, IntPtr wParam, IntPtr lParam, ref Boolean handled)
        {
            IntPtr result = IntPtr.Zero;

            switch (msg)
            {
                case WM_SIZING:             // sizing gets interactive resize
                    OnResizing();
                    break;

                case WM_SIZE:               // size gets minimize/maximize as well as final size
                    {
                        int param = wParam.ToInt32();

                        switch (param)
                        {
                            case SIZE_RESTORED:
                                OnRestored();
                                break;
                            case SIZE_MINIMIZED:
                                OnMinimized();
                                break;
                            case SIZE_MAXIMIZED:
                                OnMaximized();
                                break;
                            case SIZE_MAXSHOW:
                                break;
                            case SIZE_MAXHIDE:
                                break;
                        }
                    }
                    break;

                case WM_EXITSIZEMOVE:
                    OnResized();
                    break;

                // Windows is requesting app to close.    
                // See http://msdn.microsoft.com/en-us/library/windows/desktop/aa376890%28v=vs.85%29.aspx.
                // Use the default response (yes).
                case WM_QUERYENDSESSION:
                    IsAppAskClose = true; 
                    break;
            }

            return result;
        }

        private void OnResizing()
        {
            if (Resizing != null)
                Resizing(AssociatedObject, EventArgs.Empty);
        }

        private void OnResized()
        {
            if (Resized != null)
                Resized(AssociatedObject, EventArgs.Empty);
        }

        private void OnRestored()
        {
            if (Restored != null)
                Restored(AssociatedObject, EventArgs.Empty);
        }

        private void OnMinimized()
        {
            if (Minimized != null)
                Minimized(AssociatedObject, EventArgs.Empty);
        }

        private void OnMaximized()
        {
            if (Maximized != null)
                Maximized(AssociatedObject, EventArgs.Empty);
        }
    }

<Window x:Class="MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml
        xmlns:i="clr-namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity"
        xmlns:behaviors="clr-namespace:RapidCoreConfigurator._Behaviors"
        Title="name" Height="500" Width="750" BorderBrush="Transparent">

    <i:Interaction.Behaviors>
        <behaviors:WindowResizeEvents IsAppAskClose="{Binding IsRequestClose, Mode=OneWayToSource}"
                                      Resized="Window_Resized"
                                      Resizing="Window_Resizing" />
    </i:Interaction.Behaviors>

    ... 

</Window>

Bạn có thể đính kèm vào lớp 'SystemEvents' của lớp Win32 cài sẵn:

using Microsoft.Win32;

trong một lớp cửa sổ WPF:

SystemEvents.PowerModeChanged += SystemEvents_PowerModeChanged;
SystemEvents.SessionSwitch += SystemEvents_SessionSwitch;
SystemEvents.SessionEnding += SystemEvents_SessionEnding;
SystemEvents.SessionEnded += SystemEvents_SessionEnded;

private async void SystemEvents_PowerModeChanged(object sender, PowerModeChangedEventArgs e)
{
    await vm.PowerModeChanged(e.Mode);
}

private async void SystemEvents_PowerModeChanged(object sender, PowerModeChangedEventArgs e)
{
    await vm.PowerModeChanged(e.Mode);
}

private async void SystemEvents_SessionSwitch(object sender, SessionSwitchEventArgs e)
{
    await vm.SessionSwitch(e.Reason);
}

private async void SystemEvents_SessionEnding(object sender, SessionEndingEventArgs e)
{
    if (e.Reason == SessionEndReasons.Logoff)
    {
        await vm.UserLogoff();
    }
}

private async void SystemEvents_SessionEnded(object sender, SessionEndedEventArgs e)
{
    if (e.Reason == SessionEndReasons.Logoff)
    {
        await vm.UserLogoff();
    }
}

Có nhiều cách để xử lý thông báo bằng WndProc trong WPF (ví dụ: sử dụng HwndSource, v.v.), nhưng nói chung các kỹ thuật đó được dành riêng cho việc tương tác với các thông báo không thể xử lý trực tiếp thông qua WPF. Hầu hết các điều khiển WPF thậm chí không phải là cửa sổ theo nghĩa Win32 (và theo phần mở rộng là Windows.Forms), vì vậy chúng sẽ không có WndProcs.

WPF không hoạt động trên wndprocs loại WinForms

Bạn có thể lưu trữ một HWndHost trong một phần tử WPF thích hợp sau đó ghi đè lên wndproc của Hwndhost, nhưng AFAIK thì điều đó gần như bạn sẽ nhận được.

http://msdn.microsoft.com/en-us/library/ms742522.aspx

http://blogs.msdn.com/nickkramer/archive/2006/03/18/554235.aspx

Câu trả lời ngắn gọn là bạn không thể. WndProc hoạt động bằng cách chuyển thông điệp tới HWND ở cấp độ Win32. Cửa sổ WPF không có HWND và do đó không thể tham gia vào các thông báo WndProc. Vòng lặp thông báo WPF cơ sở không nằm trên WndProc nhưng nó tóm tắt chúng khỏi logic WPF cốt lõi.

Bạn có thể sử dụng HWndHost và nhận được tại WndProc cho nó. Tuy nhiên điều này gần như chắc chắn không phải là những gì bạn muốn làm. Đối với đa số các mục đích, WPF không hoạt động trên HWND và WndProc. Giải pháp của bạn gần như chắc chắn dựa vào việc thực hiện thay đổi trong WPF không phải trong WndProc.