Trabajar con archivos XML de módulo de administración de Service ManagerWork with Service Manager management pack XML files

Se aplica a: System Center 2016 - Service ManagerApplies To: System Center 2016 - Service Manager

Para personalizaciones más elaboradas de módulos de administración, la consola de Service Manager y Service Manager Authoring Tool no sean suficientes y tendrá que crear o modificar directamente los archivos de módulo de administración.For elaborate customizations of management packs, the Service Manager console and the Service Manager Authoring Tool might not be sufficient, and you might need to author or modify management pack files directly. Para trabajar directamente con los archivos de módulo de administración se requiere en-conocer exhaustivamente en diversas áreas, como el esquema común de System Center y la estructura de módulos de administración.Working directly with management pack files requires in-depth knowledge in several areas, such as the System Center Common Schema and the structure of management packs.

Esta sección proporciona información general e instrucciones que pueden ayudar a crear y modificar módulos de administración para personalizar Service Manager.This section provides background information and guidelines that can help you author and modify management packs to customize Service Manager.

Cambios en el esquema común de System CenterChanges to the System Center Common Schema

Service Manager incluye una versión actualizada del esquema del módulo de administración de System Center.Service Manager includes an updated version of the System Center Management Pack Schema. Este esquema ahora se denomina esquema común de System Center, e incluye una serie de mejoras y adiciones que se ha diseñado para mejorar la funcionalidad existente y habilitar las características de Service Manager.This schema is now called the System Center Common Schema, and it includes a number of improvements and additions that are intended to enhance existing functionality and enable Service Manager features. En este tema se describen los cambios realizados en el esquema común de System Center.This topic describes the changes to the System Center Common Schema.

Propiedades y restricciones de propiedadProperties and property restrictions


El esquema común extiende las clases a través de varios tipos de propiedad.The common schema extends classes through several new property types. Estos tipos de propiedad incluyen los tipos binario, de enumerador y de incremento automático.These property types include the binary, enumerator, and autoincrement types.

Además, puede definir restricciones en determinados valores de propiedad.In addition, you can define restrictions on certain property values. Por ejemplo, puede definir una restricción de expresiones regulares en un valor de propiedad de cadena.For example, you can define a regular expression restriction on a string property value. En el siguiente ejemplo, la propiedad BuildingName tiene una restricción de expresiones regulares que se define de tal modo que solo se consideran válidos los valores que tengan la palabra "Building" seguida de un espacio y un número.In the following example, the BuildingName property has a regular expression restriction that is defined so that only a value that contains the word "Building" followed by a space and a number is considered valid.


<ClassType ID="Lobby" Accessibility="Public" Base="System!System.Entity">  
   <Property ID="Id" Type="int" Key="true" />  
   <Property ID="BuildingName" Type="string" RegEx="Building [0-9]+" />  
</ClassType>  

ImágenesImages


Las imágenes no se almacenan en un módulo de administración.Images are not stored inside a management pack. Por lo tanto, la <PresentationTypes> sección del módulo de administración ya no contiene el <Images>, <Image>, o <ImageData> etiquetas.Therefore, the <PresentationTypes> section of the management pack no longer contains the <Images>, <Image>, or <ImageData> tags. En su lugar, utilice un recurso de imagen.Instead, use an image resource.

<Resources>  
   <Image ID="TestLibrary.Resources.Image1" Accessibility="Public" FileName="image.png"/>  
</Resources>  

EnumeracionesEnumerations


El esquema común admite las enumeraciones.The common schema supports enumerations. Las enumeraciones son un árbol de valores que puede utilizar para restringir el valor de una propiedad o atributo.Enumerations are a tree of values that you can use to restrict the value of a property or attribute.

Cada enumeración tiene un atributo ID único requerido y un atributo Parent opcional.Each enumeration has a required unique ID attribute and an optional Parent attribute.

En el ejemplo siguiente, la XBoxState enumeración se define con tres valores posibles: En ejecución, detenido y Error.In the following example, the XBoxState enumeration is defined with three possible values: Running, Stopped, and Error.


<EnumerationTypes>  
   <EnumerationValue ID="XBoxState" Accessibility="Public"/>  
   <EnumerationValue ID="XBoxState.Running" Parent="XBoxState" Accessibility="Public"/>  
  <EnumerationValue ID="XBoxState.Stopped" Parent="XBoxState" Accessibility="Public"/>  
   <EnumerationValue ID="XBoxState.Error" Parent="XBoxState" Accessibility="Public" />  
   <EnumerationValue ID="XBoxState.Error.RROD" Parent="XBoxState.Error" Accessibility="Public" />  
</EnumerationTypes>  

En el siguiente ejemplo, la clase Xbox define una propiedad enum del tipo XBoxState.In the following example, the Xbox class defines an enum property of type XBoxState.


<ClassType ID="XBox" Accessibility="Public" Base="System!System.ConfigItem" Hosted="true">  
   <Property ID="Id" Type="int" Key="true" />  
   <Property ID="Name" Type="string" />  
   <Property ID="State" Type="enum" EnumType="XBoxState" />  
</ClassType>  

RelacionesRelationships


La funcionalidad de las definiciones de relaciones se ha mejorado en el esquema común.The functionality of relationship definitions has been enhanced in the common schema. El tipo RelationshipType ahora tiene los subelementos Source y Target con las propiedades ID que se pueden usar como nombres para mostrar.The RelationshipType type now has Source and Target subelements with ID properties that can be used as display names. Además, puede definir la cardinalidad mínima y máxima para el origen y el destino (por ejemplo, 1-a-1 ó 0-a-muchas relaciones).In addition, you can define minimum and maximum cardinality for both the source and target (for example, 1-to-1 or 0-to-many relationships).

La cardinalidad no la exige el proceso de validación del módulo de administración, pero se diseñó para ayudar a definir las interfaces de usuario del módulo de administración.Cardinality is not enforced by the management pack validation process, but it is intended to help define user interfaces for the management pack. Por ejemplo, se puede comprobar la cardinalidad para determinar si un cuadro de texto o una lista pueden representar un campo en un formulario.For example, cardinality can be checked to determine whether a field can be represented in a form by a text box or by a list.

Importante

Todos los valores de MaxCardinality que se definan como mayores que 1 se procesan como ilimitados.Any MaxCardinality value that is defined as greater than 1 is processed as unlimited.

Si agrega un nuevo tipo de relación desde su propio módulo de administración, los usuarios deben tener privilegios suficientes para actualizar todas las propiedades de las instancias de la clase de origen y de destino del tipo de relación, con el fin de crear una instancia del nuevo tipo de relación.If you add a new relationship type from your own management pack, users must have sufficient privileges to update all properties of the source and target class instances of the relationship type in order to create an instance of the new relationship type.

En el ejemplo siguiente, una relación de hospedaje (llama HasXboxes ) entre el vestíbulo tipo y la Xbox tipo está definido.In the following example, a hosting relationship (called HasXboxes) between the Lobby type and the Xbox type is defined. En la definición de esta relación, cada tipo Lobby puede tener varios tipos Xbox .In this relationship definition, each Lobby type can have multiple Xbox types.


<RelationshipType ID="HasXBboxes" Accessibility="Public" Base="System!System.Hosting">  
   <Source ID="Source" Type="Lobby" />  
   <Target ID="Target" Type="Xbox" MinCardinality="0" MaxCardinality="9999" />  
</RelationshipType>  

Clases de combinaciónCombination classes


Clases de combinación representan una agregación de varios tipos relacionados en el módulo de administración, similar a las vistas que se definen en Microsoft SQL base de datos de servidor que puede devolver datos de varias tablas.Combination classes represent an aggregation of multiple related types in the management pack, similar to views that are defined in a Microsoft SQL Server database that can return data from multiple tables. Las clases de combinación almacenan y recuperar todos los datos agregados en una sola operación a la base de datos y pueden facilitar al módulo de administración la definición de interfaces de usuario.Combination classes store and retrieve all the aggregated data in one operation to the database, and they can make it easier to define user interfaces for a management pack.

En el ejemplo siguiente, se define una proyección para una vista de administración de incidentes.In the following example, a projection is defined for an incident management view. Esta proyección combina varios componentes que están relacionados con un incidente para formar una unidad que se pueda utilizar más fácilmente en formularios y operaciones de bases de datos.This projection combines several different components that are related to an incident into one unit that can be used more easily for forms and for database operations.


<TypeProjections>  
   <TypeProjection ID="System.WorkItem.Incident.View.ProjectionType"  
      Accessibility="Public" Type="Incident!System.WorkItem.Incident">  
      <Component Alias="AffectedUser"  
Path="$Target/Path[Relationship='SMCore!System.WorkItemCreatedForUser']$"/>  
      <Component Alias="AssignedUser" Path="$Target/Path[Relationship='SMCore!System.WorkItemAssignedToUser']$"/>  
   </TypeProjection>  
   <TypeProjection ID="System.WorkItem.Incident.View.DCMProjectionType" Accessibility="Public" Type="Incident!System.WorkItem.Incident.DCMIncident">  
      <Component Alias="AffectedUser" Path="$Target/Path[Relationship='SMCore!System.WorkItemCreatedForUser']$"/>  
      <Component Alias="AssignedUser" Path="$Target/Path[Relationship='SMCore!System.WorkItemAssignedToUser']$"/>  
      <!--Baseline and Configuration Item Information-->  
      <Component Alias="AffectedComputer" Path="$Target/Path[Relationship='Incident!System.WorkItem.Incident.DCMIncident.Refers.NonComplianceComputer']$"/>  
   </TypeProjection>  
   <TypeProjection ID="System.WorkItem.ChangeRequestViewProjection" Accessibility="Public" Type="System.WorkItem.ChangeRequest">  
      <Component Alias="AssignedTo" Path="$Target/Path[Relationship='SMCore!System.WorkItemAssignedToUser']$"/>  
   </TypeProjection>  
   <TypeProjection ID="System.WorkItem.ChangeRequestProjection" Accessibility="Public" Type="System.WorkItem.ChangeRequest">  
      <Component Alias="Activity" Path="$Target/Path[Relationship='SMActivity!System.WorkItemContainsActivity']$">  
         <Component Alias="ActivityAssignedTo" Path="$Target/Path[Relationship='SMCore!System.WorkItemAssignedToUser']$"/>  
         <Component Alias="ActivityRelatedWorkItem" Path="$Target/Path[Relationship='SMCore!System.WorkItemRelatesToWorkItem']$">  
            <Component Alias="ActivityRelatedWorkItemAssignedTo" Path="$Target/Path[Relationship='SMCore!System.WorkItemAssignedToUser']$"/>  
         </Component>  
         <Component Alias="ActivityRelatedConfigItem" Path="$Target/Path[Relationship='SMCore!System.WorkItemRelatesToConfigItem']$"/>  
         <Component Alias="ActivityAboutConfigItem" Path="$Target/Path[Relationship='System!System.WorkItemAboutConfigItem']$"/>  
         <Component Alias="ActivityFileAttachment" Path="$Target/Path[Relationship='System!System.WorkItemHasFileAttachment']$">  
            <Component Alias="ActivityFileAttachmentAddedBy" Path="$Target/Path[Relationship='System!System.FileAttachmentAddedByUser']$"/>  
         </Component>  
         <Component Alias="Reviewer" Path="$Target/Path[Relationship='SMActivity!System.ReviewActivityHasReviewer']$">  
            <Component Alias="User" Path="$Target/Path[Relationship='SMActivity!System.ReviewerIsUser']$"/>  
            <Component Alias="VotedBy" Path="$Target/Path[Relationship='SMActivity!System.ReviewerVotedByUser']$"/>  
         </Component>  
      </Component>  
      <Component Alias="CreatedBy" Path="$Target/Path[Relationship='SMCore!System.WorkItemCreatedByUser']$"/>  
      <Component Alias="AssignedTo" Path="$Target/Path[Relationship='SMCore!System.WorkItemAssignedToUser']$"/>  
      <Component Alias="CreatedFor" Path="$Target/Path[Relationship='SMCore!System.WorkItemCreatedForUser']$"/>  
      <Component Alias="RelatedWorkItem" Path="$Target/Path[Relationship='SMCore!System.WorkItemRelatesToWorkItem']$">  
         <Component Alias="RelatedWorkItemAssignedTo" Path="$Target/Path[Relationship='SMCore!System.WorkItemAssignedToUser']$"/>  
      </Component>  
      <Component Alias="RelatedConfigItem" Path="$Target/Path[Relationship='SMCore!System.WorkItemRelatesToConfigItem']$"/>  
      <Component Alias="AboutConfigItem" Path="$Target/Path[Relationship='System!System.WorkItemAboutConfigItem']$"/>  
      <Component Alias="FileAttachment" Path="$Target/Path[Relationship='System!System.WorkItemHasFileAttachment']$">  
         <Component Alias="FileAttachmentAddedBy" Path="$Target/Path[Relationship='System!System.FileAttachmentAddedByUser']$"/>  
      </Component>  
   </TypeProjection>  
   <TypeProjection ID="System.FileAttachmentProjection" Accessibility="Public" Type="System!System.FileAttachment">  
      <Component Alias="FileAttachmentAddedBy" Path="$Target/Path[Relationship='System!System.FileAttachmentAddedByUser']$"/>  
   </TypeProjection>  
</TypeProjections>  

Tareas de la consolaConsole tasks


Las tareas de la consola se extienden en el esquema común.Console tasks are extended in the common schema. Antes, las tareas de la consola eran simples punteros a un directorio de aplicación y al nombre de un archivo ejecutable.Previously, console tasks were simple pointers to an application directory and executable file name. Tareas de la consola ahora se implementan como código de controlador de Microsoft .NET ensamblado de Framework.Console tasks are now implemented as handler code in a Microsoft .NET Framework assembly. El código de controlador hace referencia el ensamblado que contiene el código, el nombre del controlador y una lista de valores con nombre que se pueden usar como argumentos en el controlador.The handler code references the assembly that houses the code, the handler name, and a list of named values that can be passed as arguments to the handler.

En el ejemplo siguiente, el controlador Some.Handler.Name se define en el ensamblado MyLibrary.Resources.Assembly .In the following example, the Some.Handler.Name handler is defined in the MyLibrary.Resources.Assembly assembly. También se define una lista de parámetros del controlador y sus valores.A list of handler parameters and their values is also defined.

<ConsoleTask ID="MyLibrary.ConsoleTasks.T1"  
    Accessibility="Public"  
     Target="System!System.Entity"  
     Enabled="true"  
     RequireOutput="true">  
   <Assembly>MyLibrary.Resources.Assembly1</Assembly>  
   <Handler>Some.Handler.Name</Handler>  
   <Parameters>  
      <Argument Name="Application">cmd.exe</Argument>  
      <Argument Name="WorkingDirectory">%TEMP%</Argument>  
      <Argument>test1</Argument>  
      <Argument>test2</Argument>  
   </Parameters>  
</ConsoleTask>  

RecursosResources


Los datos binarios no se almacenan directamente en un módulo de administración.Binary data is not stored directly in a management pack. En su lugar, los metadatos del recurso binario se almacenan en el módulo de administración y los datos binarios reales se almacenan externamente en un archivo de recursos.Instead, metadata about the binary resource is stored in the management pack, and the actual binary data is stored externally in a resource file. Los metadatos incluyen un identificador único, el nombre de archivo, los datos de creación, la fecha de modificación e información sobre accesibilidad.The metadata includes a unique identifier, the file name, the creation data, the modified date, and accessibility information.

Los datos binarios pueden incluir recursos genéricos, imágenes, ensamblados, definiciones de informes y formularios.Binary data can include generic resources, images, assemblies, report definitions, and forms. En el ejemplo siguiente se muestra un recurso XML genérico, un recurso de ensamblado y un recurso de informe.The following example shows a generic XML resource, an assembly resource, and a report resource.


<Resources>  
   <Resource ID="TestLibrary.Resources.Test1" Accessibility="Public" FileName="res1.xml"/>  
   <Resource ID="TestLibrary.Resources.Test2" Accessibility="Public" FileName="res2.xml"/>  
   <Assembly ID="TestLibrary.Resources.Assembly1" Accessibility="Public" QualifiedName="Baz, Version=1.0.0.0" FileName="baz.dll"/>  
   <Assembly ID="TestLibrary.Resources.Assembly2" Accessibility="Public" QualifiedName="Yoyo, Version=1.0.0.0" FileName="yoyo.dll">  
      <Dependency ID="TestLibrary.Resources.Assembly1"/>  
   </Assembly>  
   <ReportResource ID="TestLibrary.Resources.Report1" Accessibility="Public" MIMEType="text/xml" FileName="res1.xml"/>  
   <Image ID="TestLibrary.Resources.Image1" Accessibility="Public" FileName="image.png"/>  
</Resources>  

FormulariosForms


Los formularios se definen en un módulo de administraciónForms are defined in a management pack. y se pueden usar para ver y modificar una instancia única de un tipo o de una clase de combinación.You can use forms to view and modify a single instance of a type or combination class.

Formularios se basan en Windows Presentation Framework (WPF), y se definen en ensamblados.Forms are based on the Windows Presentation Framework (WPF), and they are defined in assemblies. El ensamblado y la clase que contiene las implementaciones de formularios de un módulo de administración se incluyen en la sección de recursos del módulo de administración.The assembly and class that contain the form implementations for a management pack are included in the resources section of the management pack. Al igual que cualquier recurso binario de un módulo de administración que utiliza el nuevo esquema común, el propio módulo de administración no contiene los datos binarios del formulario.As with any binary resource in a management pack that uses the new common schema, the management pack itself does not contain the binary data for the form. En el módulo de administración solo se especifica el manifiesto del recurso.Only the resource manifest is specified in the management pack.

Puede especificar su propia información de configuración del formulario en el módulo de administración.You can specify your own configuration information for the form in the management pack. En el ejemplo siguiente, la sección Configuración contiene una propiedad ShowXboxes .In the following example, the Configuration section contains a ShowXboxes property. El proceso de comprobación del módulo de administración no evalúa esta información de configuración; solo la interpreta la implementación del formulario.This configuration information is not evaluated by the management pack verification process; it is only interpreted by the form implementation.


    <Forms>  
   <Form ID="LobbyForm" Target="Projection" Assembly="FormAssembly" TypeName="MyFormClass">  
   <Configuration>  
      <ShowXboxes>yes</ShowXboxes>  
   </Configuration>  
   </Form>  
</Forms>  

Crear un archivo de módulo de administración para administrar proyectoresAuthor a management pack file to manage projectors

Módulos de administración se utilizan para dirigir y ampliar la funcionalidad de Service Manager.Management packs are used to direct and extend the functionality of Service Manager. En este tema se utilizan proyectores como ejemplo para describir las distintas secciones de un módulo de administración y definir los diferentes objetos necesarios para la administración de proyectores en una organización.This topic uses projectors as an example for describing the various sections of a management pack and for defining the various objects that are needed for managing projectors in an organization.

En este tema se incluye un ejemplo completo de módulo de administración con las extensiones necesarias para administrar proyectores en una organización.This topic includes a complete management pack sample with the necessary extensions to manage projectors in an organization. Además, se describe cómo importar un módulo de administración con un Windows cmdlet de PowerShell.Also, it describes how to import a management pack using a Windows PowerShell cmdlet.

En este tema se describen las siguientes secciones de un módulo de administración:This topic describes the following sections of a management pack:

  • La sección ManifestThe Manifest

  • TypeDefinitions para crear enumeraciones y relaciones de claseTypeDefinitions to create class enumerations and relationships

  • FormulariosForms

    En este tema se describe también las siguientes secciones de un módulo de administración que contienen declaraciones y definiciones de interfaz de usuario (interfaz de usuario) y los elementos de localización:This topic also describes the following sections of a management pack that contain declarations and definitions for user interface (UI) and localization elements:

  • CategoríasCategories

  • PresentaciónPresentation

  • Extensiones de claseClass Extensions

Sección de manifiestoManifest section


La primera sección de un módulo de administración contiene el manifiesto.The first section of a management pack contains the manifest. El manifiesto identifica el módulo de administración y declara todas las referencias a otros módulos de administración.The manifest identifies the management pack and declares any references to other management packs.

El siguiente ejemplo muestra la sección Manifest de un módulo de administración diseñado para efectuar un seguimiento de los proyectores en una organización.The following example shows the Manifest section of a management pack that was designed to track projectors in an organization.


<Manifest>  
  <Identity>  
    <ID>ServiceManager.Projector_Authoring</ID>  
    <Version>7.0.3707.0</Version>  
  </Identity>  
  <Name>Projector Library</Name>  
  <References>  
    <Reference Alias="System">  
      <ID>System.Library</ID>  
      <Version>7.0.3707.0</Version>  
      <PublicKeyToken>31bf3856ad364e35</PublicKeyToken>  
    </Reference>  
    <Reference Alias="SMConsole">  
      <ID>Microsoft.EnterpriseManagement.ServiceManager.UI.Console</ID>  
      <Version>7.0.3707.0</Version>  
      <PublicKeyToken>31bf3856ad364e35</PublicKeyToken>  
    </Reference>  
    <Reference Alias="Authoring">  
      <ID>Microsoft.EnterpriseManagement.ServiceManager.UI.Authoring</ID>  
      <Version>7.0.3707.0</Version>  
      <PublicKeyToken>31bf3856ad364e35</PublicKeyToken>  
    </Reference>  
    <Reference Alias="SMConfig">  
      <ID>ServiceManager.ConfigurationManagement.Library</ID>  
      <Version>7.0.3707.0</Version>  
      <PublicKeyToken>31bf3856ad364e35</PublicKeyToken>  
    </Reference>  
  </References>  
</Manifest>  
Importante

En el referencias sección, utilice valores no alfanuméricos, como un '.', en el Alias para una referencia.In the References section, do not use nonalphanumeric values, such as a '.', in the Alias for a reference.

Crear clases en la sección TypeDefinitionsCreate classes in the TypeDefinitions section

La siguiente sección de un módulo de administración contiene definiciones de tipo.The next section of a management pack contains type definitions. La sección TypeDefinitions de un módulo de administración contiene definiciones de clases, enumeraciones y relaciones utilizadas por el módulo de administración.The TypeDefinitions section of a management pack contains definitions for classes, enumerations, and relationships that are used by the management pack.

En el ejemplo siguiente se muestra una clase que contiene información sobre proyectores:The following example shows a class that contains information about projectors:


<TypeDefinitions>  
    <EntityTypes>  
      <ClassTypes>  
        <ClassType ID="System.ConfigItem.Projector" Base="System!System.ConfigItem" Hosted="false" Accessibility="Public" Abstract="false">  
          <Property ID="SerialNumber" Type="int" Key="true" />  
          <Property ID="Make" Type="string" />  
          <Property ID="Model" Type="string"  />  
          <Property ID="Location" Type="string" />  
          <Property ID="Condition" Type="enum" EnumType="ProjectorCondition"  />  
        </ClassType>  
      </ClassTypes>  
      <RelationshipTypes>  
      </RelationshipTypes>  
      <EnumerationTypes>  
        <EnumerationValue ID="ProjectorCondition" Accessibility="Public"/>  
        <EnumerationValue ID="ProjectorCondition.Working" Parent="ProjectorCondition" Accessibility="Public"/>  
        <EnumerationValue ID="ProjectorCondition.BeingRepaired" Parent="ProjectorCondition" Accessibility="Public"/>  
        <EnumerationValue ID="ProjectorCondition.New" Parent="ProjectorCondition" Accessibility="Public"/>  
        <EnumerationValue ID="ProjectorCondition.Broken" Parent="ProjectorCondition" Accessibility="Public"/>  
        <EnumerationValue ID="ProjectorViewTasksEnumeration" Accessibility="Public"/>  
      </EnumerationTypes>  
    </EntityTypes>  
  </TypeDefinitions>  

La siguiente es una sección-por-sección explicación de lo que contiene la definición de tipo.The following is a section-by-section explanation of what the type definition contains.

La sección ClassTypesThe ClassTypes section

El elemento ClassType define la clase de proyector:The ClassType element defines the projector class:

<ClassType ID="System.ConfigItem.Projector" Base="System!System.ConfigItem" Hosted="false" Accessibility="Public" Abstract="false">

El atributo ID es el identificador único de esta clase.The ID attribute is the unique identifier of this class. Se establece en:It is set to:

ID="System.ConfigItem.Projector"

El atributo Base es el Id. de la clase del que se deriva esta clase.The Base attribute is the ID of the class from which this class derives. Dado que un proyector es un tipo de elemento de configuración, se establece en:Because a projector is a kind of configuration item, this is set to:

Base="System!System.ConfigItem"

La notación de sistema!The notation of System! indica que esta clase, System.ConfigItem, está en el módulo de administración al que se hace referencia en el alias System.indicates that this class, System.ConfigItem, is in the management pack that is referenced by the alias System.

El atributo Hosted define si esta clase está hospedada por otra clase.The Hosted attribute defines whether this class is hosted by another class. En este caso, una instancia de esta clase solo puede existir cuando existe una instancia de host que la contiene.In this case, an instance of this class can only exist when a host instance exists that contains it. Para este ejemplo, los proyectores no están hospedados por nada; por lo tanto, el atributo Hosted se establece en false:For this example, projectors are not hosted by anything; therefore, the Hosted attribute is set to false:

Hosted="false"

Si el atributo Hosted se ha establecido en true , esto indica que la clase está hospedada por otra clase.Setting the Hosted attribute to true indicates that the class is hosted by another class. Una relación de hospedaje se debe declarar en la sección RelationshipTypes .A hosting relationship must be declared in the RelationshipTypes section.

El atributo Accessibility define si otras clases se pueden derivar de esta clase.The Accessibility attribute defines whether other classes can derive from this class. En caso de que desee permitir a otros usuarios la creación de una versión más específica de la clase, establezca este atributo en public, por ejemplo:In cases where you might want to allow others to create a more specific version of your class, set this attribute to public, for example:

Accessibility="Public"

Si se establece el atributo Accessibility en Internal se impide que otras clases se deriven de esta clase.Setting the Accessibility attribute to Internal prevents other classes from deriving from this class.

El atributo Abstract define si se pueden crear instancias de esta clase o si la clase se debe utilizar como clase primaria de otras clases derivadas de la misma.The Abstract attribute defines whether instances of this class can be created, or whether the class should just be used as a parent class to other classes to derive from. En este ejemplo, este atributo se establece en false.In this example, this attribute is set to false. Si este atributo se establece en true , significa que no se puede crear directamente ninguna instancia de esta clase y que esta clase se puede utilizar únicamente como clase primaria.Setting this attribute to true means that no instances of this class can be created directly and that this class can be used only as a parent class.

La siguiente sección de la definición de clase contiene las propiedades de clase.The next section of the class definition contains the class properties. El XML que define las propiedades de clase para este ejemplo se define en el ejemplo de código siguiente:The XML that defines the class properties for this example are defined in the following code example:


<Property ID="SerialNumber" Type="int" Key="true" />  
<Property ID="Make" Type="string" />  
<Property ID="Model" Type="string"  />  
<Property ID="Location" Type="string" />  
<Property ID="Condition" Type="enum" EnumType="ProjectorCondition"  />  

Cada elemento Property tiene los siguientes atributos:Each Property element has the following attributes:

  • El atributo ID , que designa el identificador único de la propiedad.The ID attribute, which designates the unique identifier of the property.

  • El atributo Type , que indica el tipo de datos de la propiedad.The Type attribute, which indicates the data type of the property.

  • El atributo Key .The Key attribute. Si este atributo se establece en true significa que esta propiedad se utilizará para identificar de forma exclusiva esta clase.Setting this attribute to true indicates that this property is to be used to uniquely identify this class.

    Crear tipos de enumeraciónCreating Enumeration Types

    Las enumeraciones del tipo de datos enum son tipos de datos especiales.Enumerations of the enum data type are special data types. Las enumeraciones se utilizan para restringir los datos que se permiten para una propiedad de un conjunto específico de valores.Enumerations are used to constrain the data that is allowed for a property to a specific set of values. Las enumeraciones pueden ser jerárquicas; una enumeración se puede basar en otra enumeración.Enumerations can be hierarchical; one enumeration can be based on another enumeration.

    Las enumeraciones se definen en la sección EnumertionTypes de un paquete de solución.Enumerations are defined in the EnumertionTypes section of a solution pack. Una definición de enumeración contiene la enumeración raíz, seguida de los valores reales de enumeración.An enumeration definition contains the root enumeration, followed by the actual enumeration values.

    Cada EnumerationValue acepta unos cuantos atributos:Each EnumerationValue accepts a few attributes:

    En este ejemplo se define una enumeración para efectuar el seguimiento de la condición de los proyectores.In this example, an enumeration is defined for keeping track of the condition of the projectors. Lo siguiente define esta enumeración:The following defines this enumeration:

  • ID es el identificador de la enumeración o el valor de enumeración.ID is the identifier for the enumeration or enumeration value.

  • Accessibility especifica si este enumerador puede contener otros enumeradores.Accessibility specifies whether this enumerator can contain other enumerators.

  • ParentName es un atributo que especifica el ID del elemento primario del valor del enumerador.ParentName is an attribute that specifies the ID of the parent of the enumerator value.


<EnumerationTypes>  
   <EnumerationValue ID="ProjectorCondition" Accessibility="Public"/>  
   <EnumerationValue ID="ProjectorCondition.Working" Parent="ProjectorCondition" Accessibility="Public"/>  
   <EnumerationValue ID="ProjectorCondition.BeingRepaired" Parent="ProjectorCondition" Accessibility="Public"/>  
   <EnumerationValue ID="ProjectorCondition.New" Parent="ProjectorCondition" Accessibility="Public"/>  
   <EnumerationValue ID="ProjectorCondition.Broken" Parent="ProjectorCondition" Accessibility="Public"/>  
   <EnumerationValue ID="ProjectorViewTasksEnumeration" Accessibility="Public"/>  
</EnumerationTypes>  

Crear un formularioCreate a form


Formularios de Service Manager se basan en Windows Presentation Framework (WPF) formularios.Service Manager forms are based on Windows Presentation Framework (WPF) forms. Service Manager amplía WPF con atributos simples que se agregan a la definición XML y permitir que el Administrador de servicio para enlazar datos desde el módulo de administración al formulario.Service Manager extends WPF with simple attributes that are added to the XML definition and allow Service Manager to bind data from the management pack to the form.

Formularios de Service Manager se pueden crear mediante el uso de varias herramientas, como Microsoft Visual Studio o Microsoft Expression Blend.Service Manager forms can be created by using several different tools, including Microsoft Visual Studio or Microsoft Expression Blend. Dado que los formularios son XML-según, también pueden definirse mediante cualquier editor de XML.Because the forms are XML-based, they can also be defined by using any XML editor.

En el ejemplo siguiente se muestra una definición de formulario que se creó mediante Microsoft Expression Blend.The following example shows a form definition that was created by using Microsoft Expression Blend. Este formulario contiene cuatro controles, tres cuadros de texto y un cuadro combinado, enlazados a las propiedades de la clase Proyector definidas previamente:This form contains four controls, three text boxes and one combo box, that are bound to the Projector class properties that were defined previously:


<UserControl xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:local="clr-namespace:SMFormsDemo" x:Class="SMFormsDemo.TestControl" x:Name="Control" Width="574" Height="390" Opacity="1" xmlns:d="http://schemas.microsoft.com/expression/blend/2008" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" mc:Ignorable="d" Background="{DynamicResource {x:Static SystemColors.WindowBrushKey}}">  
   <UserControl.Resources>  
      <ObjectDataProvider ObjectType="{x:Type local:helper}" MethodName="GetStatusValues" x:Key="getStatusValues"/>  
   </UserControl.Resources>  
   <Grid x:Name="LayoutRoot">  
      <Label Margin="70,20,0,0" HorizontalAlignment="Left" VerticalAlignment="Top" Width="160" Height="25" Content="Serial Number:"/>  
      <TextBox Margin="180,20,0,0" HorizontalAlignment="Left" VerticalAlignment="Top" Width="160" Height="25" d:IsStaticText="True" Text="{Binding Path=SerialNumber, Mode=TwoWay}"/>  
      <Label Margin="70,60,0,0" HorizontalAlignment="Left" VerticalAlignment="Top" Width="160" Height="25" Content="Make:"/>  
      <TextBox Margin="180,60,0,0" HorizontalAlignment="Left" VerticalAlignment="Top" Width="160" Height="25" d:IsStaticText="True" Text="{Binding Path=Make, Mode=TwoWay}"/>  
      <Label Margin="70,100,0,0" HorizontalAlignment="Left" VerticalAlignment="Top" Width="160" Height="25" Content="Model:"/>  
      <TextBox Margin="180,100,0,0" HorizontalAlignment="Left" VerticalAlignment="Top" Width="160" Height="25" d:IsStaticText="True" Text="{Binding Path=Model, Mode=TwoWay}"/>  
      <Label Margin="70,140,80,0" HorizontalAlignment="Left" VerticalAlignment="Top" Width="160" Height="25" Content="Location:"/>  
      <TextBox Margin="180,140,80,0" HorizontalAlignment="Left" VerticalAlignment="Top" Width="160" Height="25" d:IsStaticText="True" Text="{Binding Path=Location, Mode=TwoWay}"/>  
      <Label Margin="70,180,80,0" HorizontalAlignment="Left" VerticalAlignment="Top" Width="160" Height="25" Content="Condition:"/>  
      <ComboBox Margin="180,180,80,0" HorizontalAlignment="Left" VerticalAlignment="Top" Width="160" Height="25" ItemsSource="{Binding Source={StaticResource getStatusValues}, Mode=OneWay }" IsSynchronizedWithCurrentItem="True">  
         <ComboBox.SelectedItem>  
            <Binding Path="Condition" Mode="TwoWay" UpdateSourceTrigger="PropertyChanged"/>  
         </ComboBox.SelectedItem>  
         <ComboBox.ItemTemplate>  
            <DataTemplate>  
               <StackPanel>  
                  <TextBlock Text="{Binding Path=DisplayName}"/>  
               </StackPanel>  
            </DataTemplate>  
         </ComboBox.ItemTemplate>  
      </ComboBox>  
   </Grid>  
</UserControl>  

Para habilitar el enlace de controles del formulario a propiedades de clase definidas en un módulo de administración se deben especificar una serie de elementos.To enable binding of controls on the form to class properties that are defined in a management pack, a number of items must be specified.

Enlazar controles de textoBinding Text Controls

Para enlazar cuadros de texto a propiedades de clase en un módulo de administración, agregue un Binding Path etiqueta para el control de cuadro de texto texto propiedad, por ejemplo:To bind text boxes to class properties in a management pack, add a Binding Path tag to the text box control's Text property, for example:

{Binding Path=SerialNumber, Mode=TwoWay}  

Esta etiqueta enlaza el control de cuadro de texto a la SerialNumber propiedad de la proyector clase que se definió en el módulo de administración y se especifica que debería ser un dos-forma enlace.This tag binds the text box control to the SerialNumber property of the Projector class that was defined in the management pack, and it specifies that this should be a two-way binding. El valor de la propiedad se recupera de la base de datos y se muestra en el cuadro de texto una vez cargado el formulario y el valor de la propiedad se vuelve a almacenar en la base de datos si ha sido modificado por el usuario.The value of the property is retrieved from the database and displayed in the text box when the form is loaded, and the property value is stored back to the database if it is changed by the user.

Enlace de cuadros combinadosBinding Combo Boxes

Para que el formulario pueda recuperar datos de enumeración desde el módulo de administración subyacente y enlazarlos a un control en el formulario, se debe definir una clase auxiliar en el código-detrás de en el formulario.To allow the form to retrieve enumeration data from the underlying management pack and bind it to a control on the form, a helper class must be defined in the code-behind in the form. Esta clase auxiliar debe contener un método que devuelva una enumeración que se define en el módulo de administración.This helper class should contain a method that returns an enumeration that is defined in the management pack. Para devolver una enumeración, utilice el método GetEnumerations del módulo de administración actual.To return an enumeration use the GetEnumerations method of the current management pack. Se tiene acceso a esta instancia con el ConsoleContextHelper clase desde el kit de desarrollo de software de Service Manager (SDK).This instance is accessed with the ConsoleContextHelper class from the Service Manager software development kit (SDK). En el siguiente ejemplo, una clase auxiliar define un método GetStatusValues que recupera los valores para la enumeración ProjectorCondition definida en el módulo de administración:In the following example, a helper class defines a GetStatusValues method that retrieves the values for the ProjectorCondition enumeration that was defined in the management pack:


public class helper  
{  
   public static ICollection<IDataItem> GetStatusValues()  
   {  
      return ConsoleContextHelper.Instance.GetEnumerations("ProjectorCondition",true);  
   }  
}  

Para tener acceso a este método se deben definir algunas cosas en la definición del formulario en el módulo de administración.To access this method, a few things must be defined in the form definition in the management pack.

Primero, se agrega a la definición del formulario un espacio de nombres que apunta al espacio de nombres para el code behind del formulario.First, a namespace that points to the namespace for the code behind for the form is added to the form definition. En este ejemplo, el espacio de nombres es SMFormsDemo:In this example, the namespace is SMFormsDemo:

xmlns:local="clr-namespace:SMFormsDemo"  

A continuación, se debe definir un ObjectDataProvider para proporcionar los valores del cuadro combinado que muestra el estado del proyector.Next, an ObjectDataProvider must be defined to provide the values for the combo box that displays the projector status. Este ObjectDataProvider se define como un recurso:This ObjectDataProvider is defined as a resource:


<UserControl.Resources>  
   <ObjectDataProvider   
      ObjectType="{x:Type local:helper}"    
      MethodName="GetStatusValues"   
      x:Key="getStatusValues" />  
</UserControl.Resources>  

Este proveedor de datos especifica el objeto y el nombre del método que recupera los valores de enumeración desde el módulo de administración.This data provider specifies the object and method name that retrieves the enumeration values from the management pack.

Finalmente, para enlazar el cuadro combinado a los valores de enumeración definidos en el módulo de administración, se agrega un atributo ItemsSource a la definición del cuadro combinado.Finally, to bind the combo box to the enumeration values that are defined in the management pack, an ItemsSource attribute is added to the combo box definition. Este atributo especifica dónde debe recuperar los valores de enumeración, por ejemplo:This attribute specifies where to retrieve the enumeration values, for example:

ItemsSource="{Binding Source={StaticResource getStatusValues}, Mode=OneWay }"  

Después, SelectedItem y ItemTemplate se agregan elementos a Extensible Application Markup Language (XAML) definición del control de cuadro combinado.Next, SelectedItem and ItemTemplate elements are added to the Extensible Application Markup Language (XAML) definition of the combo box control. El ejemplo siguiente muestra la definición del cuadro combinado con el enlace XAML incluido:The following example shows the combo box definition with the binding XAML included:


<ComboBox Margin="180,180,80,0" HorizontalAlignment="Left" VerticalAlignment="Top" Width="160" Height="25" ItemsSource="{Binding Source={StaticResource getStatusValues}, Mode=OneWay }" IsSynchronizedWithCurrentItem="True">  
   <ComboBox.SelectedItem>  
      <Binding Path="Condition" Mode="TwoWay" UpdateSourceTrigger="PropertyChanged"/>  
   </ComboBox.SelectedItem>  
   <ComboBox.ItemTemplate>  
      <DataTemplate>  
         <StackPanel>  
            <TextBlock Text="{Binding Path=DisplayName}"/>  
         </StackPanel>  
      </DataTemplate>  
   </ComboBox.ItemTemplate>  
</ComboBox>  

La sección CategoryThe Category section


La sección Category de un módulo de administración agrupa elementos de módulo de administración para una navegación más sencilla.The Category section of a management pack groups management pack elements together for easier navigation.

Las dos primeras <Category> elementos en el ejemplo se utilizan para controlar la presentación de la New y editar las tareas en el proyectores vista.The first two <Category> elements in the example are used to control the display of the New and Edit tasks in the Projectors view.

<Category ID="ProjectorViewHasTasks.View" Target="AllProjectorsView" Value="ProjectorViewTasksEnumeration" />  
<Category ID="ProjectorViewHasTasks.CreateTask" Target="CreateProjector" Value="ProjectorViewTasksEnumeration" />  

Los siguientes dos categoría elementos en el módulo de administración de ejemplo se usan para que la enumeración de condición del proyector aparezca en el enumera ver en el Authoring panel de la consola de Service Manager.The second two Category elements in the example management pack are used to make the projector condition enumeration appear in the Lists view in the Authoring pane in the Service Manager console. Esto permite al usuario personalizar los valores:This enables the user to customize the values:

<Category ID="Project.ProjectorConditionEnumVisibleCategory" Target="ProjectorCondition" Value="System!VisibleToUser"/>  

Si se agrega esta categoría en el siguiente ejemplo, la tarea Editar aparece en la vista Listas para el EnumerationValue al que se apunta en el atributo Target :Adding this category in the following example makes the Edit task appear in the Lists view for the EnumerationValue that is pointed at in the Target attribute:

<Category ID="Projector.ProjectorConditionCategory" Target="ProjectorCondition" Value="Authoring!Microsoft.EnterpriseManagement.ServiceManager.UI.Authoring.EnumerationViewTasks"/>  

La sección PresentationThe Presentation section


El presentación sección de un módulo de administración declara y define el usuario-interfaz-elementos relacionados.The Presentation section of a management pack declares and defines user-interface-related elements. Entre ellos se incluyen las declaraciones de formularios, las categorías y las tareas de la consola.These include forms declarations, categories, and console tasks.

La sección FormsThe Forms Section

La sección Forms declara los formularios utilizados por el módulo de administración.The Forms section declares forms that are used by your management pack. En el siguiente ejemplo se especifica dónde se encuentra el formulario definido para mostrar y editar las instancias de la clase Proyector .The following example specifies where to find the form that is defined to display and edit instances of the Projector class. Esto enlaza el formulario a la clase Proyector definida en el módulo de administración:This binds the form to the Projector class that is defined in the management pack:


<Forms>  
   <Form TypeName="SMFormsDemo.TestControl"  
      ID="TestForm"  
      Target="System.ConfigItem.Projector"  
      Assembly="ProjectorFormsAssembly"  
      Accessibility="Public">  
   <Category>Form</Category>  
   </Form>  
</Forms>  

En el ejemplo anterior se utilizan los siguientes atributos:The following attributes are used in the preceding example:

  • El atributo TypeName contiene el espacio de nombres y el nombre de clase del formulario.The TypeName attribute contains the namespace and class name of the form.

  • El atributo ID contiene el identificador único de esta instancia de formulario.The ID attribute contains the unique identifier of this form instance.

  • El atributo Target contiene el nombre de la clase a la que está enlazado este formulario.The Target attribute contains the name of the class that this form is bound to.

  • El atributo Assembly apunta al recurso externo que contiene el formulario.The Assembly attribute points to the external resource that contains the form.

  • El atributo Accessibility define si se puede personalizar este formulario.The Accessibility attribute defines whether this form can be customized.

    Definir una vistaDefining a View

    El vistas sección de un módulo de administración contiene definiciones de interfaz de usuario (UI) vistas.The Views section of a management pack contains definitions of user interface (UI) views. Estas vistas se pueden utilizar para filtrar y mostrar objetos en un módulo de administración.These views can be used to filter and display objects in a management pack.

<View Target="System.ConfigItem.Projector"   
Enabled="true"  
TypeID="SMConsole!GridViewType"  
ID="AllProjectorsView"  
Accessibility="Public">  
<Category>NotUsed</Category>  
<Data>  
<Adapters>  
      <Adapter AdapterName="dataportal:EnterpriseManagementObjectAdaptor">  
                <AdapterAssembly>Microsoft.EnterpriseManagement.UI.SdkDataAccess</AdapterAssembly>  
   <AdapterType>  
Microsoft.EnterpriseManagement.UI.SdkDataAccess.DataAdapters.EnterpriseManagementObjectAdapter  
   </AdapterType>  
      </Adapter>  
            <Adapter AdapterName="viewframework://adapters/ListDefault">  
              <AdapterAssembly>Microsoft.EnterpriseManagement.UI.ViewFramework</AdapterAssembly>  
              <AdapterType>Microsoft.EnterpriseManagement.UI.ViewFramework.ListSupportAdapter</AdapterType>  
            </Adapter>  
</Adapters>  
<ItemsSource>  
  <AdvancedListSupportClass DataTypeName="" AdapterName="viewframework://adapters/AdvancedList" FullUpdateAdapter="dataportal:EnterpriseManagementObjectAdapter" FullUpdateFrequency='1' DataSource="mom:ManagementGroup" IsRecurring="true" RecurrenceFrequency="5000"  treaming='true' xmlns="clr-namespace:Microsoft.EnterpriseManagement.UI.ViewFramework;assembly=Microsoft.EnterpriseManagement.UI.ViewFramework" xmlns:av="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" >  
    <AdvancedListSupportClass.Parameters>  
                <QueryParameter Parameter="TargetClass" Value="System.ConfigItem.Projector"/>  
    </AdvancedListSupportClass.Parameters>  
    </AdvancedListSupportClass>  
    </ItemsSource>  
    <Criteria />  
</Data>  
<Presentation>  
<Columns>  
            <mux:ColumnCollection xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:mux="http://schemas.microsoft.com/SystemCenter/Common/UI/Views/GridView" xmlns:s="clr-namespace:System;assembly=mscorlib">  
              <mux:Column Name="SerialNumber" DisplayMemberBinding="{Binding Path=SerialNumber}" Width="100" DisplayName="SerialNumber" Property="SerialNumber" DataType="s:Int32" />  
              <mux:Column Name="Location" DisplayMemberBinding="{Binding Path=Location}" Width="100" DisplayName="Location" Property="Location" DataType="s:String" />  
              <mux:Column Name="Condition" DisplayMemberBinding="{Binding Path=Condition.DisplayName}" Width="100" DisplayName="Condition" Property="Condition.DisplayName" DataType="s:String" />  
              <mux:Column Name="DisplayName" DisplayMemberBinding="{Binding Path=DisplayName}" Width="100" DisplayName="Display Name" Property="DisplayName" DataType="s:String" />  
              <mux:Column Name="OwnerUser" DisplayMemberBinding="{Binding Path=OwnerUser.DisplayName}" Width="100" DisplayName="SupportOwner" Property="OwnerUser.DisplayName" DataType="s:String" />  
            </mux:ColumnCollection>      
</Columns>  
</Presentation>  
</View>  

El atributo Destino de vista apunta a la clase que se utilizará para mostrar la vista.The View Target attribute points to the class that the view will be used to display.

En el ejemplo anterior se hace referencia al módulo de administración de la consola de Service Manager.In the preceding example, the Service Manager Console management pack is referenced. Este módulo de administración contiene una definición de un tipo de vista utilizado.This management pack contains a definition of a view type being used. En este caso, el SMConsole!GridViewType se define el tipo de vista.In this instance, the SMConsole!GridViewType view type is defined.

AdvancedListSupportClass define una serie de parámetros, de los cuales, el más importante es el parámetro TargetClass .The AdvancedListSupportClass defines a number of parameters, the most important of which is the TargetClass parameter. Establezca este parámetro en el ID de ClassType que aparecerá en esta vista.Set this parameter to the ID of the ClassType that will appear in this view. Para mostrar las columnas que son propiedades de ClassType, utilice el elemento Column y enlácelo al atributo PropertyID .To display the columns that are properties of the ClassType, use the Column element and bind it to the PropertyID attribute.

El IsRecurring atributo de la ListSupportClass elemento determina si la vista automáticamente-actualiza.The IsRecurring attribute of the ListSupportClass element determines whether the view auto-refreshes. El atributo RecurrenceFrequency define el intervalo de actualización en milisegundos.The RecurrenceFrequency attribute defines the refresh interval in milliseconds. En este ejemplo, el intervalo de actualización se establece en 1 segundo, pero no se recomienda para instalaciones de producción.In this example, the refresh interval is set to 1 second, but that is not recommended for production installations.

Definir carpetasDefining Folders

La definición de una carpeta determina la ubicación en que se muestra la vista en el árbol de navegación.Defining a folder determines the location in the navigation tree in which the view is displayed. En este ejemplo, se define un elemento de configuración de modo que la vista solo se pueda colocar bajo la carpeta existente para elementos de configuración del área de trabajo Elementos de configuración :In this example, a configuration item is defined so that it is only suitable to place the view under the existing folder for configuration items in the Configuration Items workspace:

<Folders>  
  <Folder ID="Folder.Projectors" Accessibility="Public" ParentFolder="SMConfig!ServiceManager.Console.ConfigurationManagement.ConfigItem.Root" />  
</Folders>  
<FolderItems>  
   <FolderItem   
      ElementID="AllProjectorsView"   
      Folder="Folder.Projectors" />  
   </FolderItems>  

En el ejemplo anterior, el atributo ElementID contiene una referencia a la vista que se creó.In the preceding example, the ElementID attribute contains a reference to the view that was created. El carpeta atributo apunta a un Folders.Projectors carpeta, que a su vez tiene su raíz como se define en el Configuration Management área de trabajo de la consola de Service Manager.The Folder attribute points to a Folders.Projectors folder, which in turn has its root as defined in the Configuration Management workspace of the Service Manager console. Esta carpeta raíz se define en el módulo de administración de Configuration Management.This root folder is defined in the Configuration Management management pack.

El elemento ImageReference asigna la vista creada previamente a un icono que se define en el espacio de nombres Configuration Management :The ImageReference element maps the view that was previously created to an icon that is defined in the Configuration Management namespace:

<ImageReferences>  
  <ImageReference ElementID="Folder.Projectors" ImageID="SMConfig!ConfigItemImage16x16" />  
  <ImageReference ElementID="AllProjectorsView" ImageID="SMConfig!ConfigItemImage16x16" />  
</ImageReferences>  

Localización mediante la sección LanguagePacksLocalization Using the LanguagePacks Section

La sección LanaguagePacks de un módulo de administración define recursos de cadena y asignaciones para los elementos del módulo de administración.The LanaguagePacks section of a management pack defines string resources and mappings for management pack elements.

En el ejemplo, el EnumerationValueProjectorCondition.Working debe aparecer como trabajar.In the example, the EnumerationValueProjectorCondition.Working must appear as Working. Para ello, se deben definir los nombres para mostrar para cada una de las siguientes:To do this, display names for each of the following must be defined:

  • Vista: Todos los proyectoresView: All projectors

  • Enumeraciones: en funcionamiento, rotos, en reparación, nuevosEnumerations: working, broken, in repair, new

  <LanguagePacks>  
    <LanguagePack ID="ENU" IsDefault="true">  
      <DisplayStrings>  
        <DisplayString ElementID="AllProjectorsView">  
          <Name>All Projectors</Name>  
          <Description>This displays all projectors</Description>  
        </DisplayString>  
        <DisplayString ElementID="ProjectorCondition.Working">  
          <Name>Working</Name>  
        </DisplayString>  
        <DisplayString ElementID="ProjectorCondition.Broken">  
          <Name>Broken</Name>  
        </DisplayString>  
        <DisplayString ElementID="ProjectorCondition.BeingRepaired">  
          <Name>In Repair</Name>  
        </DisplayString>  
        <DisplayString ElementID="ProjectorCondition.New">  
          <Name>New</Name>  
        </DisplayString>  
      </DisplayStrings>  
    </LanguagePack>  
</LanguagePacks>  

Puede crear más elementos LanguagePack , según sea necesario, para cada idioma adicional que necesite.You can create additional LanguagePack elements, as necessary, for each additional language you require. La cadena de presentación correcta se muestra al usuario en función de la configuración regional del usuario.The correct display string appears to the user based on the user's locale.

RecursosResources

La sección Resources de un módulo de administración contiene referencias a recursos binarios, contenidos en ensamblados independientes del módulo de administración.The Resources section of a management pack contains references to binary resources, which are contained in assemblies that are separate from the management pack. En el siguiente ejemplo se define un recurso que apunta al ensamblado que contiene el formulario utilizado por la clase Proyector :In the following example, a resource is defined that points to the assembly that contains the form that is used by the Projector class:

<Assembly ID="ProjectorFormsAssembly"    
         Accessibility="Public"   
         QualifiedName="SMFormsDemo, Version=1.0.0.0" FileName="SMFormsDemo.dll" CreationDate="1900-10-12T13:13:13" ModifiedDate="2008-12-12T12:12:12" />  

Extensiones de claseClass extensions


Una extensión de clase es una clase que agrega propiedades a una clase existente.A class extension is a class that adds properties to an existing class. En la mayoría de los casos, la clase existente está en un módulo de administración sellado.In most cases, this existing class is in a sealed management pack. En los casos en que la clase existente no esté en un módulo de administración sellado, la extensión de clase debe encontrarse en el mismo módulo de administración que la clase que se va a extender.In cases where the existing class is not in a sealed management pack, the class extension must be contained in the same management pack as the class that is being extended.

Las extensiones de clase hereda las propiedades de todas las clases principales, por ejemplo:A class extension inherits the properties of any parent classes, for example:

  • La clase A tiene una propiedad denominada Property1Class A has a property called Property1

  • La clase B se deriva de la clase A, o la extiende, y, por consiguiente, tiene una propiedad llamada Property1.Class B derives from, or extends, Class A and therefore has a property called Property1. Esta propiedad se hereda de la clase A, el principal o clase base)This property is inherited from Class A, the parent, or base class)

  • La definición de clase B agrega una propiedad llamada Property2.The definition of Class B adds a property called Property2.

  • Todas las extensiones de clase que se deriven de la clase b heredarán Property1 y Property2.Any class extension that derives from Class B will inherit Property1 and Property2.

    En el ejemplo siguiente se muestra una definición de extensión de clase:The following example shows a class extension definition:


<TypeDefinitions>  
     <EntityTypes>  
       <ClassTypes>  
         <ClassType ID="IncidentManagmentPack.Extension" Accessibility="Public" Base="Incident!System.WorkItem.Incident" Hosted="false" IsExtensionType="true">  
          <Property ID="TimeOnIncident" Type="int" Key="false" />  
        </ClassType>  
      </ClassTypes>  
    </EntityTypes>  
  </TypeDefinitions>  

Esta extensión de la clase extiende la clase System.WorkItem.Incident y agrega una nueva propiedad llamada TimeOnIncident.This class extension extends the System.WorkItem.Incident class and adds a new property called TimeOnIncident.

La definición de una extensión de clase es similar a la de una clase.The definition for a class extension is similar to that of a class definition. Dos de los atributos del elemento ClassType se usan para definir una definición de clase: el atributo Base y el atributo IsExtensionType .Two attributes of the ClassType element are used to define a class definition: the Base attribute and the IsExtensionType attribute.

El atributo Base especifica el ID de la clase principal de la que deriva la extensión de clase.The Base attribute specifies the ID of the parent class from which the class extension derives. En este caso, el valor del atributo se establece en incidente!System.WorkItem.Incident.In this instance, the attribute value is set to Incident!System.WorkItem.Incident. Este valor contiene el Alias del nombre completo del módulo de administración, que contiene la clase que se extiende, un signo de admiración y el nombre de la clase base.This value contains the Alias of the full management pack name, which contains the class being extended, an exclamation point, and then the name of the base class. Para obtener más información, vea el siguiente ejemplo.For more information, see the following example.

El atributo IsExtensionType define si esta clase es una extensión de la clase base.The IsExtensionType attribute defines whether this class is an extension of the base class. Dado que TimeOnIncident es una extensión de la clase Incidente , esta propiedad se establece en true:Because TimeOnIncident is an extension to the Incident class, this property is set to true:

IsExtensionType="true"  

La otra opción es false, que indica que no es una extensión de otra clase, sino una clase nueva que se hereda de la base.The other option is false, which indicates that it is not an extension of another class but a new class that inherits from the base. El valor predeterminado es false; por lo tanto, este atributo no tiene que usarse si la clase no es una extensión.The default value is false; therefore, this attribute does not have to be used if the class is not an extension.

Ejemplo completoFull Example

En el ejemplo de código siguiente se muestra todo el módulo de administración que contiene la extensión de clase.The following code example shows the full management pack containing the class extension.

ManagementPack xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" ContentReadable="true" SchemaVersion="1.1">  
   <Manifest>  
     <Identity>  
      <ID>ServiceManager.Extension</ID>  
      <Version>1.0.0.0</Version>  
     </Identity>  
    <Name>ServiceManagerExtension</Name>  
     <References>  
       <Reference Alias="System">  
        <ID>System.Library</ID>  
        <Version>1.0.2780.0</Version>  
        <PublicKeyToken>31bf3856ad364e35</PublicKeyToken>  
      </Reference>  
      <Reference Alias="Incident">  
        <ID>System.WorkItem.Incident.Library</ID>  
        <Version>1.0.2780.0</Version>  
        <PublicKeyToken>31bf3856ad364e35</PublicKeyToken>  
      </Reference>  
    </References>  
  </Manifest>  
   <TypeDefinitions>  
     <EntityTypes>  
       <ClassTypes>  
         <ClassType ID="IncidentManagmentPack.Extension" Accessibility="Public" Base="Incident!System.WorkItem.Incident" Hosted="false" Extension="true">  
          <Property ID="TimeOnIncident" Type="int" Key="false" />  
        </ClassType>  
      </ClassTypes>  
    </EntityTypes>  
  </TypeDefinitions>  
</ManagementPack>  

Importar un módulo de administración mediante el uso de un cmdletImport a management pack by using a cmdlet


Puede utilizar las ventanas PowerShell importar-SCSMManagementPack para importar un módulo de administración de Service Manager, por ejemplo:You can use the Windows PowerShell Import-SCSMManagementPack cmdlet to import a Service Manager management pack, for example:

Import-SCSMManagementPack MyServiceManager.ManagementPack.xml  

Este documento describe cómo importar y utilizar módulos de administración en la consola de Service Manager.This document does not describe how to import and use management packs in the Service Manager console. Para obtener información acerca del uso de administración de módulos en la consola de Service Manager, consulte uso de módulos de administración de Service Manager.For information about using management packs in the Service Manager console, see Using Management Packs in Service Manager.

Ejemplo de módulo de administración completaFull management pack example

Los siguientes ejemplos de código representan el módulo de administración de ejemplo completo que se utiliza en los ejemplos de este tema, además la definición del formulario y la C# código-subyacente del formulario.The following code examples represent the full sample management pack that is used for examples in this topic, in addition to the form definition and the C# code-behind for the form.

Módulo de administraciónManagement Pack

<ManagementPack ContentReadable="true" SchemaVersion="1.1" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">  
  <Manifest>  
    <Identity>  
      <ID>ServiceManager.Projector</ID>  
      <Version>7.0.3707.0</Version>  
    </Identity>  
    <Name>Projector Library</Name>  
    <References>  
      <Reference Alias="SMConsole">  
        <ID>Microsoft.EnterpriseManagement.ServiceManager.UI.Console</ID>  
        <Version>7.0.3707.0</Version>  
        <PublicKeyToken>31bf3856ad364e35</PublicKeyToken>  
      </Reference>  
      <Reference Alias="Authoring">  
        <ID>Microsoft.EnterpriseManagement.ServiceManager.UI.Authoring</ID>  
        <Version>7.0.3707.0</Version>  
        <PublicKeyToken>31bf3856ad364e35</PublicKeyToken>  
      </Reference>  
      <Reference Alias="System">  
        <ID>System.Library</ID>  
        <Version>7.0.3707.0</Version>  
        <PublicKeyToken>31bf3856ad364e35</PublicKeyToken>  
      </Reference>  
      <Reference Alias="SMConfig">  
        <ID>ServiceManager.ConfigurationManagement.Library</ID>  
        <Version>7.0.3707.0</Version>  
        <PublicKeyToken>31bf3856ad364e35</PublicKeyToken>  
      </Reference>  
    </References>  
  </Manifest>  
  <TypeDefinitions>  
    <EntityTypes>  
      <ClassTypes>  
        <ClassType ID="System.ConfigItem.Projector" Accessibility="Public" Abstract="false" Base="System!System.ConfigItem" Hosted="false" Singleton="false" Extension="false">  
          <Property ID="SerialNumber" Type="int" Key="true" />  
          <Property ID="Make" Type="string" />  
          <Property ID="Model" Type="string" />  
          <Property ID="Location" Type="string" />  
          <Property ID="Condition" Type="enum" EnumType="ProjectorCondition" />  
        </ClassType>  
      </ClassTypes>  
      <EnumerationTypes>  
        <EnumerationValue ID="ProjectorCondition" Accessibility="Public" />  
        <EnumerationValue ID="ProjectorCondition.Working" Accessibility="Public" Parent="ProjectorCondition" />  
        <EnumerationValue ID="ProjectorCondition.BeingRepaired" Accessibility="Public" Parent="ProjectorCondition" />  
        <EnumerationValue ID="ProjectorCondition.New" Accessibility="Public" Parent="ProjectorCondition" />  
        <EnumerationValue ID="ProjectorCondition.Broken" Accessibility="Public" Parent="ProjectorCondition" />  
        <EnumerationValue ID="ProjectorViewTasksEnumeration" Accessibility="Public" />  
      </EnumerationTypes>  
    </EntityTypes>  
  </TypeDefinitions>  
  <Categories>  
    <Category ID="AllProjectorsView.Category" Target="AllProjectorsView" Value="SMConsole!Microsoft.EnterpriseManagement.ServiceManager.UI.Console.ViewTasks" />  
    <Category ID="ProjectorViewHasTasks.CreateTask" Target="AllProjectorsView" Value="Authoring!Microsoft.EnterpriseManagement.ServiceManager.UI.Authoring.CreateTypeCategory" />  
    <Category ID="Projector.ProjectorConditionCategory" Target="ProjectorCondition" Value="Authoring!Microsoft.EnterpriseManagement.ServiceManager.UI.Authoring.EnumerationViewTasks" />  
    <Category ID="Project.ProjectorConditionEnumVisibleCategory" Target="ProjectorCondition" Value="System!VisibleToUser" />  
  </Categories>  
  <Presentation>  
    <Forms>  
      <Form ID="TestForm" Accessibility="Public" Target="System.ConfigItem.Projector" Assembly="ProjectorFormsAssembly" TypeName="New_CI_lab.TestControl">  
        <Category>Form</Category>  
      </Form>  
    </Forms>  
    <Views>  
      <View ID="AllProjectorsView" Accessibility="Public" Enabled="true" Target="System.ConfigItem.Projector" TypeID="SMConsole!GridViewType" Visible="true">  
    <Category>NotUsed</Category>  
    <Data>  
    <Adapters>  
    <Adapter AdapterName="dataportal:EnterpriseManagementObjectAdapter">  
    <AdapterAssembly>Microsoft.EnterpriseManagement.UI.SdkDataAccess</AdapterAssembly>  
    <AdapterType>Microsoft.EnterpriseManagement.UI.SdkDataAccess.DataAdapters.EnterpriseManagementObjectAdapter</AdapterType>  
    </Adapter>  
    <Adapter AdapterName="viewframework://adapters/AdvancedList">  
    <AdapterAssembly>Microsoft.EnterpriseManagement.UI.ViewFramework</AdapterAssembly>  
    <AdapterType>Microsoft.EnterpriseManagement.UI.ViewFramework.AdvancedListSupportAdapter</AdapterType>  
    </Adapter>  
    <Adapter AdapterName="omsdk://Adapters/Criteria">  
    <AdapterAssembly>Microsoft.EnterpriseManagement.UI.SdkDataAccess</AdapterAssembly>  
    <AdapterType>Microsoft.EnterpriseManagement.UI.SdkDataAccess.DataAdapters.SdkCriteriaAdapter</AdapterType>  
    </Adapter>  
    </Adapters>  
    <ItemsSource>  
    <AdvancedListSupportClass DataTypeName="" AdapterName="viewframework://adapters/AdvancedList" FullUpdateAdapter="dataportal:EnterpriseManagementObjectAdapter" FullUpdateFrequency='1' DataSource="mom:ManagementGroup"   
  IsRecurring="true" RecurrenceFrequency="5000"  Streaming='true' xmlns="clr-namespace:Microsoft.EnterpriseManagement.UI.ViewFramework;assembly=Microsoft.EnterpriseManagement.UI.ViewFramework" xmlns:av="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" >  
    <AdvancedListSupportClass.Parameters>  
                <QueryParameter Parameter="TargetClass" Value="System.ConfigItem.Projector"/>  
    </AdvancedListSupportClass.Parameters>  
    </AdvancedListSupportClass>  
    </ItemsSource>  
    <Criteria />  
    </Data>  
    <Presentation>  
    <Columns>  
<mux:ColumnCollection xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:mux="http://schemas.microsoft.com/SystemCenter/Common/UI/Views/GridView" xmlns:s="clr-namespace:System;assembly=mscorlib">  
              <mux:Column Name="SerialNumber" DisplayMemberBinding="{Binding Path=SerialNumber}" Width="100" DisplayName="SerialNumber" Property="SerialNumber" DataType="s:Int32" />  
              <mux:Column Name="Location" DisplayMemberBinding="{Binding Path=Location}" Width="100" DisplayName="Location" Property="Location" DataType="s:String" />  
              <mux:Column Name="Condition" DisplayMemberBinding="{Binding Path=Condition.DisplayName}" Width="100" DisplayName="Condition" Property="Condition.DisplayName" DataType="s:String" />  
              <mux:Column Name="DisplayName" DisplayMemberBinding="{Binding Path=DisplayName}" Width="100" DisplayName="Display Name" Property="DisplayName" DataType="s:String" />  
              <mux:Column Name="OwnerUser" DisplayMemberBinding="{Binding Path=OwnerUser.DisplayName}" Width="100" DisplayName="SupportOwner" Property="OwnerUser.DisplayName" DataType="s:String" />  
            </mux:ColumnCollection>      
    </Columns>  
    </Presentation>  
    </View>  
    </Views>  
    <Folders>  
      <Folder ID="Folder.Projectors" Accessibility="Public" ParentFolder="SMConfig!ServiceManager.Console.ConfigurationManagement.ConfigItem.Root" />  
    </Folders>  
    <FolderItems>  
      <FolderItem ElementID="AllProjectorsView" ID="FolderItem.AllProjectors" Folder="Folder.Projectors" />  
    </FolderItems>  
    <ImageReferences>  
      <ImageReference ElementID="Folder.Projectors" ImageID="SMConfig!ConfigItemImage16x16" />  
      <ImageReference ElementID="AllProjectorsView" ImageID="SMConfig!ConfigItemImage16x16" />  
    </ImageReferences>  
  </Presentation>  
  <LanguagePacks>  
    <LanguagePack ID="ENU" IsDefault="true">  
      <DisplayStrings>  
    <DisplayString ElementID="System.ConfigItem.Projector">  
    <Name>Projector</Name>  
    </DisplayString>  
        <DisplayString ElementID="Folder.Projectors">  
          <Name>Projectors</Name>  
          <Description>This is the Projector Folder</Description>  
        </DisplayString>  
        <DisplayString ElementID="AllProjectorsView">  
          <Name>All Projectors</Name>  
          <Description>This displays all projectors</Description>  
        </DisplayString>  
        <DisplayString ElementID="ProjectorCondition.Working">  
          <Name>Working</Name>  
        </DisplayString>  
        <DisplayString ElementID="ProjectorCondition.Broken">  
          <Name>Broken</Name>  
        </DisplayString>  
        <DisplayString ElementID="ProjectorCondition.BeingRepaired">  
          <Name>In Repair</Name>  
        </DisplayString>  
        <DisplayString ElementID="ProjectorCondition.New">  
          <Name>New</Name>  
        </DisplayString>  
      </DisplayStrings>  
    </LanguagePack>  
  </LanguagePacks>  
  <Resources>  
    <Assembly ID="ProjectorFormsAssembly" Accessibility="Public" FileName="New_CI_lab.dll" QualifiedName="New_CI_lab, Version=0.0.0.0" />  
  </Resources>  
</ManagementPack>  

Definición del formularioForm Definition


<UserControl  
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"  
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"  
    xmlns:local="clr-namespace:SMFormsDemo"  
    x:Class="SMFormsDemo.TestControl"  
    x:Name="Control"  
    Width="574" Height="390" Opacity="1" xmlns:d="http://schemas.microsoft.com/expression/blend/2008" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" mc:Ignorable="d" Background="{DynamicResource {x:Static SystemColors.WindowBrushKey}}">  
  <UserControl.Resources>  
    <ObjectDataProvider ObjectType="{x:Type local:helper}"  MethodName="GetStatusValues" x:Key="getStatusValues" />  
  </UserControl.Resources>  
  <Grid x:Name="LayoutRoot">  
    <Label Margin="70,20,0,0" HorizontalAlignment="Left" VerticalAlignment="Top" Width="160" Height="25" Content="Serial Number:"/>  
    <TextBox Margin="180,20,0,0" HorizontalAlignment="Left" VerticalAlignment="Top" Width="160" Height="25" d:IsStaticText="True" Text="{Binding Path=SerialNumber, Mode=TwoWay}"/>  
    <Label Margin="70,60,0,0" HorizontalAlignment="Left"  VerticalAlignment="Top" Width="160" Height="25" Content="Make:"/>  
    <TextBox Margin="180,60,0,0" HorizontalAlignment="Left" VerticalAlignment="Top" Width="160" Height="25" d:IsStaticText="True" Text="{Binding Path=Make, Mode=TwoWay}" />  
    <Label Margin="70,100,0,0" HorizontalAlignment="Left" VerticalAlignment="Top" Width="160" Height="25" Content="Model:"/>  
    <TextBox Margin="180,100,0,0" HorizontalAlignment="Left" VerticalAlignment="Top" Width="160" Height="25" d:IsStaticText="True" Text="{Binding Path=Model, Mode=TwoWay}"/>  
    <Label Margin="70,140,80,0" HorizontalAlignment="Left" VerticalAlignment="Top" Width="160" Height="25" Content="Location:"/>  
    <TextBox Margin="180,140,80,0" HorizontalAlignment="Left" VerticalAlignment="Top" Width="160" Height="25" d:IsStaticText="True" Text="{Binding Path=Location, Mode=TwoWay}" />  
    <Label Margin="70,180,80,0" HorizontalAlignment="Left" VerticalAlignment="Top" Width="160" Height="25" Content="Condition:"/>  
    <ComboBox Margin="180,180,80,0" HorizontalAlignment="Left" VerticalAlignment="Top" Width="160" Height="25" ItemsSource="{Binding Source={StaticResource getStatusValues}, Mode=OneWay }" IsSynchronizedWithCurrentItem="True">  
      <ComboBox.SelectedItem>  
        <Binding Path="Condition" Mode="TwoWay" UpdateSourceTrigger="PropertyChanged"/>  
      </ComboBox.SelectedItem>  
      <ComboBox.ItemTemplate>  
        <DataTemplate>  
          <StackPanel>  
            <TextBlock Text="{Binding Path=DisplayName}"/>  
          </StackPanel>  
        </DataTemplate>  
      </ComboBox.ItemTemplate>  
    </ComboBox>  
  </Grid>  
</UserControl>  

Código de formulario-detrásForm Code-Behind


using System;  
using System.Collections.Generic;  
using System.Collections.ObjectModel;  
using System.Threading;  
using System.Windows.Controls;  
using Microsoft.EnterpriseManagement.ServiceManager.Application.Common;  
using Microsoft.EnterpriseManagement.UI.DataModel;  
namespace SMFormsDemo  
{  
   /// <summary>  
   /// Interaction logic for ProjectorForm.xaml  
   /// </summary>  
   public partial class TestControl : UserControl  
   {  
        public TestControl()  
      {  
         InitializeComponent();  
      }        
   }  
   public class helper  
   {  

      public static ICollection<IDataItem> GetStatusValues()  
      {  
            return ConsoleContextHelper.Instance.GetEnumerations("ProjectorCondition",true);  
      }  
   }  
}  

Pasos siguientesNext steps