Como: definir um comando de Menu em um diagrama de modelagem

Artigo
02/25/2013

Em o Visual Studio final, você pode definir itens de menu adicionais no menu de atalho de um diagrama de UML.Você pode controlar se o comando de menu aparece e está ativado no menu de atalho de qualquer elemento no diagrama, e você pode escrever código que executa quando o usuário escolher o item de menu.Você pode armazenar essas extensões em uma extensão de integração do Visual Studio (VSIX) e distribui-las para outros usuários do Visual Studio.

Requisitos

O Visual Studio SDK, que você pode obter Galeria do Visual Studio.
O SDK de visualização e modelagem do Visual Studio, que você pode obter O SDK de visualização e modelagem do Visual Studio na galeria de código.

Para criar um comando de menu para um designer de UML, você deve criar uma classe que define o comportamento de comando, e insere a classe em uma extensão de integração do Visual Studio (VSIX).O VSIX atua como um recipiente que pode instalar o comando.Há dois métodos alternativas para definir um comando de menu:

Crie um comando de menu em seu próprio VSIX usando um modelo de projeto. Este método é o mais rápido.Use se você não desejar combinar os comandos de menu com outros tipos de extensão como extensões de validação, itens personalizados da caixa de ferramentas, ou manipuladores do gesto.
Crie o comando de menu separado e projetos de VSIX. Use este método se você desejar combinar vários tipos de extensão no mesmo VSIX.Por exemplo, se o comando de menu espera o modelo observe restrições específicas, você pode incorporar-lo no mesmo VSIX que um método de validação.

Em a caixa de diálogo de Novo Projeto , em modelando projetos, Extensão de comandoselecione.
Abra o arquivo de .cs no novo projeto e modificar a classe de CommandExtension para implementar o comando.

Para obter mais informações, consulte implementando o comando de menu.
Você pode adicionar comandos adicionais ao projeto definindo novas classes.
Testar o comando de menu pressionando F5.Para obter mais informações, consulte Executar o comando de menu.
Instalar o comando de menu em outro computador copiar o arquivo bin\*\*.vsix que é compilado pelo projeto.Para obter mais informações, consulte instalando o comando de menu.

Aqui está o procedimento alternativo:

Crie um projeto de biblioteca de classes, em uma nova solução do Visual Studio, ou em uma solução existente.
1. Em o menu de Arquivo , escolha Novo, Projeto.
2. Em modelos instalados, Visual C# selecione ou Visual Basic.Em a coluna do meio, escolha Biblioteca de Classes.
3. Definir Solução para indicar se você deseja criar uma nova solução ou adicione um componente a uma solução de VSIX que você já abre.
4. Defina o nome do projeto e o local e clique em OK.

Adicione as seguintes referências ao seu projeto.

Referência	O que isso permite que você faça
System.ComponentModel.Composition	Define componentes usando Estrutura de extensibilidade gerenciado (MEF).
Microsoft.VisualStudio.Uml.Interfaces	Ler e altere as propriedades dos elementos modelo.
Microsoft.VisualStudio.ArchitectureTools.Extensibility	Crie elementos modelo, modifique formas em diagramas.
Microsoft.VisualStudio.Modeling.Sdk.11.0	Defina os manipuladores de eventos modelo. Encapsular a série de alterações no modelo.Para mais informações, consulte Como: atualizações do modelo de Link usando transações.
Microsoft.VisualStudio.Modeling.Sdk.Diagrams.11.0 (necessário) não sempre	Acessar elementos adicionais de diagrama para manipuladores do gesto.
Microsoft.VisualStudio.ArchitectureTools.Extensibility.Layer Necessário apenas para comandos em diagramas da camada.Para mais informações, consulte Estendendo os diagramas de camada.	Definir comandos em um diagrama de camada.

Adicione um arquivo de classe ao projeto e defina seu conteúdo código a seguir.

Observação
Alterar o namespace, o nome da classe, e o valor retornado por Text a sua preferência. Se você definir mais comandos, aparecem no menu em ordem alfabética de nomes de classe.

Alterar o namespace, o nome da classe, e o valor retornado por Text a sua preferência.

Se você definir mais comandos, aparecem no menu em ordem alfabética de nomes de classe.

using System.ComponentModel.Composition;   
using System.Linq;
using Microsoft.VisualStudio.ArchitectureTools.Extensibility.Presentation;
using Microsoft.VisualStudio.ArchitectureTools.Extensibility.Uml;
using Microsoft.VisualStudio.Modeling.ExtensionEnablement;
using Microsoft.VisualStudio.Uml.AuxiliaryConstructs;
using Microsoft.VisualStudio.Uml.Classes; 
    // ADD other UML namespaces if required

namespace UMLmenu1 // CHANGE
{
  // DELETE any of these attributes if the command
  // should not appear in some types of diagram.
  [ClassDesignerExtension]
  [ActivityDesignerExtension]
  [ComponentDesignerExtension]
  [SequenceDesignerExtension]
  [UseCaseDesignerExtension] 
  // [LayerDesignerExtension]

  // All menu commands must export ICommandExtension:
  [Export (typeof(ICommandExtension))]
  // CHANGE class name – determines order of appearance on menu:
  public class Menu1 : ICommandExtension
  {
    [Import]
    public IDiagramContext DiagramContext { get; set; }

    public void QueryStatus(IMenuCommand command)
    { // Set command.Visible or command.Enabled to false
      // to disable the menu command.
      command.Visible = command.Enabled = true;
    }

    public string Text
    {
      get { return "MENU COMMAND LABEL"; }
    }

    public void Execute(IMenuCommand command)
    {
      // A selection of starting points:
      IDiagram diagram = this.DiagramContext.CurrentDiagram;
      foreach (IShape<IElement> shape in diagram.GetSelectedShapes<IElement>())
      { IElement element = shape.Element; }
      IModelStore modelStore = diagram.ModelStore;
      IModel model = modelStore.Root;
      foreach (IElement element in modelStore.AllInstances<IClass>()) 
      { }
    }
  }
}

Para obter mais informações sobre o que a colocar em métodos, consulte implementando o comando de menu.

Você deve adicionar o comando de menu para um projeto de VSIX, que atua como um recipiente para instalar o comando.Se você desejar, você pode incluir outros componentes no mesmo VSIX.

Você não precisa este procedimento se você criou o comando de menu com seu próprio VSIX.
Crie um projeto de VSIX, a menos que sua solução já tem um.
1. Em Gerenciador de Soluções, no menu de atalho da solução, escolha Adicionar, Novo Projeto.
2. Em modelos instalados, expanda Visual C# ou Visual Basic, então escolha Extensibilidade.Em a coluna do meio, escolha projeto de VSIX.
Em o solution Explorer, no menu de atalho do projeto de VSIX, escolha Definir como projeto de inicialização.
Abrir source.extension.vsixmanifest.
1. Em a guia de metadados , definir um nome para o VSIX.
2. Em a guia de Destinos instalar , defina o Visual Studio final e superior como destinos.
3. Em a guia de recursos , escolha Novo, e na caixa de diálogo, defina:
  
  Tipo = Componente de MEF
  
  Origem = Um projeto na solução atual
  
  Projeto = Seu projeto de biblioteca de classe

A classe de comando de menu implementa os métodos necessários para ICommandExtension.

string Text { get; }

Retornar o rótulo do item de menu.

void QueryStatus(IMenuCommand command);

Chamado quando o usuário clica com o botão direito do mouse no diagrama.

Este método não deve modificar o modelo.

Use DiagramContext.CurrentDiagram.SelectedShapes para determinar se você desejar que o comando aparecer e ser ativado.

Conjunto:

command.Visible a true se o comando deve aparecer no menu quando o usuário clica com o botão direito do mouse no diagrama
command.Enabled a true se o usuário pode clicar no comando no menu
command.Text para definir dinamicamente a etiqueta do menu

void Execute (IMenuCommand command);

Chamado quando o usuário clica o item de menu, se é visível e ativado.

Acessando o modelo no código

Incluindo a seguinte declaração na sua classe de comando de menu:

[Import] public IDiagramContext DiagramContext { get; set; }

...

A declaração de IDiagramContext permite que você escreva código em seus métodos que acessa o diagrama, a seleção atual, e o modelo:

IDiagram diagram = this.DiagramContext.CurrentDiagram;
foreach (IShape<IElement> shape in diagram.GetSelectedShapes<IElement>())
{ IElement element = shape.Element; ... }
IModelStore modelStore = diagram.ModelStore;
IModel model = modelStore.Root;
foreach (IElement element in modelStore.AllInstances<IUseCase>()) {...}

Navegando no modelo e atualizando

Elementos modelo de UML estão disponíveis com tudo API.A seleção atual ou raiz do modelo, você pode acessar todos os elementos restantes.Para obter mais informações, consulte Como: navegar o modelo UML e Programação com a API de UML.

Se você está tratando um diagrama de seqüência, consulte também Como: Editar diagramas de seqüência usando a API de UML.

API também permite que você altere as propriedades de elementos, dos elementos de exclusão e relacionamentos, e criar novos elementos e relacionamentos.

Por padrão, cada alteração que você fez no seu executa o método será executada em uma transação separadamente.O usuário poderá desfazer separado para cada alteração.Se você deseja agrupar as alterações em uma única transação, use ILinkedUndoTransaction como descrito em Como: atualizações do modelo de Link usando transações.

Use o encadeamento de interface de usuário para atualizações

Em alguns casos pode ser útil fazer atualizações para o modelo de um segmento de plano de fundo.Por exemplo, se o comando carrega dados de um recurso lento, você pode executar a carga em um segmento de brackground para que o usuário possa ver as alterações quando está em andamento, e cancelar a operação se necessário.

Em o entanto, você deve estar ciente que o armazenamento modelo não tem segurança de segmentos.Você sempre deve usar o encadeamento de interface de usuário (UI) para realizar atualizações, e se possível, impede que o usuário faça edições quando a operação de plano de fundo está em andamento.Para um exemplo, consulte Como: atualizar um modelo UML a partir de um Thread de plano de fundo.

Para fins de teste, execute o comando no modo de depuração.

Pressione F5, ou no menu de Depurar , escolha Iniciar Depuração.

Uma instância de avaliação de Visual Studio .

Solução de Problemas: se novo Visual Studio não começa:
- Se você tiver mais de um projeto, certifique-se que o projeto de VSIX é definido como o projeto de inicialização de solução.
- Em o solution Explorer, no menu de atalho de inicialização ou somente de projeto, escolha Propriedades.Em o editor de propriedades do projeto, selecione a guia de Depurar .Certifique-se de que a cadeia de caracteres no campo de Inicie o programa externo é o nome do caminho completo de Visual Studio, normalmente:
  
  C:\Program Files\Microsoft Visual Studio 11,0 \ Common7 \ IDE \ devenv.exe
Em Visual Studiode avaliação, abra ou crie um projeto e modelagem, abra ou crie um diagrama modelando.Use um diagrama que pertence a um dos tipos que são listados nos atributos de sua classe de comando de menu.
Abra o menu de atalho em qualquer lugar no diagrama.O comando deve aparecer no menu.

Solução de Problemas: Se o comando não aparece no menu, certifique-se que:
- O projeto de comando de menu está listado como um componente de MEF na guia de recursos em source.extensions.manifest no projeto de VSIX.
- Os parâmetros de atributos de Import e de Export são válidos.
- o método de QueryStatus não está definindo command.Enabled ou campos de Visible a false.
- O tipo de diagrama modelo que você está usando (a classe, seqüência de UML, e assim por diante) é listado como um dos atributos [ClassDesignerExtension]de classe de comando do menu, [SequenceDesignerExtension] e assim por diante.

Instalando e desinstalar uma extensão

Você pode instalar uma extensão de Visual Studio no seu próprio computador e em outros computadores.

Para instalar uma extensão

Em o seu computador, localize o arquivo de .vsix que foi compilado pelo projeto de VSIX.
1. Em Gerenciador de Soluções, no menu de atalho do projeto de VSIX, escolha Abrir pasta no Windows Explorer.
2. Localize o arquivo bin\*\YourProject.vsix
Copie o arquivo de .vsix para o computador de destino que você deseja instalar a extensão.Isso pode ser o seu próprio computador ou outro.

O computador de destino deve ter uma das edições de Visual Studio que você especificou em source.extension.vsixmanifest.
Em o computador de destino, abra o arquivo de .vsix por exemplo, clicando duas vezes no.

Instalador de extensão do Visual Studio abre e instala a extensão.
Início ou reinicie Visual Studio.

Para desinstalar uma extensão

Em o menu de Ferramentas , escolha gerenciador de extensão.
Expanda extensões instaladas.
Selecione a extensão, e então escolha Desinstalar.

Raramente, uma extensão defeituosas não carrega e cria um relatório na janela de erro, mas não aparece no gerenciador de extensão.Em esse caso, você pode remover a extensão deletando o arquivo de:

%LocalAppData%\Local\Microsoft\VisualStudio\11.0\Extensions

Exemplo

O exemplo a seguir mostra o código para um comando de menu que intercambie os nomes de dois elementos em um diagrama de classe.Esse código deve ser interno um projeto de extensão de Visual Studio e instalado como descrito nas seções anteriores.

using System.Collections.Generic; // for IEnumerable
using System.ComponentModel.Composition;
  // for [Import], [Export]
using System.Linq; // for IEnumerable extensions
using Microsoft.VisualStudio.ArchitectureTools.Extensibility.Presentation;
  // for IDiagramContext
using Microsoft.VisualStudio.ArchitectureTools.Extensibility.Uml;
  // for designer extension attributes
using Microsoft.VisualStudio.Modeling.Diagrams;
  // for ShapeElement
using Microsoft.VisualStudio.Modeling.ExtensionEnablement;
  // for IGestureExtension, ICommandExtension, ILinkedUndoContext
using Microsoft.VisualStudio.Uml.Classes;
  // for class diagrams, packages

/// <summary>
/// Extension to swap names of classes in a class diagram.
/// </summary>
namespace SwapClassNames
{
  // Declare the class as an MEF component:
  [Export(typeof(ICommandExtension))]
  [ClassDesignerExtension]
  // Add more ExportMetadata attributes to make
  // the command appear on diagrams of other types.
  public class NameSwapper : ICommandExtension
  {
  // MEF required interfaces:
  [Import]
  public IDiagramContext Context { get; set; }
  [Import]
  public ILinkedUndoContext LinkedUndoContext { get; set; }

  /// <summary>
  /// Swap the names of the currently selected elements.
  /// </summary>
  /// <param name="command"></param>
  public void Execute(IMenuCommand command)
  {
    // Get selected shapes that are IClassifiers -
    // IClasses, IInterfaces, IEnumerators.
    var selectedShapes = Context.CurrentDiagram
     .GetSelectedShapes<IClassifier>();
    if (selectedShapes.Count() < 2) return;

    // Get model elements displayed by shapes.
    IClassifier firstElement = selectedShapes.First().Element;
    IClassifier lastElement = selectedShapes.Last().Element;

    // Do the swap in a transaction so that user
    // cannot undo one change without the other.
    using (ILinkedUndoTransaction transaction =
    LinkedUndoContext.BeginTransaction("Swap names"))
    {
    string firstName = firstElement.Name;
    firstElement.Name = lastElement.Name;
    lastElement.Name = firstName;
    transaction.Commit();
    }
  }

  /// <summary>
  /// Called by Visual Studio to determine whether
  /// menu item should be visible and enabled.
  /// </summary>
  public void QueryStatus(IMenuCommand command)
  { 
    int selectedClassifiers = Context.CurrentDiagram
     .GetSelectedShapes<IClassifier>().Count();
    command.Visible = selectedClassifiers > 0;
    command.Enabled = selectedClassifiers == 2;
  }

  /// <summary>
  /// Name of the menu command.
  /// </summary>
  public string Text
  {
    get { return "Swap Names"; }
  }
  }

}