Gewusst wie: Behandeln von Automatisierungsereignissen (Visual C#)

Aktualisiert: November 2007

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

Hinweis:

Je nach den aktiven Einstellungen oder der verwendeten Version können sich die angezeigten Dialogfelder und Menübefehle von den in der Hilfe beschriebenen unterscheiden. Bei der Entwicklung dieser Prozeduren war die Option Allgemeine Entwicklungseinstellungen aktiviert. Sie können die Einstellungen ändern, indem Sie im Menü Extras auf Einstellungen importieren und exportieren klicken. Weitere Informationen finden Sie unter Visual Studio-Einstellungen.

So behandeln Sie fensterbezogene Ereignisse mit Visual C#

1. Erstellen Sie in Visual C# ein Visual Studio-Add-In-Projekt.

2. 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;
   

3. 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.

4. 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);
   

5. Fügen Sie Prozeduren 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:

   • WindowActivated

   • WindowClosing

   • WindowCreated

   • WindowMoved

6. 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# wird dazu der -=-Operator verwendet. 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

Um den Code zu kompilieren, erstellen Sie ein neues Visual C#-Add-In-Projekt und ersetzen den Code der Connect-Klasse durch den Code im Beispiel.

Siehe auch

Aufgaben

Gewusst wie: Behandeln von Automatisierungsereignissen (Visual Basic)

Referenz

Operator += (C#-Referenz)

Weitere Ressourcen

Reagieren auf Automatisierungsereignisse

Reagieren auf Ereignisse (Visual Basic- und Visual C#-Projekte)