Compartir a través de

Cómo: Definir un controlador de vínculos de elementos de trabajo

  • Artículo

Puede crear una Extensión de integración de Visual Studio que responda cuando el usuario cree o elimine un vínculo establecido entre un elemento del modelo UML y un elemento de trabajo. Por ejemplo, si el usuario decide vincular un nuevo elemento de trabajo a un elemento del modelo, el código podría inicializar los campos del elemento de trabajo a partir de los valores del modelo.

Configurar una solución de extensión UML

De este modo, podrá desarrollar controladores y distribuirlos posteriormente a otros usuarios. Es necesario configurar dos proyectos de Visual Studio:

  • Un proyecto de biblioteca de clases que contenga el código del controlador de vínculos.

  • Un proyecto VSIX, que actúe como contenedor a la hora de instalar el comando. Si lo desea, puede incluir otros componentes en el mismo VSIX.

Para configurar la solución de Visual Studio

  1. Cree un proyecto de biblioteca de clases, ya sea agregándolo a una solución VSIX existente o creando una nueva solución.

    1. En el menú Archivo, elija Nuevo y haga clic en Proyecto.

    2. Bajo Plantillas instaladas, haga clic en Visual C# o en Visual Basic y a continuación, en la columna central, haga clic en Biblioteca de clases.

    3. Establezca Solución para indicar si desea crear una nueva solución o agregar un componente a una solución VSIX que ya tiene abierta.

    4. Especifique el nombre y la ubicación del proyecto, y haga clic en Aceptar.

  2. A menos que la solución ya contenga uno, cree un proyecto VSIX.

    1. En el Explorador de soluciones, haga clic con el botón secundario en la solución, seleccione Agregar y, a continuación, haga clic en Nuevo proyecto.

    2. En Plantillas instaladas, expanda Visual C# o Visual Basic y, a continuación, haga clic en Extensibilidad. En la columna central, haga clic en Proyecto VSIX.

  3. Establezca el proyecto VSIX como proyecto de inicio de la solución.

    • En el Explorador de soluciones, haga clic con el botón secundario en el proyecto VSIX y, a continuación, haga clic en Establecer como proyecto de inicio.

  4. En source.extension.vsixmanifest, en Contenido, agregue el proyecto de biblioteca de clases como un componente MEF.

    1. Abra source.extension.vsixmanifest.

    2. Haga clic en Agregar contenido.

    3. En Seleccione un tipo de contenido, seleccione MEF Component.

    4. En Seleccione un origen, haga clic en Proyecto y seleccione el nombre del proyecto de biblioteca de clases.

  5. Haga clic en Seleccionar ediciones y seleccione las ediciones de Visual Studio en las que desee que se ejecute la extensión.

  6. Establezca el nombre y los campos descriptivos de VSIX. Guarde el archivo.

Definir el controlador de vínculos de elementos de trabajo

Realice todas las tareas siguientes en el proyecto de biblioteca de clases.

Referencias del proyecto

Agregue los siguientes ensamblados .NET a las referencias del proyecto:

Microsoft.TeamFoundation.WorkItemTracking.Client.dll

Microsoft.VisualStudio.TeamFoundation.WorkItemTracking.dll Microsoft.VisualStudio.Modeling.Sdk.10.0

Microsoft.VisualStudio.ArchitectureTools.Extensibility.Uml

Microsoft.VisualStudio.Uml.Interfaces

System.ComponentModel.Composition

System.Drawing : usado en el código de ejemplo

Si no puede encontrar una de estas referencias bajo la pestaña .NET del cuadro de diálogo Agregar referencia, utilice la pestaña Examinar para buscarla en Archivos de programa\Microsoft Visual Studio 10.0\Common7\IDE\PrivateAssemblies\.

Importar el espacio de nombres de elemento de trabajo

En Referencias del proyecto de Visual Studio, agregue referencias a los siguientes ensamblados: 

  • Microsoft.TeamFoundation.WorkItemTracking.Client.dll

  • Microsoft.VisualStudio.TeamFoundation.WorkItemTracking.dll

En el código de programa, importe los siguientes espacios de nombres:

using System.ComponentModel.Composition;
using Microsoft.VisualStudio.Uml.Classes;
using Microsoft.VisualStudio.ArchitectureTools.Extensibility.Uml;
using Microsoft.VisualStudio.TeamFoundation.WorkItemTracking;
using System.Linq;

Definir el controlador de eventos de elementos de trabajo vinculados

Agregue un archivo de clase al proyecto de biblioteca de clases y establezca su contenido de la manera siguiente. Cambie los nombres de clase y espacio de nombres como desee.

using System.ComponentModel.Composition;
using Microsoft.VisualStudio.Uml.Classes;
using Microsoft.VisualStudio.ArchitectureTools.Extensibility.Uml;
using Microsoft.VisualStudio.ArchitectureTools.Extensibility.Presentation;
using Microsoft.VisualStudio.TeamFoundation.WorkItemTracking;
using System.Linq;


namespace WorkItems
{
  [Export(typeof(ILinkedWorkItemExtension))]
  public class MyWorkItemExtension : ILinkedWorkItemExtension
  {
    // Called before a new work item is edited by the user.
    // Use this to initialize work item fields from the model element.
    public void OnWorkItemCreated(System.Collections.Generic.IEnumerable<IElement> elementsToBeLinked, IWorkItemDocument workItemDocument)
    {
      INamedElement namedElement =
            elementsToBeLinked.First() as INamedElement;
      if (namedElement != null)
        workItemDocument.Item.Title = namedElement.Name;

    }

    // Called when any work item is linked to a model element.
    public void OnWorkItemLinked(System.Collections.Generic.IEnumerable<IElement> elements, string serverUri, int workItemId)
    {
      foreach (IElement element in elements)
        foreach (IShape shape in element.Shapes())
          shape.Color = System.Drawing.Color.Red;
    }

    // Called when a work item is unlinked from a model element.
    public void OnWorkItemRemoved(IElement element, string serverUri, int workItemId)
    {
      foreach (IShape shape in element.Shapes())
        shape.Color = System.Drawing.Color.White;
    }
  }
}

Probar el controlador de vínculos

Para probar, ejecute el controlador de vínculos en modo de depuración.

Para probar el controlador de vínculos

  1. Presione F5 o bien, en el menú Depurar, haga clic en Iniciar depuración.

    Se iniciará una instancia experimental de Visual Studio.

    Solución de problemas: si no se inicia un nuevo Visual Studio, asegúrese de que el proyecto VSIX esté establecido como proyecto de inicio de la solución.

  2. En la instancia experimental de Visual Studio, abra o cree un proyecto de modelado, y abra o cree un diagrama de modelado.

  3. Cree un elemento de modelo como una clase UML y establezca su nombre.

  4. Haga clic con el botón secundario en el elemento y, a continuación, haga clic en Crear elemento de trabajo.

    • Si el submenú muestra Abrir conexión de Team Foundation Server, haga clic en esa opción y siga los cuadros de diálogos para conectarse a un servidor. A continuación, vuelva a haga clic con el botón secundario en el elemento de modelo y haga clic en Crear elemento de trabajo.

    • Si el submenú muestra una lista de tipos de elemento de trabajo, haga clic en uno de ellos.

      Se abrirá un formulario de nuevo elemento de trabajo.

  5. Compruebe que el título del elemento de trabajo sea igual que el elemento de modelo, si ha usado el código de ejemplo de la sección anterior. Esto indica que OnWorkItemCreated() ha funcionado.

  6. Complete el formulario, guarde y cierre el elemento de trabajo.

  7. Compruebe que el elemento de trabajo es ahora de color rojo. Esto muestra OnWorkItemLinked() en el código de ejemplo.

    Solución de problemas: si los métodos del controlador no se han ejecutado, compruebe lo siguiente:

    • El proyecto de biblioteca de clases se muestra como un componente MEF en la lista Contenido de source.extensions.manifest en el proyecto VSIX.

    • Se ha adjuntado el atributo Export correcto a la clase del controlador y la clase implementa ILinkedWorkItemExtension.

    • Los parámetros de todos los atributos Export e Import son válidos.

Acerca del código del controlador de elementos de trabajo

Escuchar nuevos elementos de trabajo

OnWorkItemCreated se invoca cuando el usuario decide crear un nuevo elemento de trabajo que se va a vincular a elementos del modelo. El código puede inicializar los campos de elementos de trabajo. El elemento de trabajo se presenta a continuación al usuario, que puede actualizar los campos y guardar el elemento de trabajo. El vínculo a un elemento del modelo no se crea hasta que el elemento de trabajo se ha guardado correctamente.

  public void OnWorkItemCreated(
      IEnumerable<IElement> elementsToBeLinked,
      IWorkItemDocument workItem)
  {
    INamedElement namedElement = 
           elementsToBeLinked.First() as INamedElement;
    if (namedElement != null)
        workItem.Item.Title = namedElement.Name;
  }

Realizar escuchas para la creación de vínculos

OnWorkItemLinked se invoca inmediatamente después de crear un vínculo. Se invoca cuando el vínculo es a un nuevo elemento de trabajo o un elemento existente. Se llama una vez por cada elemento de trabajo.

public void OnWorkItemLinked
        (IEnumerable<IElement> elements, 
         string serverUri, // TFS server
         int workItemId)
{
  foreach (IElement element in elements)
    foreach (IShape shape in element.Shapes())
         shape.Color = System.Drawing.Color.Red;
}

Nota

Para que este ejemplo funcione, debe agregar una referencia de proyecto a System.Drawing.dll e importar el espacio de nombres Microsoft.VisualStudio.ArchitectureTools.Extensibility.Presentation. Sin embargo, estas adiciones no son necesarias para otras implementaciones de OnWorkItemLinked.

Realizar escuchas para la eliminación de vínculos

OnWorkItemRemoved se invoca una vez inmediatamente antes de que se elimine cada vínculo de elementos de trabajo. Si se elimina un elemento del modelo, se quitarán todos sus vínculos.

public void OnWorkItemRemoved
         (IElement element, string serverUri, int workItemId)
{...}

Actualizar un elemento de trabajo

A través de los espacios de nombres de Team Foundation, puede manipular un elemento de trabajo.

Para usar el ejemplo siguiente, agregue estos ensamblados .NET a las referencias del proyecto:

  • Microsoft.TeamFoundation.Client.dll

  • Microsoft.TeamFoundation.WorkItemTracking.Client.dll

using Microsoft.TeamFoundation.Client;
using Microsoft.TeamFoundation.WorkItemTracking.Client;
...
public void OnWorkItemLinked
        (IEnumerable<IElement> elements, 
         string serverUri, // TFS server
         int workItemId)
{
  TfsTeamProjectCollection tfs =
        TfsTeamProjectCollectionFactory
            .GetTeamProjectCollection(new Uri(serverUri));
  WorkItemStore workItemStore = new WorkItemStore(tfs);
  WorkItem item = workItemStore.GetWorkItem(workItemId);
  item.Open();
  item.Title = "something";
  item.Save();
} 

Acceso a los vínculos de referencia de elementos de trabajo

Puede tener acceso a los vínculos del modo siguiente:

//Get:
string linkString = element.GetReference(ReferenceConstants.WorkItem);
// Set:
element.AddReference(ReferenceConstants.WorkItem, linkString, true);

El formato de linkString es:

string.Format(@"%{0}\{1}#{1}${2}", tfServer, projectCollection, RepositoryGuid, workItem.Id);

donde:

  • El identificador URI del servidor sería:

    http://tfServer:8080/tfs/projectCollection

    El uso de minúsculas y mayúsculas es importante en projectCollection.

  • RepositoryGuid se puede obtener de la conexión a TFS:

    TfsTeamProjectCollection tpc = TfsTeamProjectCollectionFactory...;
RepositoryGuid= tpc.InstanceId;

Para obtener más información acerca de las referencias, vea Cómo: Adjuntar cadenas de referencia a elementos de modelo.

Vea también

Tareas

Cómo: Vincular elementos de trabajo con elementos de modelo

Referencia

Microsoft.TeamFoundation.WorkItemTracking.Client.WorkItemStore

Otros recursos

Cómo: Adjuntar cadenas de referencia a elementos de modelo

Cómo: Definir e instalar una extensión de modelado

Programar con la API de UML