Evento appunti C #

90

C'è un evento modificato o aggiornato negli Appunti a cui posso accedere tramite C #?

c#  events  clipboard 
— Sevki
fonte
che dire della classe di controllo? Dove è?
Fa parte di WinForms.
— Contango

Risposte:

73

Penso che dovrai usare alcuni p / invoke:

[DllImport("User32.dll", CharSet=CharSet.Auto)]
public static extern IntPtr SetClipboardViewer(IntPtr hWndNewViewer);

Vedere questo articolo su come configurare un monitor appunti in c #

Fondamentalmente registri la tua app come visualizzatore di appunti usando

_ClipboardViewerNext = SetClipboardViewer(this.Handle);

e poi riceverai il WM_DRAWCLIPBOARDmessaggio, che puoi gestire sovrascrivendo WndProc:

protected override void WndProc(ref Message m)
{
    switch ((Win32.Msgs)m.Msg)
    {
        case Win32.Msgs.WM_DRAWCLIPBOARD:
        // Handle clipboard changed
        break;
        // ... 
   }
}

(C'è ancora molto da fare; passare le cose lungo la catena degli appunti e annullare la registrazione della visualizzazione, ma puoi ottenerlo dall'articolo )

— Daniel LeCheminant
fonte
Funziona solo sul primo form aperto ... diciamo se ho MyForm1 e myForm2, quindi apro myForm1, quindi MyForm2, l'evento ClipboardChanged verrà sollevato solo in MyForm1. Voglio dire, in un'applicazione MDI ...
— serhio
Il collegamento è morto. Qualche backup di cui sei a conoscenza? +1 comunque.
— Patrick Hofman
1
Per i pigri: imposta un timer che scatti a 1 ms. Quindi, ad ogni segno di spunta, controlla se il contenuto degli appunti è cambiato. Questi hook stanno generando avvisi di virus e trojan sul mio computer.
— C4d
1
Passa ogni MSG di Windows al modulo e rende così difficile eseguire il debug del codice
Allo stesso modo, SharpClipboard come libreria potrebbe essere di maggior beneficio in quanto incapsula le stesse funzionalità in un'unica libreria di componenti di qualità. È quindi possibile accedere al suo ClipboardChangedevento e rilevare vari formati di dati quando vengono tagliati / copiati.
— Willy Kimura
78

Per completezza, ecco il controllo che sto usando nel codice di produzione. Basta trascinare dal designer e fare doppio clic per creare il gestore di eventi.

using System;
using System.ComponentModel;
using System.Runtime.InteropServices;
using System.Windows.Forms;
using System.Drawing;

namespace ClipboardAssist {

// Must inherit Control, not Component, in order to have Handle
[DefaultEvent("ClipboardChanged")]
public partial class ClipboardMonitor : Control 
{
    IntPtr nextClipboardViewer;

    public ClipboardMonitor()
    {
        this.BackColor = Color.Red;
        this.Visible = false;

        nextClipboardViewer = (IntPtr)SetClipboardViewer((int)this.Handle);
    }

    /// <summary>
    /// Clipboard contents changed.
    /// </summary>
    public event EventHandler<ClipboardChangedEventArgs> ClipboardChanged;

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

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

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

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

    protected override void WndProc(ref System.Windows.Forms.Message m)
    {
        // defined in winuser.h
        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;
        }
    }

    void OnClipboardChanged()
    {
        try
        {
            IDataObject iData = Clipboard.GetDataObject();
            if (ClipboardChanged != null)
            {
                ClipboardChanged(this, new ClipboardChangedEventArgs(iData));
            }

        }
        catch (Exception e)
        {
            // Swallow or pop-up, not sure
            // Trace.Write(e.ToString());
            MessageBox.Show(e.ToString());
        }
    }
}

public class ClipboardChangedEventArgs : EventArgs
{
    public readonly IDataObject DataObject;

    public ClipboardChangedEventArgs(IDataObject dataObject)
    {
        DataObject = dataObject;
    }
}
}
— dbkk
fonte
2
Ottimo lavoro! Tuttavia, il codice di chiamata dell'evento non è thread-safe. È necessario creare una copia locale o avviare l'evento con un delegato vuoto. Hai anche dimenticato la parola chiave 'evento' nella definizione di ClipboardChanged :)
— Ohad Schneider
1
@ohadsc Grazie per le correzioni. Per quanto ne so, WndProc viene chiamato sul thread dell'interfaccia utente. Poiché la classe deriva da Control, i client dovrebbero chiamarla anche sul thread dell'interfaccia utente.
— dbkk
Funziona solo sul primo form aperto ... diciamo se ho MyForm1 e myForm2, quindi apro myForm1, quindi MyForm2, l'evento ClipboardChanged verrà generato solo in MyForm1 ... Voglio dire, in un'applicazione MDI ...
— serhio
In qualche modo la chiamata a SetClipboardViewer imposta il codice di errore Win32 1400: "handle di finestra non valido". Ma funziona ancora. Questo mi sembra un po 'strano.
— metacircolo
1
SharpClipboard come libreria potrebbe essere di maggiore beneficio in quanto incapsula le stesse funzionalità in una libreria di componenti fini. È quindi possibile accedere al suo ClipboardChangedevento e rilevare vari formati di dati quando vengono tagliati / copiati.
— Willy Kimura
26

Ho avuto questa sfida in WPF e ho finito per utilizzare l'approccio descritto di seguito. Per i moduli Windows ci sono esempi eccellenti altrove in questa risposta, come il controllo ClipboardHelper.

Per WPF non possiamo sovrascrivere WndProc, quindi dobbiamo agganciarlo esplicitamente con una chiamata HwndSource AddHook utilizzando il Source da una finestra. Il listener degli appunti utilizza ancora la chiamata di interoperabilità nativa AddClipboardFormatListener.

Metodi nativi:

internal static class NativeMethods
{
    // See http://msdn.microsoft.com/en-us/library/ms649021%28v=vs.85%29.aspx
    public const int WM_CLIPBOARDUPDATE = 0x031D;
    public static IntPtr HWND_MESSAGE = new IntPtr(-3);

    // See http://msdn.microsoft.com/en-us/library/ms632599%28VS.85%29.aspx#message_only
    [DllImport("user32.dll", SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    public static extern bool AddClipboardFormatListener(IntPtr hwnd);
}

Classe Gestione appunti:

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

public class ClipboardManager
{
    public event EventHandler ClipboardChanged;

    public ClipboardManager(Window windowSource)
    {
        HwndSource source = PresentationSource.FromVisual(windowSource) as HwndSource;
        if(source == null)
        {
            throw new ArgumentException(
                "Window source MUST be initialized first, such as in the Window's OnSourceInitialized handler."
                , nameof(windowSource));
        }

        source.AddHook(WndProc);

        // get window handle for interop
        IntPtr windowHandle = new WindowInteropHelper(windowSource).Handle;

        // register for clipboard events
        NativeMethods.AddClipboardFormatListener(windowHandle);
    }

    private void OnClipboardChanged()
    {
        ClipboardChanged?.Invoke(this, EventArgs.Empty);
    }

    private static readonly IntPtr WndProcSuccess = IntPtr.Zero;

    private IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
    {
        if (msg == NativeMethods.WM_CLIPBOARDUPDATE)
        {
            OnClipboardChanged();
            handled = true;
        }

        return WndProcSuccess;
    }
}

Viene utilizzato in una finestra WPF aggiungendo l'evento in OnSourceInitialized o versioni successive come l'evento Window.Loaded o durante l'operazione. (quando abbiamo informazioni sufficienti per utilizzare gli hook nativi):

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
    }

    protected override void OnSourceInitialized(EventArgs e)
    {
        base.OnSourceInitialized(e);

        // Initialize the clipboard now that we have a window soruce to use
        var windowClipboardManager = new ClipboardManager(this);
        windowClipboardManager.ClipboardChanged += ClipboardChanged;
    }

    private void ClipboardChanged(object sender, EventArgs e)
    {
        // Handle your clipboard update here, debug logging example:
        if (Clipboard.ContainsText())
        {
            Debug.WriteLine(Clipboard.GetText());
        }
    }
}

Sto usando questo approccio in un progetto di analisi degli oggetti Path of Exile, poiché il gioco espone le informazioni sugli oggetti tramite gli appunti quando premi Ctrl-C.

https://github.com/ColinDabritz/PoeItemAnalyzer

Spero che questo aiuti qualcuno con la gestione delle modifiche degli appunti di WPF!

— Colin Dabritz
fonte
1
Se qualcuno non sa cosa significa ClipboardChanged?.Invokevedere Utilizzo del nuovo operatore condizionale null in C # 6 , sezione Altri scenari
— marbel82
11

Ok, quindi questo è un vecchio post ma abbiamo trovato una soluzione che sembra molto semplice rispetto all'attuale set di risposte. Stiamo usando WPF e volevamo abilitare e disabilitare i nostri comandi personalizzati (in un ContextMenu) se gli Appunti contengono testo. Esiste già un ApplicationCommands.Cut, Copy e Paste e questi comandi rispondono correttamente alla modifica degli appunti. Quindi abbiamo appena aggiunto il seguente EventHandler.

ApplicationCommands.Paste.CanExecuteChanged += new EventHandler(Paste_CanExecuteChanged);

private void Paste_CanExecuteChanged(object sender, EventArgs e) {
  ourVariable= Clipboard.ContainsText();
}

In questo modo controlliamo CanExecute sul nostro comando. Funziona per ciò di cui avevamo bisogno e forse aiuterà gli altri là fuori.

— Eric
fonte
Ottima soluzione, perché è così semplice ... Grazie!
— okieh
1
Questa è una soluzione fantastica al problema specifico di abilitare o disabilitare il comando incolla. Sfortunatamente non copre lo scenario specifico "il testo è cambiato" e non si attiva quando si copiano più righe di testo diverse, ad esempio.
— Colin Dabritz
11

Ci sono molti modi per farlo, ma questo è il mio preferito e funziona per me. Ho creato una libreria di classi in modo che altri possano aggiungere il progetto e includere la DLL, quindi semplicemente chiamarla e usarla dove vogliono all'interno delle loro applicazioni.

Questa risposta è stata fatta con l'aiuto di questo .

  1. Crea un progetto Libreria di classi e chiamalo ClipboardHelper.
  2. Sostituisci il nome Class1 con ClipboardMonitor.
  3. Aggiungi il codice sottostante.
  4. Aggiungere il riferimento System.Windows.Forms.

Altri passaggi con il codice.

using System;
using System.Windows.Forms;
using System.Threading;
using System.Runtime.InteropServices;

namespace ClipboardHelper
{
    public static class ClipboardMonitor
    {
        public delegate void OnClipboardChangeEventHandler(ClipboardFormat format, object data);
        public static event OnClipboardChangeEventHandler OnClipboardChange;

        public static void Start()
        {
            ClipboardWatcher.Start();
            ClipboardWatcher.OnClipboardChange += (ClipboardFormat format, object data) =>
            {
                if (OnClipboardChange != null)
                    OnClipboardChange(format, data);
            };
        }

        public static void Stop()
        {
            OnClipboardChange = null;
            ClipboardWatcher.Stop();
        }

        class ClipboardWatcher : Form
        {
            // static instance of this form
            private static ClipboardWatcher mInstance;

            // needed to dispose this form
            static IntPtr nextClipboardViewer;

            public delegate void OnClipboardChangeEventHandler(ClipboardFormat format, object data);
            public static event OnClipboardChangeEventHandler OnClipboardChange;

            // start listening
            public static void Start()
            {
                // we can only have one instance if this class
                if (mInstance != null)
                    return;

                var t = new Thread(new ParameterizedThreadStart(x => Application.Run(new ClipboardWatcher())));
                t.SetApartmentState(ApartmentState.STA); // give the [STAThread] attribute
                t.Start();
            }

            // stop listening (dispose form)
            public static void Stop()
            {
                mInstance.Invoke(new MethodInvoker(() =>
                {
                    ChangeClipboardChain(mInstance.Handle, nextClipboardViewer);
                }));
                mInstance.Invoke(new MethodInvoker(mInstance.Close));

                mInstance.Dispose();

                mInstance = null;
            }

            // on load: (hide this window)
            protected override void SetVisibleCore(bool value)
            {
                CreateHandle();

                mInstance = this;

                nextClipboardViewer = SetClipboardViewer(mInstance.Handle);

                base.SetVisibleCore(false);
            }

            [DllImport("User32.dll", CharSet = CharSet.Auto)]
            private static extern IntPtr SetClipboardViewer(IntPtr 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);

            // defined in winuser.h
            const int WM_DRAWCLIPBOARD = 0x308;
            const int WM_CHANGECBCHAIN = 0x030D;

            protected override void WndProc(ref Message m)
            {
                switch (m.Msg)
                {
                    case WM_DRAWCLIPBOARD:
                        ClipChanged();
                        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;
                }
            }

            static readonly string[] formats = Enum.GetNames(typeof(ClipboardFormat));

            private void ClipChanged()
            {
                IDataObject iData = Clipboard.GetDataObject();

                ClipboardFormat? format = null;

                foreach (var f in formats)
                {
                    if (iData.GetDataPresent(f))
                    {
                        format = (ClipboardFormat)Enum.Parse(typeof(ClipboardFormat), f);
                        break;
                    }
                }

                object data = iData.GetData(format.ToString());

                if (data == null || format == null)
                    return;

                if (OnClipboardChange != null)
                    OnClipboardChange((ClipboardFormat)format, data);
            }
        }
    }

    public enum ClipboardFormat : byte
    {
        /// <summary>Specifies the standard ANSI text format. This static field is read-only.
        /// </summary>
        /// <filterpriority>1</filterpriority>
        Text,
        /// <summary>Specifies the standard Windows Unicode text format. This static field
        /// is read-only.</summary>
        /// <filterpriority>1</filterpriority>
        UnicodeText,
        /// <summary>Specifies the Windows device-independent bitmap (DIB) format. This static
        /// field is read-only.</summary>
        /// <filterpriority>1</filterpriority>
        Dib,
        /// <summary>Specifies a Windows bitmap format. This static field is read-only.</summary>
        /// <filterpriority>1</filterpriority>
        Bitmap,
        /// <summary>Specifies the Windows enhanced metafile format. This static field is
        /// read-only.</summary>
        /// <filterpriority>1</filterpriority>
        EnhancedMetafile,
        /// <summary>Specifies the Windows metafile format, which Windows Forms does not
        /// directly use. This static field is read-only.</summary>
        /// <filterpriority>1</filterpriority>
        MetafilePict,
        /// <summary>Specifies the Windows symbolic link format, which Windows Forms does
        /// not directly use. This static field is read-only.</summary>
        /// <filterpriority>1</filterpriority>
        SymbolicLink,
        /// <summary>Specifies the Windows Data Interchange Format (DIF), which Windows Forms
        /// does not directly use. This static field is read-only.</summary>
        /// <filterpriority>1</filterpriority>
        Dif,
        /// <summary>Specifies the Tagged Image File Format (TIFF), which Windows Forms does
        /// not directly use. This static field is read-only.</summary>
        /// <filterpriority>1</filterpriority>
        Tiff,
        /// <summary>Specifies the standard Windows original equipment manufacturer (OEM)
        /// text format. This static field is read-only.</summary>
        /// <filterpriority>1</filterpriority>
        OemText,
        /// <summary>Specifies the Windows palette format. This static field is read-only.
        /// </summary>
        /// <filterpriority>1</filterpriority>
        Palette,
        /// <summary>Specifies the Windows pen data format, which consists of pen strokes
        /// for handwriting software, Windows Forms does not use this format. This static
        /// field is read-only.</summary>
        /// <filterpriority>1</filterpriority>
        PenData,
        /// <summary>Specifies the Resource Interchange File Format (RIFF) audio format,
        /// which Windows Forms does not directly use. This static field is read-only.</summary>
        /// <filterpriority>1</filterpriority>
        Riff,
        /// <summary>Specifies the wave audio format, which Windows Forms does not directly
        /// use. This static field is read-only.</summary>
        /// <filterpriority>1</filterpriority>
        WaveAudio,
        /// <summary>Specifies the Windows file drop format, which Windows Forms does not
        /// directly use. This static field is read-only.</summary>
        /// <filterpriority>1</filterpriority>
        FileDrop,
        /// <summary>Specifies the Windows culture format, which Windows Forms does not directly
        /// use. This static field is read-only.</summary>
        /// <filterpriority>1</filterpriority>
        Locale,
        /// <summary>Specifies text consisting of HTML data. This static field is read-only.
        /// </summary>
        /// <filterpriority>1</filterpriority>
        Html,
        /// <summary>Specifies text consisting of Rich Text Format (RTF) data. This static
        /// field is read-only.</summary>
        /// <filterpriority>1</filterpriority>
        Rtf,
        /// <summary>Specifies a comma-separated value (CSV) format, which is a common interchange
        /// format used by spreadsheets. This format is not used directly by Windows Forms.
        /// This static field is read-only.</summary>
        /// <filterpriority>1</filterpriority>
        CommaSeparatedValue,
        /// <summary>Specifies the Windows Forms string class format, which Windows Forms
        /// uses to store string objects. This static field is read-only.</summary>
        /// <filterpriority>1</filterpriority>
        StringFormat,
        /// <summary>Specifies a format that encapsulates any type of Windows Forms object.
        /// This static field is read-only.</summary>
        /// <filterpriority>1</filterpriority>
        Serializable,
    }
}
  1. Negli altri progetti fai clic con il pulsante destro del mouse su soluzione e Aggiungi -> Uscita dal progetto -> ClipboardHelper.csproj
  2. Nel tuo progetto vai su e fai clic con il pulsante destro del mouse su Riferimenti -> Aggiungi riferimento -> Soluzione -> Seleziona ClipboardHelper.
  3. Nel file di classe del tipo di progetto utilizzando ClipboardHelper.

  4. È ora possibile digitare ClipboardMonitor.Start o .Stop o .OnClipboardChanged

    using ClipboardHelper;

namespace Something.Something.DarkSide
{
    public class MainWindow
    {

        public MainWindow()
        {
            InitializeComponent();

            Loaded += MainWindow_Loaded;
        }

        void MainWindow_Loaded(object sender, RoutedEventArgs e)
        {
            ClipboardMonitor.OnClipboardChange += ClipboardMonitor_OnClipboardChange;
            ClipboardMonitor.Start();
        }               

        private void ClipboardMonitor_OnClipboardChange(ClipboardFormat format, object data)
        {
            // Do Something...
        }
}
— AzzamAziz
fonte
6

Credo che una delle soluzioni precedenti non verifichi la presenza di un valore nullo nel metodo dispose:

using System;
using System.ComponentModel;
using System.Runtime.InteropServices;
using System.Windows.Forms;
using System.Drawing;

namespace ClipboardAssist {

// Must inherit Control, not Component, in order to have Handle
[DefaultEvent("ClipboardChanged")]
public partial class ClipboardMonitor : Control 
{
    IntPtr nextClipboardViewer;

    public ClipboardMonitor()
    {
        this.BackColor = Color.Red;
        this.Visible = false;

        nextClipboardViewer = (IntPtr)SetClipboardViewer((int)this.Handle);
    }

    /// <summary>
    /// Clipboard contents changed.
    /// </summary>
    public event EventHandler<ClipboardChangedEventArgs> ClipboardChanged;

    protected override void Dispose(bool disposing)
    {
        if(nextClipboardViewer != null)
            ChangeClipboardChain(this.Handle, nextClipboardViewer);
    }

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

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

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

    protected override void WndProc(ref System.Windows.Forms.Message m)
    {
        // defined in winuser.h
        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;
        }
    }

    void OnClipboardChanged()
    {
        try
        {
            IDataObject iData = Clipboard.GetDataObject();
            if (ClipboardChanged != null)
            {
                ClipboardChanged(this, new ClipboardChangedEventArgs(iData));
            }

        }
        catch (Exception e)
        {
            // Swallow or pop-up, not sure
            // Trace.Write(e.ToString());
            MessageBox.Show(e.ToString());
        }
    }
}

    public class ClipboardChangedEventArgs : EventArgs
    {
        public readonly IDataObject DataObject;

        public ClipboardChangedEventArgs(IDataObject dataObject)
        {
            DataObject = dataObject;
        }
    }
}
— SamFisher83
fonte
Non è mai nullo perché il costruttore lo imposta. L'unica cosa che farei diversamente è chiamare base.Dispose()nel metodo dispose.
— jedmao
Comunque. Per scopi di verifica come quello che hai elencato, dovresti usare IntPtr.Zero per NULL (nota che non è equivalente al null in C #) stackoverflow.com/questions/1456861/…
— walter
1
ChangeClipboardChain viene eseguito sempre all'uscita in tutti i campioni msdn
— walter
Lo scopo è quello di rimuovere se stesso dalla catena del visualizzatore degli appunti
— walter
5

SharpClipboard come libreria potrebbe essere di maggiore beneficio in quanto incapsula le stesse funzionalità in una libreria di componenti fini. È quindi possibile accedere al suo fileClipboardChanged evento e rilevare vari formati di dati quando vengono tagliati / copiati.

Puoi scegliere i vari formati di dati che desideri monitorare:

var clipboard = new SharpClipboard();

clipboard.ObservableFormats.Texts = true;
clipboard.ObservableFormats.Files = true;
clipboard.ObservableFormats.Images = true;
clipboard.ObservableFormats.Others = true;

Ecco un esempio che utilizza il suo ClipboardChangedevento:

private void ClipboardChanged(Object sender, ClipboardChangedEventArgs e)
{
    // Is the content copied of text type?
    if (e.ContentType == SharpClipboard.ContentTypes.Text)
    {
        // Get the cut/copied text.
        Debug.WriteLine(clipboard.ClipboardText);
    }

    // Is the content copied of image type?
    else if (e.ContentType == SharpClipboard.ContentTypes.Image)
    {
        // Get the cut/copied image.
        Image img = clipboard.ClipboardImage;
    }

    // Is the content copied of file type?
    else if (e.ContentType == SharpClipboard.ContentTypes.Files)
    {
        // Get the cut/copied file/files.
        Debug.WriteLine(clipboard.ClipboardFiles.ToArray());

        // ...or use 'ClipboardFile' to get a single copied file.
        Debug.WriteLine(clipboard.ClipboardFile);
    }

    // If the cut/copied content is complex, use 'Other'.
    else if (e.ContentType == SharpClipboard.ContentTypes.Other)
    {
        // Do something with 'e.Content' here...
    }
}

Puoi anche scoprire l'applicazione su cui si è verificato l'evento di taglio / copia insieme ai suoi dettagli:

private void ClipboardChanged(Object sender, SharpClipboard.ClipboardChangedEventArgs e)
{
    // Gets the application's executable name.
    Debug.WriteLine(e.SourceApplication.Name);
    // Gets the application's window title.
    Debug.WriteLine(e.SourceApplication.Title);
    // Gets the application's process ID.
    Debug.WriteLine(e.SourceApplication.ID.ToString());
    // Gets the application's executable path.
    Debug.WriteLine(e.SourceApplication.Path);
}

Ci sono anche altri eventi come il MonitorChanged evento che ascolta ogni volta che il monitoraggio degli appunti è disabilitato, il che significa che puoi abilitare o disabilitare il monitoraggio degli appunti in fase di esecuzione.

Oltre a tutto ciò, poiché è un componente, puoi usarlo in Designer View trascinandolo e rilasciandolo in un Windows Form, rendendo estremamente facile per chiunque personalizzare le sue opzioni e lavorare con i suoi eventi incorporati.

SharpClipboard sembra essere l'opzione migliore per gli scenari di monitoraggio degli appunti in .NET.

— Willy Kimura
fonte
0 
        [DllImport("User32.dll", CharSet = CharSet.Auto)]
        public static extern IntPtr SetClipboardViewer(IntPtr hWndNewViewer);
        private IntPtr _ClipboardViewerNext;

        private void Form1_Load(object sender, EventArgs e)
        {
            _ClipboardViewerNext = SetClipboardViewer(this.Handle);
        }

        protected override void WndProc(ref System.Windows.Forms.Message m)
        {
            const int WM_DRAWCLIPBOARD = 0x308;

            switch (m.Msg)
            {
                case WM_DRAWCLIPBOARD:
                    //Clipboard is Change 
                    //your code..............
                    break; 
                default:
                    base.WndProc(ref m);
                    break;
            }
        }
— Hossein Hajizadeh
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.