Wie kann ich Änderungen in der Zwischenablage in C# erkennen?

Echtzeit-Zwischenablageüberwachung mit C#

In diesem Artikel wird gezeigt, wie Sie eine C#-Anwendung erstellen, die Änderungen in der Zwischenablage effizient überwacht. Die Herausforderung besteht darin, zu erkennen, wann der Inhalt der Zwischenablage aktualisiert wird.

Lösung:

Die Verwendung der Windows-Nachrichtenverarbeitung bietet eine robuste Lösung. Dazu gehört:

1. Benutzerdefiniertes Steuerelement: Ein benutzerdefiniertes Steuerelement, das von Control (nicht von Component) erbt, ist entscheidend für den Erhalt eines Fensterhandles. Dieses Handle ist für die Interaktion mit der Windows-Nachrichtenwarteschlange erforderlich.

2. WndProc Override: Die WndProc-Methode fängt Windows-Nachrichten ab. Wir zielen gezielt auf WM_DRAWCLIPBOARD.

3. WM_DRAWCLIPBOARDVerarbeitung: Diese Meldung signalisiert eine Aktualisierung der Zwischenablage. Innerhalb der WndProc-Methode wird beim Empfang von WM_DRAWCLIPBOARD die OnClipboardChanged-Methode aufgerufen.

4. Datenabruf: OnClipboardChanged verwendet Clipboard.GetDataObject(), um die aktualisierten Zwischenablagedaten abzurufen.

5. Ereignisauslöser: Schließlich wird ein benutzerdefiniertes ClipboardChanged Ereignis ausgelöst, das die neuen Daten übergibt.

Hier ist ein Codebeispiel, das die Überwachungssteuerung der Zwischenablage zeigt:

<code class="language-csharp">using System;
using System.ComponentModel;
using System.Runtime.InteropServices;
using System.Windows.Forms;
using System.Drawing;

namespace ClipboardMonitorApp
{
    [DefaultEvent("ClipboardChanged")]
    public class ClipboardMonitor : Control
    {
        private IntPtr nextClipboardViewer;

        public ClipboardMonitor()
        {
            this.BackColor = Color.Red;
            this.Visible = false;
            nextClipboardViewer = SetClipboardViewer((int)this.Handle);
        }

        public event EventHandler<ClipboardChangedEventArgs> ClipboardChanged;

        protected override void Dispose(bool disposing)
        {
            ChangeClipboardChain(this.Handle, nextClipboardViewer);
            base.Dispose(disposing);
        }

        [DllImport("User32.dll")]
        private static extern int SetClipboardViewer(int hWndNewViewer);

        [DllImport("User32.dll", CharSet = CharSet.Auto)]
        private static extern bool ChangeClipboardChain(IntPtr hWndRemove, IntPtr hWndNewNext);

        [DllImport("user32.dll", CharSet = CharSet.Auto)]
        private static extern int SendMessage(IntPtr hwnd, int wMsg, IntPtr wParam, IntPtr lParam);

        protected override void WndProc(ref Message m)
        {
            const int WM_DRAWCLIPBOARD = 0x308;
            const int WM_CHANGECBCHAIN = 0x030D;

            switch (m.Msg)
            {
                case WM_DRAWCLIPBOARD:
                    OnClipboardChanged();
                    SendMessage(nextClipboardViewer, m.Msg, m.WParam, m.LParam);
                    break;
                case WM_CHANGECBCHAIN:
                    if (m.WParam == nextClipboardViewer)
                        nextClipboardViewer = m.LParam;
                    else
                        SendMessage(nextClipboardViewer, m.Msg, m.WParam, m.LParam);
                    break;
                default:
                    base.WndProc(ref m);
                    break;
            }
        }

        private void OnClipboardChanged()
        {
            try
            {
                IDataObject data = Clipboard.GetDataObject();
                ClipboardChanged?.Invoke(this, new ClipboardChangedEventArgs(data));
            }
            catch (Exception ex)
            {
                // Handle exceptions appropriately (e.g., log the error)
                MessageBox.Show(ex.ToString());
            }
        }
    }

    public class ClipboardChangedEventArgs : EventArgs
    {
        public readonly IDataObject DataObject;

        public ClipboardChangedEventArgs(IDataObject dataObject)
        {
            DataObject = dataObject;
        }
    }
}</code>

Dieser verfeinerte Code bietet eine robustere Lösung mit Fehlerbehandlung für die Überwachung von Änderungen in der Zwischenablage in Ihren C#-Anwendungen. Denken Sie daran, potenzielle Ausnahmen in einer Produktionsumgebung angemessen zu behandeln.

Das obige ist der detaillierte Inhalt vonWie kann ich Änderungen in der Zwischenablage in C# erkennen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!