O aumento da complexidade de aplicativos de software moderno também aumenta a dificuldade de fazer com que código seja confiável e também seja fácil de manter. As métricas de código são um conjunto de medidas de software que fornecem aos desenvolvedores uma visão melhor do código que estão desenvolvendo.

Podemos usar o Visual Studio para gerar dados de métricas de código que medem a complexidade e facilidade de manutenção de seu código gerenciado. Os dados de métricas de código podem ser gerados para uma solução inteira ou um único projeto.

Dessa forma , as métricas de código ou Code Metrics permite o desenvolvedor ter uma visão da manutenibilidade e complexidade do código.

O Visual Studio usa cinco métricas de código para ajudar você a entender melhor seu código :

1. Linha de Código
2. Acoplamento de classe
3. Profundidade da herança
4. Complexidade ciclomática
5. Índice de Manutenção

Que são definidas da seguinte forma segundo a documentação:

Linhas de código-fonte :  Indica o número exato de linhas de código-fonte que estão presentes no arquivo de origem, incluindo linhas em branco. Essa métrica está disponível a partir do Visual Studio 2019 versão 16,4 e Microsoft. CodeAnalysis. métricas (2.9.5).

Acoplamento de Classe :  Mede o acoplamento de classes por meio de parâmetros, variáveis locais, tipos de retorno, chamadas de método, instanciações genéricas ou modelo, classes base, implementações de interface, campos definidos nos tipos externos, e decoração de atributos. Um bom projeto de software determina que tipos e métodos devem ter alta coesão e baixo acoplamento. Um alto acoplamento indica um projeto que é difícil de ser reutilizado e de manter devido à suas muitas interdependências em outros tipos.

Profundidade de herança : Indica o número de classes diferentes que herdam uma da outra, de volta para a classe base. A profundidade da herança é semelhante ao acoplamento de classes, pois uma alteração em uma classe base pode afetar qualquer uma de suas classes herdadas. Quanto maior esse número, mais profunda a herança e maior o potencial para modificações na classe base resultam em uma alteração significativa. Para a Profundidade da herança, um valor baixo é bom e um valor alto é ruim.

A complexidade ciclomática : Mede a complexidade do código estrutural. Ela é criada pelo cálculo do número de diferentes caminhos de código no fluxo do programa. Um programa que tem um fluxo de controle complexo requer mais testes para obter uma boa cobertura de código e é menos passível de manutenção.

Índice de facilidade de manutenção : Calcula um valor de índice entre 0 e 100 que representa a relativa facilidade de manutenção do código. Um valor alto significa melhor facilidade de manutenção. Podemos usar classificações codificadas por cor para identificar rapidamente pontos problemáticos no código:

• Uma classificação verde está entre 20 e 100 e indica que o código tem boa facilidade de manutenção;
• Uma classificação amarela esta entre 10 e 19 e indica que o código é razoavelmente fácil de manter;
• Uma classificação vermelha esta em uma classificação entre 0 e 9 e indica pouca facilidade de manutenção;

Agora veremos na prática como usar este recurso no Visual Studio 2019.

recursos usados:

• Visual Basic 2019 Community Edition

Criando o projeto C# no VS 2019

Vamos criar um projeto Console do tipo .NET Core com o seguinte nome para a Solution: CShp_CodeMetrics:

No projeto criado vamos abrir o arquivo Program e definir neste arquivo o código com duas classes:

• ClasseBase
• ClasseDerivada

O código foi definido no mesmo arquivo para facilitar a visualização e é muito simples. Neste código temos que a classe ClasseDerivada herda da classe ClasseBase.

Vamos calcula as métricas deste código usando o Visual Studio 2019. Para isso basta clicar com o botão direito do mouse sobre o nome do projeto e selecionar a opção Analyze and Code Cleanup -> Calculate Code Metrics:

O Visual Studio calculará as métricas de código desse aplicativo e você deverá encontrará a tela a seguir.

Os valores obtidos para o nosso código foram:

1. Linha de Código =  21
2. Acoplamento de classe = 2
3. Profundidade da herança = 2
4. Complexidade ciclomática = 3
5. Índice de Manutenção = 100

Como o nosso código é bem simples e para não complicar muito o nosso exemplo vamos analisar apenas a Profundidade da herança e o Acoplamento de Classe.

Pelos valores obtidos estamos vendo que a profundidade da herança é igual a 2 e o valor do Acoplamento de classe é igual a 2.

A profundidade da herança é 2 porque existem 2 hierarquias de classe de nível na classe ClasseDerivada, e, o valor do Acoplamento de classe é 2 porque a classe ClasseBase esta associada à classe ClasseDerivada, assim uma classe depende de ClasseDerivada, e, a classe Programa usa o método Main() que esta invocando a classe Console.

Vamos agora alterar o código do projeto e recalcular as métricas de código.  Vamos fazer o seguinte:

• Criar uma interface ITeste
• Criar uma classe DemoClasse que herda de ClasseBase
• A nossa classe ClasseDerivada vai herdar de DemoClasse e vai implementar a interface ITeste

Veja como ficou o código:

Realizando novamente a medida das métricas usando o Visual Studio iremos obter os seguintes valares :

Os resultados são:

1. Linha de Código =  19
2. Acoplamento de classe = 4
3. Profundidade da herança = 3
4. Complexidade ciclomática = 5
5. Índice de Manutenção = 100

O valor da profundidade da herança é igual a 3 pois :

1. DemoClasse herda de ClasseBase
2. ClasseDerivada herda de DemoClasse
3. ClasseDerivada implementa a interface ITeste

O valor do Acoplamento de classe é igual a 4 pois temos que:

1. DemoClasse herda de ClasseBase
2. ClasseDerivada herda de DemoClasse
3. ClasseDerivada implementa a interface ITeste
4. A classe Program usa o método Main que usa a classe Console

Embora o projeto usado tenha um nível de complexidade muito baixo oque impede entrar em muitos detalhes, creio que você entendeu o objetivo de realizar as métricas de código no seu projeto.