Herencia

En los ejemplos de código siguientes se muestran algunas de las ligeras variaciones que se pueden dar en la utilización de la herencia en código administrado con el fin de crear una jerarquía de herencia en WMI.

Herencia de eventos para clases derivadas de BaseEvent

Cuando los programadores desean exponer eventos de aplicaciones a través de WMI, tienen que derivar los eventos de la clase __ExtrinsicEvent del sistema WMI. De manera predeterminada, al derivar una clase de System.Management.Instrumentation.BaseEvent, su clase administrada representará a una clase WMI derivada de __ExtrinsicEvent. Si deriva otras clases de su propia clase, se reflejarán en un árbol de herencia de eventos WMI.

Con código administrado se puede generar cualquier evento de la jerarquía de clases de evento administradas. De este modo, las aplicaciones cliente pueden suscribirse a una amplia gama de eventos similares o a un sólo evento especializado. Por ejemplo, si tiene dos clases de evento, MyBaseEvent y una clase derivada MyDerivedEvent, la consulta WQL "SELECT * FROM MyBaseEvent" permitirá que una aplicación cliente detecte ambos eventos, MyBaseEvent y MyDerivedEvent, generados desde su aplicación. Por otro lado, un cliente que emita la consulta WQL "SELECT * FROM MyDerivedEvent" no vería nada cuando su aplicación generara MyBaseEvent, pero obtendría eventos cuando la aplicación generara MyDerivedEvent.

En el ejemplo de código siguiente se muestra cómo usar la herencia para crear una jerarquía de eventos WMI sencilla mediante la clase ayudante BaseEvent. La clase de evento administrada de alto nivel, TopEvent, está representada por una clase WMI, TopEvent, derivada de __ExtrinsicEvent. La clase TopEvent tendrá dos clases secundarias: Branch1Event y Branch2Event. Por último, habrá dos clases secundarias de Branch1Event (Leaf1AEvent y Leaf1BEvent), y una secundaria de Branch2Event (Leaf2AEvent). Para ver esta jerarquía de eventos, puede examinar el diagrama del primer bloque de comentarios del ejemplo. Las clases más derivadas de una jerarquía (aquéllas que no tienen ninguna clase derivada) se denominan nodos hoja. Los nodos hoja no son especialmente importantes para las jerarquías de eventos, pero la distinción entre ellos y los demás desempeña un papel importante para el instrumental de instancias.

Para que resulte más simple, los eventos no tienen propiedades. En la práctica, lo más probable es que extienda cada clase secundaria con propiedades adicionales, pero en el siguiente código se han omitido para acortarlo.

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();
    }
}

Herencia de eventos para clases no derivadas de BaseEvent

Como alternativa a la opción de derivar las clases de evento superiores de la clase ayudante System.Managment.Instrumentation.BaseEvent, los programadores pueden marcar una clase con el atributo [InstrumentationClass(InstrumentationType.Event)]. Sólo hace falta hacerlo en la clase de evento de nivel superior. Las clases derivadas de una clase con este atributo también se interpretarán como clases de evento instrumentadas. Esto es posible porque el atributo InstrumentationClass se hereda automáticamente en las clases derivadas. De hecho, este atributo no hacía falta en el ejemplo (los eventos se derivan de BaseEvent) porque la propia clase BaseEvent tiene el atributo InstrumentationClass que pasa en herencia a todas sus clases secundarias.

En el ejemplo siguiente se realizan las mismas tareas que en el anterior, pero se utiliza el atributo InstrumentationClass en lugar de la derivación de BaseEvent:

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());
    }
}

Herencia de instancias para clases derivadas de Instance

La creación de jerarquías de instancias se parece mucho a la creación de jerarquías de eventos. La principal diferencia es que los eventos WMI de nivel superior se derivan de la clase WMI __ExtrinsicEvent, mientras que las instancias de nivel superior no tienen clase primaria (o superclase, según la terminología de WMI). Al generar instrumental de instancias mediante la sencilla técnica de derivar una sola clase de la clase ayudante System.Management.Instrumentation.Instance, la clase WMI aparece como una sola clase de instancia de nivel superior.

Las jerarquías de instancias, sin embargo, son algo más complejas. En la versión actual de System.Management, sólo los nodos hoja de una jerarquía de instancias pueden permitir en realidad la publicación de instancias. Los nodos que no son hoja se consideran clases WMI abstractas. En otras palabras, si tiene dos clases, BaseInstance y una clase derivada DerivedInstance, puede crear instancias de la clase DerivedInstance pero no de la clase BaseInstance. Otro término utilizado con frecuencia para describir las clases que pueden admitir instancias es clase concreta. Por lo tanto, la regla de herencia para el instrumental de instancias podría expresarse de la siguiente manera: sólo los nodos hoja de una jerarquía de herencias pueden ser clases concretas de instancia. El resto de los nodos de la jerarquía deben marcarse como clases WMI abstractas.

Para marcar una clase como clase de instrumental WMI abstracta, debe tener el atributo [InstrumentationClass(InstrumentationType.Abstract)]. La clase ayudante Instance se marca con [InstrumentationClass(InstrumentationType.Instance)], que se propaga a clases secundarias de manera predeterminada. Esto no constituye un problema cuando se tiene una clase de instancia concreta de nivel superior pero, con una jerarquía más compleja, tiene que agregar manualmente el atributo Abstract a la clase de nivel superior. En el ejemplo siguiente se muestra una jerarquía que usa esta técnica. La clase de nivel superior, TopInstance, se deriva de Instance y se marca explícitamente con Abstract. Las clases derivadas que no son nodos hoja heredarán correctamente este atributo (y serán clases WMI abstractas como TopInstance). Los nodos hoja tienen que marcarse como instancias concretas y, por lo tanto, tendrán atributos Instance explícitos en sus definiciones de clase.

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;
    }
}

Herencia de instancias para clases no derivadas de Instance

Si sólo utiliza atributos para declarar clases de instrumental de instancia, las jerarquías se definen igual al método utilizado para las clases de instrumental derivadas de la clase ayudante System.Management.Instrumentation.Instance. De nuevo, la clase de instrumental de instancia de nivel superior se debe marcar con [InstrumentationClass(InstrumentationType.Abstract)], a menos que sólo haya una clase de instancia concreta de nivel superior. Las ramas de la jerarquía heredarán este atributo, así que no tienen que declarar explícitamente su propio atributo InstrumentationClass. En este caso, los nodos hoja también se deben marcar explícitamente como clases de instancia WMI concretas y necesitarán el atributo [InstrumentationClass(InstrumentationType.Instance)].

En el ejemplo siguiente se muestra la misma funcionalidad que en el anterior, pero se usa sólo el atributo InstrumentationClass en lugar de derivar la clase de nivel superior de la clase ayudante Instance.

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);
    }
}

Vea también

Instrumentar aplicaciones de .NET Framework con System.Management | Clases y asignación en CLI y WMI | Exponer eventos de administración | Exponer datos de administración | Registrar el esquema de una aplicación instrumentada