Olá a todos! É um grande prazer estar aqui novamente escrevendo um novo artigo para todos os leitores do .NET Coders.
Sem mais delongas, vamos ao que realmente interessa. Neste artigo vou explicar como garantir um código mais homogêneo em projetos .NET através da ferramenta gratuita StyleCop.
Introdução
Quem nunca participou de um projeto que envolvia dois ou mais desenvolvedores que atire a primeira pedra! E nós sabemos bem que cada pessoa desenvolve software de uma forma diferente da outra. Se passarmos uma tarefa para três pessoas diferentes desenvolverem, teremos três códigos diferentes no fim das contas.
É inviável querer demandar que pessoas diferentes desenvolvam o mesmo algoritmo para um determinado problema, mas então, como garantir um código mais homogêneo em todo o projeto? A intenção deste artigo não é obrigar as equipes a desenvolverem o mesmo algoritmo para todos os problemas.
Então qual é o objetivo deste artigo?
O objetivo deste artigo é apresentar uma ferramenta que é capaz de monitorar e avaliar COMO o código é escrito ao longo do projeto. Identação, nomes utilizados em declarações de variáveis, espaços em branco desnecessários, parênteses desnecessários, e muitas outras validações são exemplos do que o StyleCop é capaz de garantir para nós.
StyleCop não é FxCop!
Muitos podem ficar confusos em relação a diferença destas duas ferramentas. Só para deixar claro, o FXCop trabalha em cima da IL, ou seja, em cima de código compilado.
Já o StyleCop trabalha em cima dos arquivos fontes do projeto, e é por isto que ele tem, por exemplo, a capacidade de validar a identação do que foi escrito.
Obtendo o StyleCop
O StyleCop, como dito anteriormente, é uma ferramenta gratuita, e pode ser obtida através do link abaixo:
Para instalar é simples, basta fazer download do arquivo .MSI e instalar no computador. Ele já vai integrar com o Visual Studio automaticamente. Vale ressaltar que todos envolvidos no projeto terão que instalar o StyleCop em suas estações de desenvolvimento.
Atenção: Se for efetuar a instalação no modo Customizado, não desative o pacote “MSBuild files”, porque vamos precisas dele no mais tardar do nosso artigo. Por padrão o instalador já instala estes arquivos no PC.
Integrando o StyleCop a um projeto
Agora que já instalamos o StyleCop, o próximo passo é integrar o mesmo a um ou mais projetos de nossa Solution. Com viés acadêmico, eu vou criar um projeto do tipo Class Library a fim de ilustrar o artigo, mas você pode integrar ele a outros tipos de projeto também, uma vez que os passos para configuração são os mesmos.
Criação do Projeto
Seguindo o caminho abaixo, vamos à criação do Projeto:
File > New > Project > Visual C# > Windows Desktop > Class Library
[caption id=”attachment_2160" align=”alignnone” width=”300"]
Criação do Projeto[/caption]
Dê o nome de “StyleCopTutorial” ao projeto, e clique em OK.
Não apague a classe “Class1”. Vamos precisar dela para exemplificar este artigo.
Configurando o StyleCop
Com o projeto criado, agora vamos configurar o StyleCop e suas respectivas regras. Clique com o botão direito em cima do nome do projeto “StyleCopTutorial” na solution, e selecione a opção “StyleCop Settings”. A seguinte janela irá se abrir:
[caption id=”attachment_2157" align=”alignnone” width=”300"]
Configurando o StyleCop[/caption]
Nesta janela podemos configurar as regras que serão utilizadas no projeto. O StyleCop já oferece diversas regras padrões baseadas em convenções. De cara podemos ver as categorias cobertas pela ferramenta:
- Regras de Documentação
- Regras de Layout
- Regras de Manutenção
- Regras de Nomeação
- Regras de Ordenação
- Regras de Legibilidade
- Regras de Espaçamento
Você pode ativar ou desativar estas regras conforme a necessidade do projeto ou da equipe. Eu vou deixar a configuração padrão para o artigo (com algumas exceções), mas em projetos eu costumo desativar algumas outras regras. Esta configuração vai da forma de trabalho de cada equipe, e normalmente quem vai configurar isto é o Arquiteto ou quem estiver a frente do projeto.
Desative a regra SA1633, que está dentro do caminho “Documentation Rules > File Headers”. Se não desativarmos esta regra, no mais tardar do artigo teremos problema ao compilar o projeto com o StyleCop associado ao MSBuild.
Desative também as seguintes regras (Você pode usar a opção Find da janela):
- SA1200
- SA1650
A medida que você começar a utilizar o StyleCop em seus projetos, você vai começar a entender melhor quais regras se aplicam ou não para seu cenário. Eu aconselho já desativar as 3 regras que falei acima, até porque, se não fizermos isto, nós não teremos exito ao chegar no final do artigo.
Você também pode criar suas próprias regras, mas eu normalmente trabalho com estas que já são disponibilizadas pela ferramenta. Para os interessados em criar suas próprias regras, vocês podem conferir o seguinte tutorial:
Para finalizar a configuração, clique em OK na janela. Agora se abrirmos o diretório do projeto no Windows Explorer, é possível visualizar um novo arquivo dentro da pasta, que é o arquivo “Settings.StyleCop”. Este arquivo contém as regras que foram habilitadas para o projeto através daquela interface que acabamos de ver. Se você quiser usar as mesmas regras em outro projeto, você pode copiar estes arquivos para seus respectivos diretórios. Em projetos muito grandes, pode haver a necessidade de configurar um arquivo pai para todos os projetos. Neste link da documentação oficial do StyleCop é possível ver como fazer isto:
Integrando ao MSBuild e gerando erros de compilação
Com os passos que executamos anteriormente, já é possível validar o projeto clicando com o botão direito em cima dele e selecionando a opção “Run StyleCop”. Se você deixou o arquivo “Class1.cs” que foi criado junto com o projeto, você vai receber 1 Warning, conforme a imagem abaixo:
[caption id=”attachment_2158" align=”alignnone” width=”300"]
StyleCop Warning[/caption]
A princípio isto já parece ser o suficiente, mas não, não é. No início do projeto todos vão respeitar a nova ferramenta, vão validar, vão se sentir bem com isto, mas quando os prazos APERTAREM, todo mundo vai ignorar as regras e escrever do seu próprio jeito, e era uma vez nosso código homogêneo.
Felizmente, o StyleCop permite que integremos suas validações junto ao Build do projeto. Desta forma, podemos garantir que o projeto só vai compilar com sucesso se tudo estiver conforme as regras configuradas. Caso contrário, erros serão lançados ao tentar compilar o projeto.
Para fazer isto, será necessário alterar o arquivo “.csproj” do projeto. Lembrando que, se houver mais de um projeto na Solution, esta tarefa deverá ser feita para cada projeto, ou seja, para cada arquivo “.csproj” da solution.
Vá até a pasta do projeto criado, e abra o arquivo “StyleCopTutorial.csproj” com seu editor de texto preferido. Eu utilizo o Notepad++. Será necessário acrescentar as seguintes linhas no arquivo:
Adicione o código a seguir logo abaixo da linha => “<Import Project=”$(MSBuildToolsPath)\Microsoft.CSharp.targets” />”.
[code language=”xml”]
<Import Project=”$(ProgramFiles)\MSBuild\StyleCop\v4.7\StyleCop.targets” />
[/code]
E o próximo dentro do nó “PropertyGroup” que está sem atributos:
[code language=”xml”]
<StyleCopTreatErrorsAsWarnings>false</StyleCopTreatErrorsAsWarnings>
[/code]
No fim das contas, o arquivo vai ficar assim:
[code language=”xml”]
<?xml version=”1.0" encoding=”utf-8"?>
<Project ToolsVersion=”12.0" DefaultTargets=”Build” xmlns=”http://schemas.microsoft.com/developer/msbuild/2003">
<Import Project=”$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props” Condition=”Exists(‘$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props’)” />
<PropertyGroup>
<Configuration Condition=” ‘$(Configuration)’ == ‘’ “>Debug</Configuration>
<Platform Condition=” ‘$(Platform)’ == ‘’ “>AnyCPU</Platform>
<ProjectGuid>{C917539A-FA39–4356–9B06–65480183AE0F}</ProjectGuid>
<OutputType>Library</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>StyleCopTutorial</RootNamespace>
<AssemblyName>StyleCopTutorial</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
<StyleCopTreatErrorsAsWarnings>false</StyleCopTreatErrorsAsWarnings>
</PropertyGroup>
<PropertyGroup Condition=” ‘$(Configuration)|$(Platform)’ == ‘Debug|AnyCPU’ “>
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=” ‘$(Configuration)|$(Platform)’ == ‘Release|AnyCPU’ “>
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>bin\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<ItemGroup>
<Reference Include=”System” />
<Reference Include=”System.Core” />
<Reference Include=”System.Xml.Linq” />
<Reference Include=”System.Data.DataSetExtensions” />
<Reference Include=”Microsoft.CSharp” />
<Reference Include=”System.Data” />
<Reference Include=”System.Xml” />
</ItemGroup>
<ItemGroup>
<Compile Include=”Class1.cs” />
<Compile Include=”Properties\AssemblyInfo.cs” />
</ItemGroup>
<Import Project=”$(MSBuildToolsPath)\Microsoft.CSharp.targets” />
<Import Project=”$(ProgramFiles)\MSBuild\StyleCop\v4.7\StyleCop.targets” />
<! — To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name=”BeforeBuild”>
</Target>
<Target Name=”AfterBuild”>
</Target>
→
</Project>
[/code]
Salve o arquivo. Depois de salvar o arquivo “.csproj”, experimente recompilar o projeto. O Build não terá sucesso, e aquele Warning que tivemos anteriormente agora se tornou um erro de compilação. Veja:
[caption id=”attachment_2159" align=”alignnone” width=”300"]
Build Error[/caption]
Para corrigirmos este erro, agora temos que alterar nossa classe “Class1” para atender as regras do StyleCop. Para isto, altere o código da classe “Class1” para o código a seguir.
[code language=”csharp”]
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StyleCopTutorial
{
/// <summary>
/// Classe de teste.
/// </summary>
public class Class1
{
}
}
[/code]
Agora experimente recompilar o projeto, e veja que após comentar a classe “Class1”, o projeto irá compilar com sucesso.
Conclusão
Espero que com este artigo você já consiga integrar e usufruir do StyleCop em seus projetos pessoais e profissionais. No começo pode parecer chato e estressante, mas ao chegar no fim do projeto eu garanto que você verá que valeu a pena!
A ferramenta possui outros recursos que eu não comentei no artigo, e quem tiver interesse em conhece-los mais a fundo, basta acessar a documentação oficial, que está disponível no seguinte link:
Um grande abraço a todos e até a próxima!
