Compartilhar via

Diagramas de dependência: diretrizes

  • Artigo

Descrever a arquitetura do aplicativo em alto nível criando diagramas de dependência no Visual Studio. Verifique se o código permanece consistente com esse design, validando seu código com um diagrama de dependência. Você também pode incluir a validação de camada no processo de build.

Para ver quais edições do Visual Studio dão suporte a esse recurso, confira Suporte de edição para ferramentas de arquitetura e modelagem.

Observação

Diagramas de dependência para projetos do .NET Core têm suporte a partir do Visual Studio 2019 versão 16.2.

O que é um diagrama de dependência?

Como um diagrama de arquitetura tradicional, um diagrama de dependência identifica os principais componentes ou unidades funcionais do design e as respectivas interdependências. Cada nó no diagrama, chamado de camada, representa um grupo lógico de namespaces, projetos ou outros artefatos. Você pode desenhar as dependências que devem existir no seu design. Ao contrário de um diagrama de arquitetura tradicional, você pode verificar se as dependências reais no código-fonte estão em conformidade com as dependências pretendidas especificadas. Ao fazer parte da validação de um build regular no Team Foundation Server, você pode garantir que o código do programa continue a seguir a arquitetura do sistema com as alterações futuras. Confira Diagramas de dependência: referência.

Como criar ou atualizar seu aplicativo com diagramas de dependência

As etapas a seguir fornecem uma visão geral de como usar diagramas de dependência no processo de desenvolvimento. As seções subsequentes neste tópico descrevem mais detalhes sobre cada etapa. Se você estiver desenvolvendo um novo design, omita as etapas que se referem ao código existente.

Observação

Essas etapas aparecem em ordem aproximada. Provavelmente, convém sobrepor as tarefas, reordená-las para se adequar à sua própria situação e revisitá-las no início de cada iteração no seu projeto.

  1. Crie um diagrama de dependência para todo o aplicativo ou para uma camada dentro dele.

  2. Defina camadas para representar as principais áreas funcionais ou componentes do seu aplicativo. Nomeie essas camadas de acordo com sua função, por exemplo, "Apresentação" ou "Serviços". Se você tiver uma solução do Visual Studio, poderá associar cada camada a uma coleção de artefatos, como projetos, namespaces, arquivos e assim por diante.

  3. Descubra as dependências existentes entre camadas.

  4. Edite as camadas e dependências para mostrar o design atualizado que você deseja que o código reflita.

  5. Projete novas áreas do aplicativo criando camadas para representar os principais blocos ou componentes de arquitetura e definindo dependências para mostrar como cada camada usa as outras.

  6. Edite o layout e a aparência do diagrama para ajudar você a discuti-lo com colegas.

  7. Valide o código no diagrama de dependência para realçar os conflitos entre o código e a arquitetura necessária.

  8. Atualize o código para estar em conformidade com sua nova arquitetura. Desenvolva e refatore o código iterativamente até que a validação não mostre conflitos.

  9. Inclua a validação de camada no processo de build para garantir que o código continue a seguindo o design.

Criar um diagrama de dependência

Um diagrama de dependência deve ser criado dentro de um projeto de modelagem. Você pode adicionar um novo diagrama de dependência a um projeto de modelagem existente, criar um novo projeto de modelagem para o diagrama de dependência ou copiar um diagrama de dependência existente dentro do mesmo projeto de modelagem.

Importante

Não adicione, arraste ou copie um diagrama de dependência existente de um projeto de modelagem para outro projeto de modelagem ou para outro local na solução. Um diagrama de dependência copiado dessa forma terá as mesmas referências que o diagrama original, mesmo se você modificar o diagrama. Isso impede que a validação da camada funcione corretamente e talvez cause outros problemas como, por exemplo, elementos não encontrados ou outros erros ao tentar abrir o diagrama.

Confira Criar diagramas de dependências com base no código.

Definir camadas para representar áreas funcionais ou componentes

As camadas representam grupos lógicos de artefatos, como projetos, arquivos de código, namespaces, classes e métodos. Você pode criar camadas a partir de artefatos de projetos do Visual C# e do Visual Basic ou anexar especificações ou planos a uma camada vinculando documentos, como arquivos do Word ou apresentações do PowerPoint. Cada camada aparece como um retângulo no diagrama e mostra o número de artefatos que estão vinculados a ele. Uma camada pode conter camadas aninhadas que descrevem tarefas mais específicas.

Como regra geral, nomeie essas camadas de acordo com sua função, por exemplo, "Apresentação" ou "Serviços". Se os artefatos forem intimamente interdependentes, coloque-os na mesma camada. Se os artefatos puderem ser atualizados separadamente ou usados em aplicativos separados, coloque-os em diferentes camadas.

Dica

Há determinados tipos de artefatos que você pode vincular a camadas, mas que não dão suporte à validação no diagrama de dependência. Para ver se o artefato dá suporte à validação, abra o Gerenciador de Camadas para examinar a propriedade Dá Suporte à Validação do link do artefato. Confira Descobrir dependências existentes entre camadas.

Ao atualizar um aplicativo desconhecido, você também pode criar mapas de código. Esses diagramas podem ajudar você a descobrir padrões e dependências, enquanto explora o código. Use o Gerenciador de Soluções para explorar namespaces e classes, que normalmente correspondem bem a camadas existentes. Atribua esses artefatos de código a camadas arrastando-os do Gerenciador de Soluções para os diagramas de dependência. Em seguida, você pode usar os diagramas de dependência para ajudar a atualizar o código e mantê-lo consistente com seu design.

Consulte:

Descobrir dependências existentes entre camadas

Existirá uma dependência sempre que um artefato associado a uma camada tiver uma referência a um artefato associado a outra camada. Por exemplo, uma classe em uma camada declara uma variável que tem uma classe em outra camada. Você pode descobrir as dependências existentes por meio da engenharia reversa.

Observação

As dependências não podem sofrer engenharia reversa para determinados tipos de artefatos. Por exemplo, nenhuma dependência sofrerá engenharia reversa de ou para uma camada vinculada a um arquivo de texto. Para saber quais artefatos têm dependências em que você pode usar a engenharia reversa, clique com o botão direito do mouse em uma ou várias camadas e, em seguida, clique em Exibir Links. No Gerenciador de Camadas, examine a coluna Dá Suporte à Validação. As dependências não sofrerão engenharia reversa para artefatos para os quais essa coluna mostra False.

Para fazer a engenharia reversa das dependências existentes entre camadas

Selecione uma ou várias camadas, clique com o botão direito do mouse em uma camada selecionada e clique em Gerar Dependências.

Normalmente, você verá algumas dependências que não devem existir. É possível editar essas dependências para alinhá-las com o design desejado.

Editar camadas e dependências para mostrar o design desejado

Para descrever as alterações que você pretende fazer no sistema ou na arquitetura desejada, use as etapas a seguir para editar o diagrama de dependência. Você também pode fazer algumas alterações de refatoração para melhorar a estrutura do código antes de estendê-lo. Confira Como aprimorar a estrutura do código.

Para Realizar estas etapas
Excluir uma dependência que não deve existir Clique na dependência e pressione DELETE.
Alterar ou restringir a direção de uma dependência Defina sua propriedade Direção.
Criar novas dependências Use as ferramentas Dependência e Dependência Bidirecional.

Para desenhar várias dependências, clique duas vezes na ferramenta. Quando você terminar, clique na ferramenta Ponteiro ou pressione a tecla ESC.
Especificar que os artefatos associados a uma camada não dependem dos namespaces especificados Digite os namespaces na propriedade Dependências de Namespace Proibidas da camada. Use um ponto-e-vírgula (;) para separar os namespaces.
Especificar que os artefatos associados a uma camada não devem pertencer aos namespaces especificados Digite os namespaces na propriedade Namespaces Proibidos da camada. Use um ponto-e-vírgula (;) para separar os namespaces.
Especificar que os artefatos associados a uma camada devem pertencer a um dos namespaces especificados Digite o namespace na propriedade Namespaces Obrigatórios da camada. Use um ponto-e-vírgula (;) para separar os namespaces.

Como aprimorar a estrutura do código

As alterações de refatoração são aprimoramentos que não afetam o comportamento do aplicativo, mas ajudam a facilitar a alteração e a extensão do código no futuro. O código bem estruturado tem um design fácil de abstrair para um diagrama de dependência.

Por exemplo, se você criar uma camada para cada namespace no código e, em seguida, fazer a engenharia reversa das dependências, deve haver um conjunto mínimo de dependências unidirecionais entre as camadas. Se você criar um diagrama mais detalhado usando classes ou métodos como suas camadas, o resultado também deverá ter as mesmas características.

Se esse não for o caso, o código será mais difícil de alterar ao longo de sua vida útil e será menos adequado para validação usando diagramas de dependência.

Criar novas áreas do seu aplicativo

Quando você começa o desenvolvimento de um novo projeto ou de uma nova área em um novo projeto, pode desenhar camadas e dependências para ajudar a identificar os principais componentes, antes de começar a desenvolver o código.

  • Mostrar padrões de arquitetura identificáveis nos seus diagramas de dependência, se possível. Por exemplo, um diagrama de dependência que descreve um aplicativo da área de trabalho pode incluir camadas como Apresentação, Lógica de Domínio e Armazenamento de Dados. Um diagrama de dependência que abrange um único recurso dentro de um aplicativo pode ter camadas como Modelo, Exibição e Controlador.

  • Crie um artefato de código para cada camada, como um namespace, uma classe ou um componente. Isso facilita o acompanhamento do código e a vinculação dos artefatos de código às camadas. Assim que você criar cada artefato, vincule-o à camada apropriada.

  • Você não precisa vincular a maioria das classes e outros artefatos às camadas porque elas se enquadram em artefatos maiores, como os namespaces que você já vinculou às camadas.

  • Crie um novo diagrama para um novo recurso. Normalmente, haverá um ou mais diagramas de dependência que descrevem todo o aplicativo. Se você estiver criando um novo recurso dentro do aplicativo, não adicione nem altere os diagramas existentes. Em vez disso, crie seu próprio diagrama que reflita as novas partes do código. As camadas no novo diagrama podem incluir apresentação, lógica de domínio e camadas de banco de dados para o novo recurso.

    Quando você compilar o aplicativo, seu código será validado no diagrama geral e no diagrama de recursos mais detalhado.

Editar o layout para apresentação e discussão

Para ajudar você a identificar camadas e dependências ou discuti-las com os membros da equipe, edite a aparência e o layout do diagrama da seguinte maneira:

  • Altere os tamanhos, as formas e as posições das camadas.

  • Altere as cores de camadas e dependências.

    • Selecione uma ou mais camadas ou dependências, clique com o botão direito do mouse e clique em Propriedades. Na janela Propriedades, edite a propriedade Color.

Validar o código em relação ao diagrama

Ao editar o diagrama, você pode validá-lo no código manualmente a qualquer momento ou automaticamente sempre que você compilar.

Consulte:

Atualizar o código para estar em conformidade com a nova arquitetura

Normalmente, os erros aparecerão na primeira vez que você validar o código em um diagrama de dependência atualizado. Esses erros podem ter várias causas:

  • Um artefato é atribuído à camada errada. Nesse caso, mova o artefato.

  • Um artefato como, por exemplo, uma classe usa outra classe de maneira a entrar em conflito com a arquitetura. Nesse caso, refatore o código para remover a dependência.

Para resolver esses erros, atualize o código até que mais nenhum erro seja exibido durante a validação. Geralmente, esse é um processo iterativo. Para obter mais informações sobre esses erros, confira Validar código com diagramas de dependência.

Observação

Ao desenvolver ou refatorar o código, talvez você tenha novos artefatos para vincular ao diagrama de dependência. No entanto, isso pode não ser necessário, por exemplo, quando você tem camadas que representam namespaces existentes e o novo código só adiciona mais material a esses namespaces.

Durante o processo de desenvolvimento, você talvez queira suprimir alguns dos conflitos reportados durante a validação. Por exemplo, você talvez queira suprimir erros que já esteja resolvendo ou que não sejam relevantes para seu cenário específico. Quando você suprime um erro, é uma prática recomendada registrar em log um item de trabalho no Team Foundation. Para executar essa tarefa, confira Validar código com diagramas de dependência.

Incluir validação de camada no processo de build

Para garantir que as alterações futuras no código estejam em conformidade com os diagramas de dependência, inclua a validação de camada para o processo de build padrão da solução. Sempre que outros membros da equipe criarem a solução, as diferenças entre as dependências no código e o diagrama de dependência serão relatadas como erros de build. Para obter mais informações sobre como incluir a validação de camada no processo de build, confira Validar código com diagramas de dependência.

Conteúdo relacionado