Gewusst wie: Behandeln von Automatisierungsereignissen (Visual C#)

Artikel
06/10/2015

Die folgende Prozedur veranschaulicht das Behandeln fensterbezogener Ereignisse mithilfe eines Visual C#-Add-Ins.

Hinweis

Je nach den aktiven Einstellungen oder der Version unterscheiden sich die Dialogfelder und Menübefehle auf Ihrem Bildschirm möglicherweise von den in der Hilfe beschriebenen.Bei der Entwicklung dieser Verfahren war die Option Allgemeine Entwicklungseinstellungen aktiviert.Wählen Sie im Menü Extras die Option Einstellungen importieren und exportieren aus, um die Einstellungen zu ändern.Weitere Informationen finden Sie unter Anpassen der Entwicklungseinstellungen in Visual Studio.

So behandeln Sie fensterbezogene Ereignisse mit Visual C#

Erstellen Sie in Visual C# ein Visual Studio-Add-In-Projekt.
Initialisieren Sie in der OnConnection-Methode eine Variable, um Ereignisse abzufangen. Im nachfolgenden Beispiel hat diese Variable den Namen events.
```
EnvDTE.Events events = _applicationObject.Events;
```
Rufen Sie in der OnConnection-Methode die Ereignisobjekte vom Automatisierungsmodell ab.
```
winEvents = (EnvDTE.WindowEvents)events.get_WindowEvents(null);
```
In diesem Beispiel trägt die Variable die Bezeichnung winEvents. Andere Objekte im Automatisierungsmodell beziehen sich auf andere Ereignistypen. So gilt FindEvents für Ereignisse in Bezug auf Suchvorgänge, und TaskListEvents gilt für Ereignisse in Bezug auf die Aufgabenliste. Eine vollständige Liste der verfügbaren Ereignisse finden Sie unter Reagieren auf Automatisierungsereignisse.
Stellen Sie in der OnConnection-Methode eine Verbindung zu den einzelnen Delegaten her, die von den Ereignisobjekten verfügbar gemacht werden, die in Schritt 3 mithilfe des Operators += abgerufen wurden. Um beispielsweise die Verbindung zu Delegaten herzustellen, die vom WindowClosing-Ereignis verfügbar gemacht wurden, verwenden Sie den folgenden Code:
```
winEvents.WindowClosing += new  
_dispWindowEvents_WindowClosingEventHandler(this.WindowClosing);
```
Fügen Sie Verfahren für jedes auf das Ereignisobjekt bezogene Ereignis hinzu. Um beispielsweise das Ereignis zu behandeln, das beim Schließen eines Fensters auftritt (WindowClosing), verwenden Sie folgenden Code:
```
public void WindowClosing(EnvDTE.Window closingWindow)
{
    outputWindowPane.OutputString ("WindowEvents::WindowClosing\n");
    outputWindowPane.OutputString("\tWindow: " + 
    closingWindow.Caption + "\n");
}
```
Beim WindowEvents-Objekt sind Prozeduren für alle Ereignisse erforderlich, und zwar:
Um schließlich zu verhindern, dass Visual Studio nach Schließen des Add-Ins durch die fortdauernde Überwachung fensterbezogener Ereignisse die Systemleistung beeinträchtigt, deaktivieren Sie die Ereignisbehandlung. In Visual C# verwenden Sie dazu den Operator -=. Um beispielsweise die Ereignisbehandlung für WindowClosing zu deaktivieren, verwenden Sie den folgenden Code:
```
public void OnDisconnection(ext_DisconnectMode disconnectMode, 
ref Array custom)
{
    if (winEvents != null)
    {
        winEvents.WindowClosing -= new 
        _dispWindowEvents_WindowClosingEventHandler     
        (this.WindowClosing);
    }
}
```
Dadurch wird die Ereignisbehandlung unabhängig davon deaktiviert, ob das Add-In oder die integrierte Entwicklungsumgebung (Integrated Development Environment – IDE) heruntergefahren wird, während das Add-In ausgeführt wird. Wenn die IDE heruntergefahren wird, werden automatisch alle ausgeführten Add-Ins zuerst beendet.

Beispiel

Das folgende Beispiel mit einem grundlegenden Visual C#-Add-In veranschaulicht das Abfangen und Behandeln fensterbezogener Ereignisse in Visual Studio. Sobald ein fensterbezogenes Ereignis auftritt, wird an das Ausgabefenster eine Benachrichtigung gesendet.

namespace CSEventsAddin
{
    using System;
    using Microsoft.VisualStudio.CommandBars;
    using Extensibility;
    using EnvDTE;
    using EnvDTE80;

    public class Connect : Object, IDTExtensibility2
    {
        public Connect()
        {
        }

        public void OnConnection(object application, ext_ConnectMode 
        connectMode, object addInInst, ref Array custom)
        {
            _applicationObject = (DTE2)application;
            _addInInstance = (AddIn)addInInst;

            // Retrieve the event objects from the automation model.
            EnvDTE.Events events = _applicationObject.Events;
            // Send event messages to the Output window.
            OutputWindow outputWindow = 
            (OutputWindow)_applicationObject.Windows.Item
            (Constants.vsWindowKindOutput).Object;
            outputWindowPane = outputWindow.OutputWindowPanes.Add("DTE 
Event Information");
            // Retrieve the event objects from the automation model.
            winEvents = 
            (EnvDTE.WindowEvents)events.get_WindowEvents(null);

            // Connect to each delegate exposed from each object 
            // retrieved above.
            winEvents.WindowActivated += new 
            _dispWindowEvents_WindowActivatedEventHandler
            (this.WindowActivated);
            winEvents.WindowClosing += new  
            _dispWindowEvents_WindowClosingEventHandler
            (this.WindowClosing);
            winEvents.WindowCreated += new  
            _dispWindowEvents_WindowCreatedEventHandler
            (this.WindowCreated);
            winEvents.WindowMoved += new 
            _dispWindowEvents_WindowMovedEventHandler
            (this.WindowMoved);
        }

        public void OnDisconnection(ext_DisconnectMode disconnectMode, 
        ref Array custom)
        {
            // If the delegate handlers have been connected, then 
            // disconnect them here. 
            // If this is not done, the handlers may still 
            // fire until the next garbage collection event.
            if (winEvents != null)
            {
                winEvents.WindowActivated -= new 
                _dispWindowEvents_WindowActivatedEventHandler
                (this.WindowActivated);
                winEvents.WindowClosing -= new 
                _dispWindowEvents_WindowClosingEventHandler
                (this.WindowClosing);
                winEvents.WindowCreated -= new 
                _dispWindowEvents_WindowCreatedEventHandler
                (this.WindowCreated);
                winEvents.WindowMoved -= new 
                _dispWindowEvents_WindowMovedEventHandler
                (this.WindowMoved);
            }
        }

        // Window-related events.
        public void WindowClosing(EnvDTE.Window closingWindow)
        {
            outputWindowPane.OutputString
("WindowEvents::WindowClosing\n");
            outputWindowPane.OutputString("\tWindow: " + 
closingWindow.Caption + "\n");
        }

        public void WindowActivated(EnvDTE.Window gotFocus,   
        EnvDTE.Window lostFocus)
        {
            outputWindowPane.OutputString
("WindowEvents::WindowActivated\n");
            outputWindowPane.OutputString("\tWindow receiving focus: " 
+ gotFocus.Caption + "\n");
            outputWindowPane.OutputString("\tWindow that lost focus: " 
+ lostFocus.Caption + "\n");
        }

        public void WindowCreated(EnvDTE.Window window)
        {
            outputWindowPane.OutputString
            ("WindowEvents::WindowCreated\n");
            outputWindowPane.OutputString("\tWindow: " + window.Caption 
+ "\n");
        }

        public void WindowMoved(EnvDTE.Window window, int top, int 
        left, int width, int height)
        {
            outputWindowPane.OutputString
            ("WindowEvents::WindowMoved\n");
            outputWindowPane.OutputString("\tWindow: " + window.Caption 
+ "\n");
            outputWindowPane.OutputString("\tLocation: (" + 
top.ToString() + " , " + left.ToString() + " , " + 
width.ToString() + " , " + height.ToString() + ")\n");
        }

        public void OnAddInsUpdate(ref Array custom)
        {
        }

        public void OnStartupComplete(ref Array custom)
        {
        }

        public void OnBeginShutdown(ref Array custom)
        {
        }

        private DTE2 _applicationObject;
        private AddIn _addInInstance;
        private EnvDTE.WindowEvents winEvents;
        private OutputWindowPane outputWindowPane;
    }
}

Kompilieren des Codes

Erstellen Sie zum Kompilieren des Codes ein neues Visual C#-Add-In-Projekt, und ersetzen Sie den Code der Connect-Klasse durch den Code im Beispiel.

Siehe auch

Freigeben über

Gewusst wie: Behandeln von Automatisierungsereignissen (Visual C#)

So behandeln Sie fensterbezogene Ereignisse mit Visual C#

Beispiel

Kompilieren des Codes

Siehe auch

Aufgaben

Referenz

Weitere Ressourcen

Zusätzliche Ressourcen