Vererbung

Anhand der folgenden Codebeispiele werden einige Variationen der Verwendung der Vererbung in verwaltetem Code zum Erstellen einer Vererbungshierarchie in WMI dargestellt.

Ereignisvererbung für Klassen, die von "BaseEvent" abgeleitet wurden

Wenn Sie als Entwickler Anwendungsereignisse über WMI offen legen möchten, müssen die Ereignisse von der WMI-Systemklasse __ExtrinsicEvent abgeleitet werden. Wenn Sie eine Klasse von System.Management.Instrumentation.BaseEvent ableiten, stellt die verwaltete Klasse standardmäßig eine WMI-Klasse dar, die von __ExtrinsicEvent abgeleitet wurde. Wenn Sie von eigenen Klassen weitere Klassen ableiten, werden diese in einem Vererbungsbaum mit WMI-Ereignissen gespiegelt.

Alle Ereignisse in der Klassenhierarchie der verwalteten Ereignisse können über verwalteten Code ausgelöst werden. Daher können Clientanwendungen einen umfangreichen Satz ähnlicher Ereignisse oder ein einzelnes hochspezialisiertes Ereignis abonnieren. Wenn Sie beispielsweise über zwei Ereignisklassen (MyBaseEvent und die abgeleitete Klasse MyDerivedEvent) verfügen, ermöglicht es die WQL-Abfrage "SELECT * FROM MyBaseEvent", dass eine Clientanwendung sowohl das von der Anwendung ausgelöste MyBaseEvent-Ereignis als auch das von der Anwendung ausgelöste MyDerivedEvent-Ereignis abfängt. Andererseits kann ein Client, der die WQL-Abfrage "SELECT * FROM MyDerivedEvent" ausgibt, nichts sehen, wenn die Anwendung MyBaseEvent ausgelöst hat. Er empfängt jedoch Ereignisse, wenn die Anwendung MyDerivedEvent auslöst.

Anhand des folgenden Codebeispiels wird dargestellt, wie die Vererbung zum Erstellen einer einfachen WMI-Ereignishierarchie mit der Hilfsklasse BaseEvent verwendet wird. Die Klasse für verwaltete Ereignisse auf der obersten Ebene (TopEvent) wird von einer WMI-Klasse (TopEvent) dargestellt, die von __ExtrinsicEvent abgeleitet wurde. Die TopEvent-Klasse hat zwei untergeordnete Elemente (Branch1Event und Branch2Event). Schließlich verfügt Branch1Event über zwei untergeordnete Elemente (Leaf1AEvent und Leaf1BEvent) und Branch2Event über ein untergeordnetes Element (Leaf2AEvent). Sie können zum Visualisieren dieser Ereignishierarchie das Diagramm im ersten Kommentarblock des Beispiels betrachten. Die am stärksten abgeleiteten Klassen in einer Hierarchie (diejenigen Klassen, die nicht über weiter abgeleitete Klassen verfügen) werden als Endknoten bezeichnet. In Ereignishierarchien spielen Endknoten keine wesentliche Rolle, aber der Unterschied zwischen Endknoten und anderen Knoten spielt bei der Instanzinstrumentation eine entscheidende Rolle.

Zur Vereinfachung verfügen die Ereignisse nicht über Eigenschaften. In der Praxis würden Sie die untergeordnete Klasse wahrscheinlich mit zusätzlichen Eigenschaften erweitern, in dem folgenden Code wird dies jedoch unterlassen, damit das Beispiel nicht zu umfangreich wird.

using System;
using System.Management.Instrumentation;

[assembly:Instrumented]

// A simple tree of events derived from BaseEvent
// TopEvent--Branch1Event--Leaf1AEvent
//          \            \-Leaf1BEvent
//           \
//            Branch2Event--Leaf2AEvent
// Any event in the hierarchy can be raised by the application

// This class inherits the 'InstrumentationType.Event' attribute
// from 'BaseEvent'
public class TopEvent : BaseEvent {
}

// This class inherits the 'InstrumentationType.Event' attribute
public class Branch1Event : TopEvent{
}

// This class inherits the 'InstrumentationType.Event' attribute
public class Leaf1AEvent : Branch1Event {
}

// This class inherits the 'InstrumentationType.Event' attribute
public class Leaf1BEvent : Branch1Event {
}

// This class inherits the 'InstrumentationType.Event' attribute
public class Branch2Event : TopEvent {
}

// This class inherits the 'InstrumentationType.Event' attribute
public class Leaf2AEvent : Branch2Event {
}

class App {
    static void Main(string[] args) {
        // Raise each type of event
        new TopEvent().Fire();
        new Branch1Event().Fire();
        new Leaf1AEvent().Fire();
        new Leaf1BEvent().Fire();
        new Branch2Event().Fire();
        new Leaf2AEvent().Fire();
    }
}

Ereignisvererbung für Klassen, die nicht von BaseEvent abgeleitet wurden

Anstatt die oberste Ereignisklasse von der Hilfsklasse System.Managment.Instrumentation.BaseEvent abzuleiten, kann eine Klasse mit dem Attribut ([InstrumentationClass(InstrumentationType.Event)]) markiert werden. Dies ist nur für die Ereignisklasse der obersten Ebene erforderlich. Klassen, die von einer Klasse mit diesem Attribut abgeleitet wurden, werden auch als instrumentierte Ereignisklassen bezeichnet. Technisch gesehen ist dies möglich, weil das InstrumentationClass-Attribut automatisch an abgeleitete Klassen vererbt wird. Dieses Attribut wird im Beispiel (Ereignisse, die von BaseEvent abgeleitet wurden) eigentlich nicht benötigt, weil BaseEvent selbst über das InstrumentationClass-Attribut verfügt, das an alle untergeordneten Elemente vererbt wird.

Im folgenden Beispiel werden dieselben Aufgaben wie im vorherigen Beispiel ausgeführt, es wird jedoch anstelle einer Ableitung von BaseEvent das InstrumentationClass-Attribut verwendet:

using System;
using System.Management.Instrumentation;

[assembly:Instrumented]

// A simple tree of events declared with attributes
// TopEvent2--Branch1Event2--Leaf1AEvent2
//           \             \-Leaf1BEvent2
//            \
//             Branch2Event2--Leaf2AEvent2
// Any event in the hierarchy can be raised by the application

// This is a top-level event class
[InstrumentationClass(InstrumentationType.Event)]
public class TopEvent2 {
}

// This class inherits the 'InstrumentationType.Event' attribute
public class Branch1Event2 : TopEvent2{
}

// This class inherits the 'InstrumentationType.Event' attribute
public class Leaf1AEvent2 : Branch1Event2 {
}

// This class inherits the 'InstrumentationType.Event' attribute
public class Leaf1BEvent2 : Branch1Event2 {
}

// This class inherits the 'InstrumentationType.Event' attribute
public class Branch2Event2 : TopEvent2 {
}

// This class inherits the 'InstrumentationType.Event' attribute
public class Leaf2AEvent2 : Branch2Event2 {
}

class App {
    static void Main(string[] args) {
        // Raise each type of event
        Instrumentation.Fire(new TopEvent2());
        Instrumentation.Fire(new Branch1Event2());
        Instrumentation.Fire(new Leaf1AEvent2());
        Instrumentation.Fire(new Leaf1BEvent2());
        Instrumentation.Fire(new Branch2Event2());
        Instrumentation.Fire(new Leaf2AEvent2());
    }
}

Instanzvererbung für Klassen, die von "Instance" abgeleitet wurden

Das Erstellen von Instanzhierarchien hat viel Ähnlichkeit mit dem Erstellen von Ereignishierarchien. Der größte Unterschied besteht darin, dass die WMI-Ereignisse der obersten Ebene von der WMI-Klasse __ExtrinsicEvent abgeleitet wurden und die Instanzen der obersten Ebene nicht über übergeordnete Klassen verfügen. Bei der Ausführung der einfachen Instanzinstrumentation durch Ableiten einer einzigen Klasse von der Hilfsklasse System.Management.Instrumentation.Instance erscheint die WMI-Klasse als einfache Instanzklasse der obersten Ebene.

Instanzhierarchien sind jedoch etwas komplexer. In der aktuellen Version von System.Management können nur Endknoten einer Instanzhierarchie die Veröffentlichung von Instanzen tatsächlich unterstützen. Alle anderen Knoten werden als abstrakte WMI-Klassen betrachtet. Das heißt, wenn Sie über zwei Klassen (BaseInstance und eine abgeleitete Klasse DerivedInstance) verfügen, können Sie Instanzen der DerivedInstance-Klasse erstellen, die Erstellung von Instanzen der BaseInstance-Klasse ist jedoch nicht möglich. Eine weitere, häufig verwendete Bezeichnung für Klassen, die Instanzen unterstützen können, lautet "konkrete Klasse". Die Vererbungsregel für die Instanzinstrumentation kann demnach wie folgt beschrieben werden: Nur bei Endknoten von Vererbungshierarchien kann es sich um konkrete Instanzklassen handeln. Alle anderen Knoten der Hierarchie müssen als abstrakte WMI-Klassen markiert werden.

Damit eine Klasse als abstrakte WMI-Instrumentationsklasse markiert werden kann, muss sie über das [InstrumentationClass(InstrumentationType.Abstract)]-Attribut verfügen. Die Hilfsklasse Instance ist mit [InstrumentationClass(InstrumentationType.Instance)] markiert. Diese Markierung wird standardmäßig an untergeordnete Klassen übertragen. Das ist in Ordnung, wenn eine einzelne konkrete Instanzklasse auf der obersten Ebene vorliegt, bei komplexen Hierarchien müssen Sie jedoch der Klasse auf der obersten Ebene das Abstract-Attribut manuell hinzufügen. Anhand des folgenden Beispiels wird eine Hierarchie demonstriert, die diese Technik anwendet. Die oberste Klasse TopInstance wird von Instance abgeleitet und explizit mit Abstract markiert. Die abgeleiteten Klassen, bei denen es sich nicht um Endknoten handelt, erben dieses Attribut ordnungsgemäß (und werden abstrakte WMI-Klassen wie TopInstance sein). Die Endknoten müssen als konkrete Instanzen markiert werden und verfügen daher in ihrer Klassendefinition über explizite Instance-Attribute.

using System;
using System.Management.Instrumentation;

[assembly:Instrumented]

// A simple tree of instances derived from Instance
// TopInstance--Branch1Instance--Leaf1AInstance
//           \                 \-Leaf1BInstance
//            \
//             Branch2Instance--Leaf2AInstance
// Only the leafs of the tree can be concrete instances.
// All other nodes on the tree must be abstract.

// This is a top-level abstract class.  It must have the
// 'InstrumentationType.Abstract' attribute or it would
// inherit the 'Instance' attribute from the base class 'Instance'
[InstrumentationClass(InstrumentationType.Abstract)]
public class TopInstance : Instance {
}

// This class inherits the 'InstrumentationType.Abstract' attribute
public class Branch1Instance : TopInstance {
}

// This is a leaf class which can be concrete
[InstrumentationClass(InstrumentationType.Instance)]
public class Leaf1AInstance : Branch1Instance {
}

// This is a leaf class which can be concrete
[InstrumentationClass(InstrumentationType.Instance)]
public class Leaf1BInstance : Branch1Instance {
}

// This class inherits the 'InstrumentationType.Abstract' attribute
public class Branch2Instance : TopInstance {
}

// This is a leaf class which can be concrete
[InstrumentationClass(InstrumentationType.Instance)]
public class Leaf2AInstance : Branch2Instance {
}

class App {
    static void Main(string[] args) {
        // Publish an instance of each leaf
        Leaf1AInstance leaf1a = new Leaf1AInstance();
        Leaf1BInstance leaf1b = new Leaf1BInstance();
        Leaf2AInstance leaf2a = new Leaf2AInstance();

        leaf1a.Published = true;
        leaf1b.Published = true;
        leaf2a.Published = true;

        // Instances now visible through WMI
        Console.WriteLine("Instances now visible through WMI");
        Console.ReadLine();
        
        // Revoke all instances
        leaf1a.Published = false;
        leaf1b.Published = false;
        leaf2a.Published = false;
    }
}

Instanzvererbung für Klassen, die nicht von "Instance" abgeleitet wurden

Wenn Sie Attribute nur zum Deklarieren von Instanzinstrumentationsklassen verwenden, wird zum Definieren von Hierarchien eine ähnliche Methode verwendet wie bei Instanzinstrumentationsklassen, die von der Hilfsklasse System.Management.Instrumentation.Instance abgeleitet wurden. Die Instanzinstrumentationsklasse auf der obersten Ebene sollte auch hier mit [InstrumentationClass(InstrumentationType.Abstract)] markiert werden, sofern nicht nur eine einzige konkrete Instanzklasse auf der obersten Ebene vorliegt. Die Zweige der Hierarchie erben dieses Attribut, so dass sie nicht explizit ihr eigenes InstrumentationClass-Attribut deklarieren müssen. Der Endknoten muss auch hier explizit als konkrete WMI-Instanzklasse markiert werden und benötigt das [InstrumentationClass(InstrumentationType.Instance)]-Attribut.

Anhand des folgenden Beispiels wird dieselbe Funktionalität dargestellt wie im vorherigen Beispiel. Es wird jedoch nicht die oberste Klasse von der Hilfsklasse Instance abgeleitet, sondern nur das InstrumentationClass-Attribut verwendet.

using System;
using System.Management.Instrumentation;

[assembly:Instrumented]

// A simple tree of instances declared with attributes
// TopInstance2--Branch1Instance2--Leaf1AInstance2
//           \                   \-Leaf1BInstance2
//            \
//             Branch2Instance2--Leaf2AInstance2
// Only the leafs of the tree can be concrete instances.
// All other nodes on the tree must be abstract.

// This is a top level abstract class.
[InstrumentationClass(InstrumentationType.Abstract)]
public class TopInstance2 {
}

// This class inherits the 'InstrumentationType.Abstract' attribute
public class Branch1Instance2 : TopInstance2{
}

// This is a leaf class which can be concrete
[InstrumentationClass(InstrumentationType.Instance)]
public class Leaf1AInstance2 : Branch1Instance2 {
}

// This is a leaf class which can be concrete
[InstrumentationClass(InstrumentationType.Instance)]
public class Leaf1BInstance2 : Branch1Instance2 {
}

// This class inherits the 'InstrumentationType.Abstract' attribute
public class Branch2Instance2 : TopInstance2 {
}

// This is a leaf class which can be concrete
[InstrumentationClass(InstrumentationType.Instance)]
public class Leaf2AInstance2 : Branch2Instance2 {
}

class App {
    static void Main(string[] args) {
        // Publish an instance of each leaf
        Leaf1AInstance2 leaf1a = new Leaf1AInstance2();
        Leaf1BInstance2 leaf1b = new Leaf1BInstance2();
        Leaf2AInstance2 leaf2a = new Leaf2AInstance2();

        Instrumentation.Publish(leaf1a);
        Instrumentation.Publish(leaf1b);
        Instrumentation.Publish(leaf2a);

        // Instances now visible through WMI
        Console.WriteLine("Instances now visible through WMI");
        Console.ReadLine();
        
        // Revoke all instances
        Instrumentation.Revoke(leaf1a);
        Instrumentation.Revoke(leaf1b);
        Instrumentation.Revoke(leaf2a);
    }
}

Siehe auch

Instrumentieren von .NET Framework-Anwendungen mit System.Management | Klassen und Zuordnung in CLI und WMI | Offenlegen von Verwaltungsereignissen | Verfügbarmachen von Verwaltungsdaten | Registrieren des Schemas für eine instrumentierte Anwendung