Adicionar validação personalizada da arquitetura a diagramas de camada

Em Visual Studio Ultimate e em Visual Studio Premium, os usuários podem validar o código-fonte em um projeto de Visual Studio em um modelo de camada de modo que eles possam verifique se o código-fonte está de acordo com as dependências em um diagrama de camada.Há um algoritmo padrão de validação, mas você pode definir suas próprias extensões de validação para Visual Studio Ultimate e Visual Studio Premium.

Quando o usuário seleciona o comando de Validar Arquitetura em um diagrama de camada, o método padrão de validação é invocado, seguido por todas as extensões de validação que são instaladas.

Observação
A validação em um diagrama de camada não é a mesma que a validação em diagramas de UML.Em um diagrama de camada, o objetivo principal é comparar o diagrama com código de programa em outras partes de solução.

Você pode compactar sua extensão de validação da camada em uma extensão de integração do Visual Studio (VSIX), que você pode distribuir o outro Visual Studio Ultimate usuários.Ou você pode colocar seu validação em um VSIX por si só, ou você pode combiná-la no mesmo VSIX que outras extensões.Você deve escrever código de validação em seu próprio projeto de Visual Studio , não no mesmo projeto que outras extensões.

Cuidado
Depois de criar um projeto de validação, copie código de exemplo no final deste tópico e em seguida que às suas necessidades.

Requisitos

• Visual Studio Ultimate

• Visual Studio SDK

• SDK de visualização e modelagem do Visual Studio

Definindo um validador de camada em um novo VSIX

O método o mais rápido de criar um validação é usar o modelo de projeto.Isso coloca o código e o manifesto de VSIX no mesmo projetos.

Para definir uma extensão usando um modelo de projeto

1. Crie um novo projeto em uma solução, usando o comando de Novo Projeto no menu de Arquivo .

2. Na caixa de diálogo Novo Projeto , em Modelando projetos, Extensão de validação do designer de camada.

   O modelo cria um projeto que contém uma pequena amostra.

   Cuidado
   Para fazer o modelo funcionar corretamente: Chamadas de edição a LogValidationError para remover os argumentos opcionais errorSourceNodes e errorTargetNodes. Se você usar propriedades personalizadas, aplique a atualização mencionada em Adicionar propriedades personalizadas a um diagrama de camada.Além disso, arquitetura aberta Explorer antes que você abrir uma solução modelo.

3. Editar o código para definir a validação.Para obter mais informações, consulte Validação de programação.

4. Para testar a extensão, consulte Depurando a validação de camada.

   Observação
   O método será chamado somente em circunstâncias específicas, e os pontos de interrupção não funcionará automaticamente.Para obter mais informações, consulte Depurando a validação de camada.

5. Para instalar a extensão na instância principal de Visual Studio, ou em outro computador, localizar o arquivo de .vsix em bin\*.Copie o computador onde você deseja para o instalar, clique duas vezes nele.Para desinstalar-la, use Gerenciador de Extensões no menu de Ferramentas .

Adicionando um validador de camada a um VSIX separado

Se você deseja criar um VSIX que contém validadores de camada, comandos, e outras extensões, é recomendável que você crie um projeto definir o VSIX, e projetos separados para os manipuladores.Para obter informações sobre outros tipos de modelagem a extensão, consulte Diagramas e modelos UML estendendo.

Para adicionar validação de camada a um VSIX separado

1. Crie um projeto de biblioteca de classes em uma nova ou solução existente de Visual Studio Ultimate .Na caixa de diálogo Novo Projeto , clique Visual C# e clique em Biblioteca de Classes.Este projeto conterá a classe de validação da camada.

2. Identifica ou crie um projeto de VSIX em sua solução.Um projeto de VSIX contém um arquivo chamado source.extension.vsixmanifest.Se você precisa adicionar um projeto de VSIX, siga estas etapas:

   1. Na caixa de diálogo Novo Projeto , escolha Visual C#, Extensibilidade, VSIX Projeto.

   2. Em Gerenciador de Soluções, no menu de atalho do projeto de VSIX, Definir como projeto de inicialização.

3. Em source.extension.vsixmanifest, em Ativos, adicione o projeto de validação da camada como um componente de MEF:

   1. Escolha Novo.

   2. Na caixa de diálogo Adicionar o novo recurso , defina:

      Tipo = Microsoft.VisualStudio.MefComponent

      Origem = Um projeto na solução atual

      Projeto = seu projeto de validação

4. Você também deve adicioná-lo como uma camada de validação:

   1. Escolha Novo.

   2. Na caixa de diálogo Adicionar o novo recurso , defina:

      Tipo = Microsoft.VisualStudio.ArchitectureTools.Layer.Validator.Isso não é uma das opções na lista suspensa.Você deve entrar no teclado.

      Origem = Um projeto na solução atual

      Projeto = seu projeto de validação

5. Retornar ao projeto de validação da camada intermediária, e adicione as seguintes referências de projeto:

   Referência	O que isso permite que você faça
   Microsoft.VisualStudio.GraphModel.dll	Ler o gráfico de arquitetura
   Microsoft.VisualStudio.ArchitectureTools.Extensibility.CodeSchema.dll	Ler os DOM de código associados com as camadas
   Microsoft.VisualStudio.ArchitectureTools.Extensibility.Layer.dll	Ler o modelo de camada
   Microsoft.VisualStudio.ArchitectureTools.Extensibility	Ler e forms e diagramas de atualização.
   System.ComponentModel.Composition	Defina o componente de validação que usa a extensibilidade gerenciada Framework (MEF)
   Microsoft.VisualStudio.Modeling.Sdk.11.0	Defina a modelagem extensões

6. Copie o código de exemplo no final deste tópico no arquivo de classe no projeto de biblioteca de validação conter código para a validação.Para obter mais informações, consulte Validação de programação.

7. Para testar a extensão, consulte Depurando a validação de camada.

   Observação
   O método será chamado somente em circunstâncias específicas, e os pontos de interrupção não funcionará automaticamente.Para obter mais informações, consulte Depurando a validação de camada.

8. Para instalar o VSIX na instância principal de Visual Studio, ou em outro computador, localizar o arquivo de .vsix no diretório de bin de projeto de VSIX.Copie o computador onde você deseja instalar o VSIX.Clique duas vezes no arquivo de VSIX no Windows Explorer.(Gerenciador de Arquivos no Windows 8).

   Para desinstalar-la, use Gerenciador de Extensões no menu de Ferramentas .

Validação de programação

Para definir uma extensão de validação de camadas, você define uma classe que tenha as seguintes características:

• O formulário total de declaração é a seguinte:

  
  using System.ComponentModel.Composition;
  using Microsoft.VisualStudio.ArchitectureTools.Extensibility.CodeSchema;
  using Microsoft.VisualStudio.ArchitectureTools.Extensibility.Layer;
  using Microsoft.VisualStudio.GraphModel;
  ...
   [Export(typeof(IValidateArchitectureExtension))]
    public partial class Validator1Extension :
                    IValidateArchitectureExtension
    {
      public void ValidateArchitecture(Graph graph)
      {
         GraphSchema schema = graph.DocumentSchema;
        ...
    } }
  

• Quando você descobre um erro, você pode relatórios usando LogValidationError().

  Cuidado
  Não use os parâmetros opcionais de LogValidationError.

Quando o usuário invocar o comando de menu de Validar Arquitetura , as análises do sistema de tempo de execução da camada as camadas e os artefatos gerar um gráfico.O gráfico tem quatro partes:

• Os modelos de camada de solução de Visual Studio que são representados como nós e links no gráfico.

• O código, itens de projeto, e outros artefatos que são definidos na solução e representados como nós, e links que representam as dependências descobertas pelo processo de análise.

• Links de nós de camada nós de produto de código.

• Os nós que representam erros descobriram o validador.

Quando o gráfico foi construído, o método padrão de validação é chamado.Quando isso é concluída, todos os métodos instalados de validação de extensão são chamados em ordem não-especificada.O gráfico é passado para cada método de ValidateArchitecture , que pode verificação o gráfico e relata os erros que encontrar.

Observação
Isso não é o mesmo que o processo de validação que é aplicado a diagramas de UML, e não é o mesmo que o processo de validação que pode ser usado em idiomas específicos de domínio.

Os métodos de validação não devem alterar o modelo de camada ou código que está sendo validada.

O modelo de gráfico é definido em Microsoft.VisualStudio.GraphModel.As classes principais são GraphNode e GraphLink.

Cada nó e cada link têm uma ou mais categorias que especificam o tipo de elemento ou de relacionamento que representa.Os nós de um gráfico típico têm as seguintes categorias:

• Dsl.LayerModel

• Dsl.Layer

• Dsl.Reference

• CodeSchema_Type

• CodeSchema_Namespace

• CodeSchema_Type

• CodeSchema_Method

• CodeSchema_Field

• CodeSchema_Property

Links das camadas aos elementos em código têm a categoria “representam”.

Validação de depuração

Para depurar a extensão de validação da camada, pressione CTRL+F5.Uma instância de avaliação de Visual Studio abre.Nesse caso, abra ou crie um modelo de camada.Este modelo deve ser associado com o código, e deve ter pelo menos uma dependência.

Teste com uma solução que contém dependências

A validação não é executada a menos que as seguintes características estarem presentes:

• Há pelo menos um link de dependência no diagrama de camada.

• Há as camadas no modelo que estão associadas com os elementos de código.

Na primeira vez que você iniciar uma instância de avaliação de Visual Studio para testar sua extensão de validação, abra ou crie uma solução que tem as características.

Executar a solução limpa antes validam a arquitetura

Sempre que você atualiza seu código de validação, use o comando de Limpar solução no menu de Compilar na solução de avaliação, antes que você teste o comando validar.Isso é necessário porque os resultados de validação são armazenados em cache.Se você não atualizou o diagrama da camada de teste ou seu código, os métodos de validação não serão executados.

Iniciar o depurador explicitamente

A validação é executado em um processo separado.Portanto, os pontos de interrupção no método de validação não serão disparados.Você deve anexar o depurador ao processo explicitamente quando a validação foi iniciado.

Para anexar o depurador ao processo de validação, inserir uma chamada a System.Diagnostics.Debugger.Launch() no início do seu método de validação.Quando a caixa de diálogo de depuração aparece, selecione a instância principal de Visual Studio.

Como alternativa, você pode inserir uma chamada a System.Windows.Forms.MessageBox.Show().Quando a caixa de mensagem aparece, vá para a instância principal de Visual Studio e clique em Anexar a Processodo menu de Depurar . Selecione o processo que é chamado Graphcmd.exe.

Sempre comece a instância de avaliação pressionando CTRL + (Iniciar sem depuração).

Implantando uma extensão de validação

Para instalar sua extensão de validação em um computador em que Visual Studio Ultimate ou Visual Studio Premium são instalados, abra o arquivo de VSIX no computador de destino.Para instalar em um computador em que Team Foundation Build é instalado, você deve manualmente extrair o conteúdo de VSIX em uma pasta de extensões.Para obter mais informações, consulte Implantando uma camada de extensão de modelagem.

Código de exemplo

using System;
using System.ComponentModel.Composition;
using System.Globalization;
using System.Linq;
using System.Text.RegularExpressions;
using Microsoft.VisualStudio.ArchitectureTools.Extensibility.CodeSchema;
using Microsoft.VisualStudio.ArchitectureTools.Extensibility.Layer;
using Microsoft.VisualStudio.GraphModel;

namespace Validator3
{
    [Export(typeof(IValidateArchitectureExtension))]
    public partial class Validator3Extension : IValidateArchitectureExtension
    {
        /// <summary>
        /// Validate the architecture
        /// </summary>
        /// <param name="graph">The graph</param>
        public void ValidateArchitecture(Graph graph)
        {
            if (graph == null) throw new ArgumentNullException("graph");

            // Uncomment the line below to debug this extension during validation
            // System.Windows.Forms.MessageBox.Show("Attach 2 to GraphCmd.exe with process id " + System.Diagnostics.Process.GetCurrentProcess().Id);


            // Get all layers on the diagram
            foreach (GraphNode layer in graph.Nodes.GetByCategory("Dsl.Layer"))
            {
                System.Threading.Thread.Sleep(100);
                // Get the required regex property from the layer node
                string regexPattern = "^[a-zA-Z]+$"; //layer[customPropertyCategory] as string;
                if (!string.IsNullOrEmpty(regexPattern))
                {
                    Regex regEx = new Regex(regexPattern);

                    // Get all referenced types in this layer including those from nested layers so each
                    // type is validated against all containing layer constraints.
                    foreach (GraphNode containedType in layer.FindDescendants().Where(node => node.HasCategory("CodeSchema_Type")))
                    {
                        // Check the type name against the required regex                        
                        CodeGraphNodeIdBuilder builder = new CodeGraphNodeIdBuilder(containedType.Id, graph);
                        string typeName = builder.Type.Name;
                        if (!regEx.IsMatch(typeName))
                        {
                            // Log an error
                            string message = string.Format(CultureInfo.CurrentCulture, Resources.InvalidTypeNameMessage, typeName);
                            this.LogValidationError(graph, typeName + "TypeNameError", message, GraphErrorLevel.Error, layer);
                        }
                    }
                }

            }

        }
    }
}

Consulte também

Conceitos

Estendendo os diagramas de camada