C#: evitando a Injeção de SQL

A Injeção de SQL, ou em inglês SQL Injection, é uma vulnerabilidade que permite que algum usuário malicioso possa executar uma instrução em SQL dentro da aplicação, aproveitando uma brecha em uma consulta que permita acesso ao banco de dados.

Para demonstrar um exemplo desta vulnerabilidade, vamos criar um banco de dados de vendas, onde temos nossa tabela de usuários com alguns informações.

USE [master];
GO

CREATE DATABASE [VendasDb];
GO

USE [VendasDb];
GO

CREATE TABLE [dbo].[Usuario]
	(
		[Id] INT IDENTITY(1,1) NOT NULL PRIMARY KEY, 
		[Usuario] VARCHAR(50) NOT NULL, 
		[Senha] VARCHAR(50) NOT NULL
	);
GO

INSERT 
	INTO [dbo].[Usuario]([Usuario], [Senha])
	VALUES ('tiagopariz', '123456'), 
		   ('jonatanvies', '789012'), 
		   ('alineloas', '345678');
GO

USE [master];

CREATE DATABASE [VendasDb];

USE [VendasDb];

CREATE TABLE [dbo].[Usuario]

(

[Id] INT IDENTITY(1,1) NOT NULL PRIMARY KEY,

[Usuario] VARCHAR(50) NOT NULL,

[Senha] VARCHAR(50) NOT NULL

);

INSERT

INTO [dbo].[Usuario]([Usuario], [Senha])

VALUES ('tiagopariz', '123456'),

('jonatanvies', '789012'),

('alineloas', '345678');

Abra o Visual Studio Code, e crie uma pasta chamada EvitandoAInjecaoDeSQL, e dentro dela outra chamada src. Em EvitandoAInjecaoDeSQL crie uma solução usando o comando dotnet new sln e logo em seguida abra a pasta src, adicione e logo abra um nova pasta chamada EvitandoAInjecaoDeSQL.Web e adicione um projeto do tipo MVC usando o comando dotnet new mvc, volte até a pasta EvitandoAInjecaoDeSQL e adicone o projeto na solução usando o comando dotnet sln add .\src\EvitandoAInjecaoDeSQL.Web\EvitandoAInjecaoDeSQL.Web.csproj.

Adicione um controller na pasta Controllers do projeto de MVC chamado ContaController.cs e uma view chamada Login.cshtml na pasta Views/Conta.

using System;
using Microsoft.AspNetCore.Mvc;
using System.Data.SqlClient;

namespace EvitandoAInjecaoDeSQL.Web.Controllers
{
    public class ContaController : Controller
    {
        [HttpGet]
        public ActionResult Login()
        {
            return View();
        }

        [HttpPost]
        public ActionResult Login(string usuario, string senha)
        {
            var connectionString = @"Data Source=(localdb)\MSSQLLocalDB;Initial Catalog=VendasDb;Integrated Security=True;Connect Timeout=30;Encrypt=False;TrustServerCertificate=True;ApplicationIntent=ReadWrite;MultiSubnetFailover=False";
            var consulta = "SELECT COUNT(*) FROM Usuario WHERE Usuario = '" + usuario + "' AND Senha = '" + senha + "'";

            try
            {
                using (var conexao = new SqlConnection(connectionString))
                {
                    conexao.Open();

                    using (SqlCommand comando = new SqlCommand(consulta, conexao))
                    {
                        var resultado = (int)comando.ExecuteScalar();
                        if (resultado > 0)
                            ViewBag.Mensagem = "Login efetuado com sucesso";
                        else
                            ViewBag.Mensagem = "Falha no login";
                    }
                }
            }
            catch (Exception e)
            {
                ViewBag.Mensagem = "Erro: " + e.Message;
            }

            return View();
        }
    }
}

using System;

using Microsoft.AspNetCore.Mvc;

using System.Data.SqlClient;

namespace EvitandoAInjecaoDeSQL.Web.Controllers

{

public class ContaController : Controller

{

[HttpGet]

public ActionResult Login()

{

return View();

}

[HttpPost]

public ActionResult Login(string usuario, string senha)

{

var connectionString = @"Data Source=(localdb)\MSSQLLocalDB;Initial Catalog=VendasDb;Integrated Security=True;Connect Timeout=30;Encrypt=False;TrustServerCertificate=True;ApplicationIntent=ReadWrite;MultiSubnetFailover=False";

var consulta = "SELECT COUNT(*) FROM Usuario WHERE Usuario = '" + usuario + "' AND Senha = '" + senha + "'";

try

{

using (var conexao = new SqlConnection(connectionString))

{

conexao.Open();

using (SqlCommand comando = new SqlCommand(consulta, conexao))

{

var resultado = (int)comando.ExecuteScalar();

if (resultado > 0)

ViewBag.Mensagem = "Login efetuado com sucesso";

else

ViewBag.Mensagem = "Falha no login";

}

catch (Exception e)

{

ViewBag.Mensagem = "Erro: " + e.Message;

}

return View();

}

<h2>Login</h2>

@using (Html.BeginForm("Login", "conta", FormMethod.Post, new { enctype = "multipart/form-data" }))
{
    <label>Usuario: </label>
    <input type="text" id="usuario" name="usuario" /><br />

    <label>Senha: </label>
    <input type="text" id="senha" name="senha" /><br />

    <input type="submit" value="Login" /><br />

    <label>@ViewBag.Mensagem</label>
}

<h2>Login</h2>

@using (Html.BeginForm("Login", "conta", FormMethod.Post, new { enctype = "multipart/form-data" }))

{

<label>Usuario: </label>

<label>Senha: </label>

<label>@ViewBag.Mensagem</label>

}

A tela de login deve ser semelhante a esta, após abrir o site e digitar uma senha válida:

O nosso site está funcionando, então agora vamos aplicar o SQL Injection para verificar a vulnerabilidade. Como vimos, o campo usuário e senha só efetua login se for digitado um nome de usuário e uma senha correta. Mas vamos tentar burlar isto.

Para entdenr o que acontece no lado do banco de dados ao digitar o usuário e senha da captura de tela, vamos analisar a intrução SQL montada pelo aplicativo:

SELECT COUNT(*)
    FROM Usuario 
    WHERE Usuario = 'tiagopariz' AND Senha = '123456'

SELECT COUNT(*)

FROM Usuario

WHERE Usuario = 'tiagopariz' AND Senha = '123456'

Se executarmos a instrução acima no SQL Server, temos o resultado 1, que é a informação que permite que o sistema permita o acesso.

Mas esta instrução é facilmente alterada usando alguns caracteres de ‘ (apóstrofo), fazendo a consulta ficar assim:

SELECT COUNT(*)
    FROM Usuario 
    WHERE Usuario = 'tiagopariz' AND Senha = '' OR '1' = '1'

SELECT COUNT(*)

FROM Usuario

WHERE Usuario = 'tiagopariz' AND Senha = '' OR '1' = '1'

Que retorna um valor positivo, mesmo sem informar a senha.

Mas como isto é possível sem editar o SQL que está no código? Simples, pois a forma a instrução foi montada, permite que seja alterada, pois o SELECT é uma concatenação dos campos que são enviados no post e a o corpo da instrução, o C# não sabe o que é filtro e o que é comando de banco, ele monta primeiro uma string e depois executa no banco. Sendo assim, vamos recriar esta consulta direto no campo de senha.

Antes, tente digitar uma senha errada, para conferir se formulário está funcionando e acessando os dados corretamente.

Agora vamos explorar a vulnerabilidades, digitando no campo de senha ‘ OR ‘1’ = ‘1 e clique em login.

E acabamos de ser invadidos por uma falha bem simples no site, pois é possivel “editar” a instrução SQL antes de enviar. Este tipo de falha, pode ser tão grave que é até pode permitir acessar e alterar informações do próprio sistema operacional, dependendo da configuração do banco de dados.

Mas como consertamos este caso específico? A solução a seguir vai resolver este tipo de abertura, mas há outros tipos de falahas que podem precisar uma solução mais avançada. O que vamos fazer é passar parâmetros para o banco de dados em vez de montar todo o sql de uma vez, para isso, em vez de usar uma concatenação, mas nomer estes dados usando um @ (arroba antes) antes, então, para isto, vou comentar o código vulnerável do arquivo ContaController.cs e adicionar a forma mais segura, como segue:

using System;
using Microsoft.AspNetCore.Mvc;
using System.Data.SqlClient;

namespace EvitandoAInjecaoDeSQL.Web.Controllers
{
    public class ContaController : Controller
    {
        [HttpGet]
        public ActionResult Login()
        {
            return View();
        }

        [HttpPost]
        public ActionResult Login(string usuario, string senha)
        {
            var connectionString = @"Data Source=(localdb)\MSSQLLocalDB;Initial Catalog=VendasDb;Integrated Security=True;Connect Timeout=30;Encrypt=False;TrustServerCertificate=True;ApplicationIntent=ReadWrite;MultiSubnetFailover=False";
            
            // Código com a vunerabilidade devido a concatenação
            //var consulta = "SELECT COUNT(*) FROM Usuario WHERE Usuario = '" + usuario + "' AND Senha = '" + senha + "'";

            // Forma mais segura, montando o SELECT que espera os parâmetros @usuario e @senha
            var consulta = "SELECT COUNT(*) " +
                                "FROM Usuario " +
                                "WHERE " +
                                    "Usuario = @usuario AND " +
                                    "Senha = @senha;";

            try
            {
                using (var conexao = new SqlConnection(connectionString))
                {
                    conexao.Open();

                    using (SqlCommand comando = new SqlCommand(consulta, conexao))
                    {
                        // Passando os parâmetros de SQL sem a necessidade de concatenar
                        comando.Parameters.Add(new SqlParameter("@usuario", usuario));
                        comando.Parameters.Add(new SqlParameter("@senha", senha));

                        var resultado = (int)comando.ExecuteScalar();
                        if (resultado > 0)
                            ViewBag.Mensagem = "Login efetuado com sucesso";
                        else
                            ViewBag.Mensagem = "Falha no login";
                    }
                }
            }
            catch (Exception e)
            {
                ViewBag.Mensagem = "Erro: " + e.Message;
            }

            return View();
        }
    }
}

using System;

using Microsoft.AspNetCore.Mvc;

using System.Data.SqlClient;

namespace EvitandoAInjecaoDeSQL.Web.Controllers

{

public class ContaController : Controller

{

[HttpGet]

public ActionResult Login()

{

return View();

}

[HttpPost]

public ActionResult Login(string usuario, string senha)

{

// Código com a vunerabilidade devido a concatenação

//var consulta = "SELECT COUNT(*) FROM Usuario WHERE Usuario = '" + usuario + "' AND Senha = '" + senha + "'";

// Forma mais segura, montando o SELECT que espera os parâmetros @usuario e @senha

var consulta = "SELECT COUNT(*) " +

"FROM Usuario " +

"WHERE " +

"Usuario = @usuario AND " +

"Senha = @senha;";

try

{

using (var conexao = new SqlConnection(connectionString))

{

conexao.Open();

using (SqlCommand comando = new SqlCommand(consulta, conexao))

{

// Passando os parâmetros de SQL sem a necessidade de concatenar

comando.Parameters.Add(new SqlParameter("@usuario", usuario));

comando.Parameters.Add(new SqlParameter("@senha", senha));

var resultado = (int)comando.ExecuteScalar();

if (resultado > 0)

ViewBag.Mensagem = "Login efetuado com sucesso";

else

ViewBag.Mensagem = "Falha no login";

}

catch (Exception e)

{

ViewBag.Mensagem = "Erro: " + e.Message;

}

return View();

}

Com isto, temos um código mais seguro. Outra solução, seria usar frameworks ORM, como Entity Framework ou NHibernate.

O projeto completo está disponível no meu GitHub:

https://github.com/tiagopariz/EvitandoAInjecaoDeSQL

Obrigado e um bom dia a todos.

Entity Framework: migrations com vários projetos e bancos de dados

Quando trabalhamos com soluções grandes, onde há vários projetos e cada um tem sua própria base de dados, assim como seu próprio versionamento usando Migrations do Entity Framework, fica meio complicado ficar alterando o Set as startup project e o Default Project na janela do Package Manager Console. Então, o ideal é apontar os projetos de configuração e dados na mesma linha de comando do Add-Migration e Update-Database.

Atualizando o banco de dados

Quando abrimos uma projeto que já tem migrations, precisamos atualizar o banco de dados, e para isso usamos o comando Update-Database. Mas podemos ser mais específico, e não precisar escolher nada em tela para que ele saiba onde achar a Connection String e Contexto, usando o comando abaixo.

Update-Database -ProjectName NomeDoProjetoDeDados -StartUpProjectName NomeDoProjetoInicial -ConfigurationTypeName NomeDoProjeto.Configuration -Verbose

1	Update-Database -ProjectName NomeDoProjetoDeDados -StartUpProjectName NomeDoProjetoInicial -ConfigurationTypeName NomeDoProjeto.Configuration -Verbose

Update-Database

Este comando atualiza o banco de dados com a ultima versão das migrations registradas, assim como roda algum Seed que pode popular tabelas.

-ProjectName

Nome do projeto onde está a configuração das entidades que representam os objetos do banco de dados, ou os DbSets.

-StartUpProjectName

O projeto que contém a Connection String para conexão com o banco de dados.

-ConfigurationTypeName

Nome completo, incluindo as namespaces, da entidade de configuração das migrations. Este arquivo é aquele que é gerado automaticamente ao usar o comando Enable-Migrations para ativar as migrações.

-Verbose

Este parâmetro exibe na tela todas as alterações efetuadas, assim como configurações definidas nos parâmetros anteriores.

Adicionando uma nova migração

Após atualizar o banco de dados, fazer as alterações nos objetos de domínio, precisamos adicionar a migração para depois enviar ao banco de dados as alterações versionadas, e novamente, é preciso que não precisemos definir o projeto de inicialização e dados. Para isso, use o comando a seguir:

Add-Migration -ProjectName NomeDoProjetoDeDados -StartUpProjectName NomeDoProjetoDeInicializacao -ConfigurationTypeName NomeDoProjetoDeDados...Configuration -Name NomeDaMigration

1	Add-Migration -ProjectName NomeDoProjetoDeDados -StartUpProjectName NomeDoProjetoDeInicializacao -ConfigurationTypeName NomeDoProjetoDeDados...Configuration -Name NomeDaMigration

Além dos parâmetros -ProjectName, -StartUpProjectName e -ConfigurationTypeName que já foram explicados no tópico anterior, precisamos incluir o parâmetro -Name e definir um nome que identifique qual alteração será feita no banco de dados.

Após adicionar a migration, só é preciso digitar o comando Update-Database com os parâmetros corretos.

OpenCover: analisando e automatizando a cobertura de código

Cobertura de código é essencial para sabermos o quanto estamos investindo na qualidade do nosso projeto. Para isso, até temos recursos nativos na IDE do Visual Studio, mas apenas na edição Enterprise. Mas nem tudo está perdido para quem não tem acesso à edições “premium” do VS! Podemos substituir tranquilamente pelo OpenCover, que atende a este necessidade com grande eficiência e elegância. E isso veremos no projeto de exemplo que iremos montar com o Visual Studio 2017 e o NUnit.

Observação: o OpenCover atende outras plataformas de testes, inclusive a nativa da Microsoft, irei o Usar o NUnit apenas por escolha própria, fique a vontade para integrar com a ferramente que convir.

Crie a solução dos projetos

Crie uma solução vazia chamada CodeCoverage, e inclua três Solution Folders chamadas Domain, Presentation e Tests. na pasta Tests, inclua mais duas subpastas chamadas Domain e Presentation, que serão os testes específicos de cada camada.

Projeto de domínio

Crie um projeto do tipo Class Library chamado CodeCoverage.Domain dentro da pasta Domain, e dentro do projeto inclua outra pasta chamada Entities. Nesta pasta inclua três classes chamadas State, City e Person, pois estas classes que serão analisadas pelo OpenCover, afim de gerar um relatório com o percentual de cobertura por testes unitários. A seguir o código de cada uma delas:

Classe de estados

using System;

namespace CodeCoverage.Domain.Entities
{
    public class State
    {
        public State(Guid id,
                     string name)
        {
            Id = id;
            Name = name;
        }

        public Guid Id { get; }
        public string Name { get; }

        public override string ToString()
        {
            return Name;
        }
    }
}

using System;

namespace CodeCoverage.Domain.Entities

{

public class State

{

public State(Guid id,

string name)

{

Id = id;

Name = name;

}

public Guid Id { get; }

public string Name { get; }

public override string ToString()

{

return Name;

}

Classe de cidades

using System;

namespace CodeCoverage.Domain.Entities
{
    public class City
    {
        public City(Guid id,
                    string name,
                    Guid stateId,
                    State state)
        {
            Id = id;
            Name = name;
            StateId = stateId;
            State = state;
        }

        public Guid Id { get; }
        public string Name { get; }
        public Guid StateId { get; }

        #region Relationships

        public virtual State State { get; }

        #endregion

        public override string ToString()
        {
            return Name;
        }
    }
}

using System;

namespace CodeCoverage.Domain.Entities

{

public class City

{

public City(Guid id,

string name,

Guid stateId,

State state)

{

Id = id;

Name = name;

StateId = stateId;

State = state;

}

public Guid Id { get; }

public string Name { get; }

public Guid StateId { get; }

#region Relationships

public virtual State State { get; }

#endregion

public override string ToString()

{

return Name;

}

Classe de pessoas

using System;

namespace CodeCoverage.Domain.Entities
{
    public class Person
    {
        public Person(Guid id,
                      string name,
                      Guid? cityId,
                      Guid? stateId,
                      City city,
                      State state)
        {
            Id = id;
            Name = name;
            CityId = cityId;
            StateId = stateId;
            City = city;
            State = state;
        }

        public Guid Id { get; }
        public string Name { get; }
        public Guid? CityId { get; }
        public Guid? StateId { get; set; }

        #region Relationships

        public virtual City City { get; }
        public virtual State State { get; }

        #endregion

        public override string ToString()
        {
            return Name;
        }
    }
}

using System;

namespace CodeCoverage.Domain.Entities

{

public class Person

{

public Person(Guid id,

string name,

Guid? cityId,

Guid? stateId,

City city,

State state)

{

Id = id;

Name = name;

CityId = cityId;

StateId = stateId;

City = city;

State = state;

}

public Guid Id { get; }

public string Name { get; }

public Guid? CityId { get; }

public Guid? StateId { get; set; }

#region Relationships

public virtual City City { get; }

public virtual State State { get; }

#endregion

public override string ToString()

{

return Name;

}

Projeto de Console

O projeto de console, será a nossa camada de apresentação, onde vamos trabalhar com DTOs, que são representações dos dados das nossas classes de domínio. Para isso, na pasta Presentation da solução, adicione um projeto do tipo Console Application chamado CodeCoverage.Prompt, e dentro do projeto inclua um pasta chamada Dto. Onde residirão as 3 classes de dados que serão a StateDto, CityDto e a PersonDto, como segue:

DTO de estado

using System;

namespace CodeCoverage.Prompt.Dto
{
    public class StateDto
    {
        public StateDto(Guid id,
                        string name)
        {
            Id = id;
            Name = name;
        }

        public Guid Id { get; }
        public string Name { get; }

        public override string ToString()
        {
            return Name;
        }
    }
}

using System;

namespace CodeCoverage.Prompt.Dto

{

public class StateDto

{

public StateDto(Guid id,

string name)

{

Id = id;

Name = name;

}

public Guid Id { get; }

public string Name { get; }

public override string ToString()

{

return Name;

}

DTO de cidades

using System;

namespace CodeCoverage.Prompt.Dto
{
    public class CityDto
    {
        public CityDto(Guid id,
                       string name,
                       Guid stateId,
                       StateDto stateDto)
        {
            Id = id;
            Name = name;
            StateId = stateId;
            State = stateDto;
        }

        public Guid Id { get; }
        public string Name { get; }
        public Guid StateId { get; }

        #region Relationships

        public virtual StateDto State { get; }

        #endregion

        public override string ToString()
        {
            return Name;
        }
    }
}

using System;

namespace CodeCoverage.Prompt.Dto

{

public class CityDto

{

public CityDto(Guid id,

string name,

Guid stateId,

StateDto stateDto)

{

Id = id;

Name = name;

StateId = stateId;

State = stateDto;

}

public Guid Id { get; }

public string Name { get; }

public Guid StateId { get; }

#region Relationships

public virtual StateDto State { get; }

#endregion

public override string ToString()

{

return Name;

}

DTO de pessoa

using System;

namespace CodeCoverage.Prompt.Dto
{
    public class PersonDto
    {
        public PersonDto(Guid id,
                         string name,
                         Guid? stateId,
                         Guid? cityId,
                         CityDto cityDto,
                         StateDto stateDto)
        {
            Id = id;
            Name = name;
            StateId = stateId;
            CityId = cityId;
            CityDto = cityDto;
            StateDto = stateDto;
        }

        public Guid Id { get; }
        public string Name { get; }
        public Guid? CityId { get; }
        public Guid? StateId { get; set; }

        #region Relationships

        public virtual CityDto CityDto { get; }
        public virtual StateDto StateDto { get; }

        #endregion

        public override string ToString()
        {
            return Name;
        }
    }
}

using System;

namespace CodeCoverage.Prompt.Dto

{

public class PersonDto

{

public PersonDto(Guid id,

string name,

Guid? stateId,

Guid? cityId,

CityDto cityDto,

StateDto stateDto)

{

Id = id;

Name = name;

StateId = stateId;

CityId = cityId;

CityDto = cityDto;

StateDto = stateDto;

}

public Guid Id { get; }

public string Name { get; }

public Guid? CityId { get; }

public Guid? StateId { get; set; }

#region Relationships

public virtual CityDto CityDto { get; }

public virtual StateDto StateDto { get; }

#endregion

public override string ToString()

{

return Name;

}

Edite a classe Program.cs e crie o método que faz os mapeamento entre o Domínio e DTO e o código que exibe os dados em tela.

using System;
using CodeCoverage.Domain.Entities;
using CodeCoverage.Prompt.Dto;

namespace CodeCoverage.Prompt
{
    internal class Program
    {
        private static StateDto _stateDto;
        private static CityDto _cityDto;
        private static PersonDto _personDto;

        private static void Main()
        {
            var state = new State(Guid.NewGuid(), "RS");
            var city = new City(Guid.NewGuid(), "Porto Alegre", state.Id, state);
            var person = new Person(Guid.NewGuid(), "Tiago", city.Id, state.Id, city, state);
            SetMappings(person, city, state);

            Console.WriteLine($"Name: {_personDto.Name}");
            Console.WriteLine($"City: {_personDto.CityDto.Name}");
            Console.WriteLine($"State: {_personDto.StateDto.Name}");

            Console.ReadKey();
        }

        private static void SetMappings(Person person,
                                        City city,
                                        State state)
        {
            _stateDto = new StateDto(state.Id, state.Name);
            _cityDto = new CityDto(city.Id, city.Name, city.StateId, _stateDto);
            _personDto = new PersonDto(person.Id, person.Name, person.StateId, person.CityId, _cityDto, _stateDto);
        }
    }
}

using System;

using CodeCoverage.Domain.Entities;

using CodeCoverage.Prompt.Dto;

namespace CodeCoverage.Prompt

{

internal class Program

{

private static StateDto _stateDto;

private static CityDto _cityDto;

private static PersonDto _personDto;

private static void Main()

{

var state = new State(Guid.NewGuid(), "RS");

var city = new City(Guid.NewGuid(), "Porto Alegre", state.Id, state);

var person = new Person(Guid.NewGuid(), "Tiago", city.Id, state.Id, city, state);

SetMappings(person, city, state);

Console.WriteLine($"Name: {_personDto.Name}");

Console.WriteLine($"City: {_personDto.CityDto.Name}");

Console.WriteLine($"State: {_personDto.StateDto.Name}");

Console.ReadKey();

}

private static void SetMappings(Person person,

City city,

State state)

{

_stateDto = new StateDto(state.Id, state.Name);

_cityDto = new CityDto(city.Id, city.Name, city.StateId, _stateDto);

_personDto = new PersonDto(person.Id, person.Name, person.StateId, person.CityId, _cityDto, _stateDto);

}

Observação: não é intenção deste artigo explicar como funciona processos de mapeamentos entre entidades de domínio, DTOs e ViewModels. Mas fica a dica para você procurar na internet qual o funcionamento de um AutoMapper, por exemplo.

Testes

Expanda a pasta de solução Tests e dentro da pasta Domain adicione um projeto do tipo Unit Test Project chamado CodeCoverage.Domain.Tests.

Neste projeto, inclua uma pasta chamada Entities, e dentro dela vamos incluir duas classes de testes, mas antes é preciso instalar o pacote NUnit, para isso abra o Package Manager Console selecione o projeto de testes do domínio e digite:

Install-Package NUnit

1	Install-Package NUnit

Adicione uma referência para o projeto de domínio, para que os testes possam acessar as entidades. Então adicione as classes de testes na pasta Entities.

Testes da classe de estado

using System;
using CodeCoverage.Domain.Entities;
using NUnit.Framework;

namespace CodeCoverage.Domain.Tests.Entities
{
    [TestFixture]
    public class StateTests
    {
        [Test]
        public void VerifyName()
        {
            var sut = new State(Guid.NewGuid(), "Test name");
            Assert.AreEqual("Test name", sut.Name);
        }
    }
}

using System;

using CodeCoverage.Domain.Entities;

using NUnit.Framework;

namespace CodeCoverage.Domain.Tests.Entities

{

[TestFixture]

public class StateTests

{

[Test]

public void VerifyName()

{

var sut = new State(Guid.NewGuid(), "Test name");

Assert.AreEqual("Test name", sut.Name);

}

Testes da classe de pessoa

using System;
using CodeCoverage.Domain.Entities;
using NUnit.Framework;

namespace CodeCoverage.Domain.Tests.Entities
{
    [TestFixture]
    public class PersonTests
    {
        [Test]
        public void VerifyName()
        {
            var sut = new Person(Guid.NewGuid(), "Test name", null, null, null, null);
            Assert.AreEqual("Test name", sut.Name);
        }

        [Test]
        public void VerifyId()
        {
            var sut = new Person(Guid.NewGuid(), "Test name", null, null, null, null);
            Assert.AreNotEqual(Guid.Empty, sut.Id);
        }
    }
}

using System;

using CodeCoverage.Domain.Entities;

using NUnit.Framework;

namespace CodeCoverage.Domain.Tests.Entities

{

[TestFixture]

public class PersonTests

{

[Test]

public void VerifyName()

{

var sut = new Person(Guid.NewGuid(), "Test name", null, null, null, null);

Assert.AreEqual("Test name", sut.Name);

}

[Test]

public void VerifyId()

{

var sut = new Person(Guid.NewGuid(), "Test name", null, null, null, null);

Assert.AreNotEqual(Guid.Empty, sut.Id);

}

Adicione um outro projeto do tipo Unit Test Project chamado CodeCoverage.Prompt.Tests e adicione uma referência do projeto CodeCoverage.Prompt e instale o pacote do NUnit também.

Crie uma pasta chamada Dto, e dentro dela inclua uma classe de testes chamada PersonDtoTests para pessoas.

using System;
using CodeCoverage.Prompt.Dto;
using NUnit.Framework;

namespace CodeCoverage.Prompt.Tests.Dto
{
    [TestFixture]
    public class PersonDtoTests
    {
        [Test]
        public void VerifyName()
        {
            var sut = new PersonDto(Guid.NewGuid(), "Test name", null, null, null, null);
            Assert.AreEqual("Test name", sut.Name);
        }
    }
}

using System;

using CodeCoverage.Prompt.Dto;

using NUnit.Framework;

namespace CodeCoverage.Prompt.Tests.Dto

{

[TestFixture]

public class PersonDtoTests

{

[Test]

public void VerifyName()

{

var sut = new PersonDto(Guid.NewGuid(), "Test name", null, null, null, null);

Assert.AreEqual("Test name", sut.Name);

}

Usando o Cake

Abra o Powershell, e se posicione na pasta da solução, e logo após digite o comando para instalar o pacote que compila e executa o script do Cake:

Invoke-WebRequest https://cakebuild.net/download/bootstrapper/windows -OutFile build.ps1

1	Invoke-WebRequest https://cakebuild.net/download/bootstrapper/windows -OutFile build.ps1

Ainda na pasta raiz da solução, crie um novo arquivo chamado build.cake e crie também a pasta docs/testsResults/Reports, que será onde ficará os resultados dos testes.

Dica: você pode adicionar o arquivo build.cake à solução, para que ele faça parte do projeto, mas é muito mais produtivo usar o Visual Studio Code e a extensão do Cake, conforme expliquei neste artigo.

#tool "nuget:?package=OpenCover"
#tool "nuget:?package=NUnit.ConsoleRunner"
#tool "nuget:?package=ReportGenerator"

var target = Argument("target", "Default");

Task("BuildProjects")
    .Does(() =>
    {
        foreach(var project in GetFiles("./src/**/*.csproj"))
        {
            MSBuild(project.GetDirectory().FullPath,
                new MSBuildSettings {
                    Verbosity = Verbosity.Minimal,
                    Configuration = "Debug"
                }
            );
        }
    });

Task("BuildTests")
    .IsDependentOn("BuildProjects")
    .Does(() =>
    {
        foreach(var test in GetFiles("./tests/**/*.csproj"))
        {
            MSBuild(test.GetDirectory().FullPath,
                new MSBuildSettings {
                    Verbosity = Verbosity.Minimal,
                    Configuration = "Debug"
                }
            );
        }
    });

Task("OpenCover")
    .IsDependentOn("BuildTests")
    .Does(() =>
    {
        var openCoverSettings = new OpenCoverSettings()
        {
            Register = "user",
            SkipAutoProps = true,
            ArgumentCustomization = args => args.Append("-coverbytest:*.Tests.dll").Append("-mergebyhash")
        };

        var outputFile = new FilePath("./docs/testsResults/Reports/CodeCoverageReport.xml");

        OpenCover(tool => {
            var testAssemblies = GetFiles("./tests/**/bin/Debug/*.Tests.dll");
            tool.NUnit3(testAssemblies);
            },
            outputFile,
            openCoverSettings
                .WithFilter("+[CodeCoverage*]*")
                .WithFilter("-[CodeCoverage.*.Tests]*")
        );
    });

Task("ReportGenerator")
    .IsDependentOn("OpenCover")
    .Does(() =>{
        var reportGeneratorSettings = new ReportGeneratorSettings()
        {
            HistoryDirectory = new DirectoryPath("./docs/testsResults/Reports/ReportsHistory")
        };

        ReportGenerator("./docs/testsResults/Reports/CodeCoverageReport.xml", 
                        "./docs/testsResults/Reports/ReportGeneratorOutput",
                        reportGeneratorSettings);
    });

Task("Default")
    .IsDependentOn("ReportGenerator")
    .Does(() => {
        if (IsRunningOnWindows())
        {
            var reportFilePath = ".\\docs\\testsResults\\Reports\\ReportGeneratorOutput\\index.htm";

            StartProcess("explorer", reportFilePath);
        }
    });

RunTarget(target);

#tool "nuget:?package=OpenCover"

#tool "nuget:?package=NUnit.ConsoleRunner"

#tool "nuget:?package=ReportGenerator"

var target = Argument("target", "Default");

Task("BuildProjects")

.Does(() =>

{

foreach(var project in GetFiles("./src/**/*.csproj"))

{

MSBuild(project.GetDirectory().FullPath,

new MSBuildSettings {

Verbosity = Verbosity.Minimal,

Configuration = "Debug"

}

);

}

});

Task("BuildTests")

.IsDependentOn("BuildProjects")

.Does(() =>

{

foreach(var test in GetFiles("./tests/**/*.csproj"))

{

MSBuild(test.GetDirectory().FullPath,

new MSBuildSettings {

Verbosity = Verbosity.Minimal,

Configuration = "Debug"

}

);

}

});

Task("OpenCover")

.IsDependentOn("BuildTests")

.Does(() =>

{

var openCoverSettings = new OpenCoverSettings()

{

SkipAutoProps = true,

ArgumentCustomization = args => args.Append("-coverbytest:*.Tests.dll").Append("-mergebyhash")

};

var outputFile = new FilePath("./docs/testsResults/Reports/CodeCoverageReport.xml");

OpenCover(tool => {

var testAssemblies = GetFiles("./tests/**/bin/Debug/*.Tests.dll");

tool.NUnit3(testAssemblies);

outputFile,

openCoverSettings

.WithFilter("+[CodeCoverage*]*")

.WithFilter("-[CodeCoverage.*.Tests]*")

);

});

Task("ReportGenerator")

.IsDependentOn("OpenCover")

.Does(() =>{

var reportGeneratorSettings = new ReportGeneratorSettings()

{

HistoryDirectory = new DirectoryPath("./docs/testsResults/Reports/ReportsHistory")

};

ReportGenerator("./docs/testsResults/Reports/CodeCoverageReport.xml",

"./docs/testsResults/Reports/ReportGeneratorOutput",

reportGeneratorSettings);

});

Task("Default")

.IsDependentOn("ReportGenerator")

.Does(() => {

if (IsRunningOnWindows())

{

var reportFilePath = ".\\docs\\testsResults\\Reports\\ReportGeneratorOutput\\index.htm";

StartProcess("explorer", reportFilePath);

}

});

RunTarget(target);

Volte ao Powershell e digite o comando .\build.ps1 para executar o script do Cake.

Após a execução do script, o Report Generator irá compilar os arquivos xml do OpenCover e gerar uma visualização mais amigável e detalhada e ainda abrir um sumário no seu navegador padrão, incluind um histório de cobertura.

.gitignore

Se você está usando o arquivo .gitignore padrão do Visual Studio – aquele que é fornecido, por exemplo, pelo GitHub ou Visual Studio Online – será preciso alterar para que ele ignore os arquivos compilados do Cake e não suba para o repositório do GitHub. Para isso encontre o trecho a seguir:

# Cake - Uncomment if you are using it
# tools/**
# !tools/packages.confi

# Cake - Uncomment if you are using it

# tools/**

# !tools/packages.confi

E descomente as duas últimas linhas.

# Cake - Uncomment if you are using it
tools/**
!tools/packages.config

# Cake - Uncomment if you are using it

tools/**

!tools/packages.config

Pronto, agora podemos acompanhar a evolução dos testes de nosso aplicativo de forma elegante e segura.

Até a próxima e se quiser, acesse o projeto completo em meu GitHub:

https://github.com/tiagopariz/CodeCoverage

Cake: automatizando tarefas

O Cake é um automatizador de tarefas construído sobre o compilador do C# e de fácil configuração.

Instalando o Cake

Para usar o Cake, precisamos baixar os scripts de automação que vem todos em um arquivo chamado build.ps1 que roda no Powershell. Para isso, abra o Powershell, crie uma pasta chamada CakeAutomation.

PS C:\> Set-Location .\GitHub\
PS C:\GitHub> New-Item -ItemType Directory -Path CakeAutomation

    Diretório: C:\GitHub

Mode                LastWriteTime         Length Name
----                -------------         ------ ----
d-----       27/01/2018     12:26                CakeAutomation

PS C:\GitHub> Set-Location .\CakeAutomation\
PS C:\GitHub\CakeAutomation>

PS C:\> Set-Location .\GitHub\

PS C:\GitHub> New-Item -ItemType Directory -Path CakeAutomation

Diretório: C:\GitHub

Mode LastWriteTime Length Name

---- ------------- ------ ----

d----- 27/01/2018 12:26 CakeAutomation

PS C:\GitHub> Set-Location .\CakeAutomation\

PS C:\GitHub\CakeAutomation>

Com a pasta criado, execute o comando para baixar o pacote com as configurações.

Invoke-WebRequest https://cakebuild.net/download/bootstrapper/windows -OutFile build.ps1

1	Invoke-WebRequest https://cakebuild.net/download/bootstrapper/windows -OutFile build.ps1

Pronto, o ambiente está configurado, agora precisamos de um projeto para automatizar.

Crie uma aplicação de exemplo

Eu tenho um post que ensina como criar uma aplicação console com o Visual Studio Code, vamos usar este exemplo para automatizar uma build:

Visual Studio Code: como criar uma aplicação console em C#

Crie o script de build da aplicação com o Cake

Na raiz do projeto, inclua uma arquivo chamado build.cake, que será onde residirá todo o código de automação. Edite o arquivo conforme segue:

var targetHello = Argument("target", "Default");
var targetBuild = Argument("target", "Build");
var configuration = Argument("configuration", "Release");
var artifactsDirectory = MakeAbsolute(Directory("./artifacts"));
 
Task("Default")
    .Does(() =>
    {
        Information("Hello World! Lets build? Sure.");
    });
 
RunTarget(targetHello);

Task("Build")
    .Does(() =>
    {
        foreach(var project in GetFiles("./src/**/*.csproj"))
        {
            DotNetCoreBuild(
                project.GetDirectory().FullPath, 
                new DotNetCoreBuildSettings()
                {
                    Configuration = configuration
                });
        }
    });

RunTarget(targetBuild);

var targetHello = Argument("target", "Default");

var targetBuild = Argument("target", "Build");

var configuration = Argument("configuration", "Release");

var artifactsDirectory = MakeAbsolute(Directory("./artifacts"));

Task("Default")

.Does(() =>

{

Information("Hello World! Lets build? Sure.");

});

RunTarget(targetHello);

Task("Build")

.Does(() =>

{

foreach(var project in GetFiles("./src/**/*.csproj"))

{

DotNetCoreBuild(

project.GetDirectory().FullPath,

new DotNetCoreBuildSettings()

{

Configuration = configuration

});

}

});

RunTarget(targetBuild);

Agora o script está pronto para ser rodado, para isso, é preciso que você esteja na raiz do projeto, via powershell digite o comando a seguir:

PS C:\GitHub\CakeAutomation> .\build.ps1

1	PS C:\GitHub\CakeAutomation> .\build.ps1

Site oficial

https://cakebuild.net/

Extensão para VS Code:

https://marketplace.visualstudio.com/items?itemName=cake-build.cake-vscode

Repositório no GitHub:

https://github.com/tiagopariz/CakeAutomation

C#: Using e Dispose

Não vejo muitos softwares usando em seu código, pelo menos da maneira correta, o bloco using em conjunto método Dispose da interface IDisposable() da maneira correta. Mas vou mostrar em um exemplo bem simples como estes dois recursos podem ser poderosos para manter uma aplicação enxuta e performática.

Para começar, vamos criar uma solução chamada UsingAndDispose e incluir dois projetos, um projeto de domínio do tipo Class Library chamado UsingAndDispose.Domain e outro do tipo Console Application chamado UsingAndDispose.Prompt.

No projeto de domínio, vamos incluir uma classe chamada TxtFile, que recebe dois parâmetros via construtor, nome do arquivo e pasta, e com eles alimenta uma propriedade que retorna o caminho completo. Incluiremos também um método que efetuará o fechamento do arquivo após a leitura e limpará a memória, mas neste caso vamos apenas escrever um frase na tela do console.

Crie uma classe chamada TxtFile e defina uma herança da interface IDisposable, que exigirá a implementação do método Dispose, que chamará o método Close().

using System;

namespace UsingAndDispose.Domain
{
    public class TxtFile : IDisposable
    {
        public TxtFile(string name, string folder)
        {
            Name = name;
            Folder = folder;
            FullPath = Folder + "/" + Name;
        }

        public string Name { get; }
        public string Folder { get; }
        public string FullPath { get; }

        public void Close()
        {
            Console.WriteLine("Dispose object...");
        }

        public void Dispose()
        {
            Close();
        }
    }
}

using System;

namespace UsingAndDispose.Domain

{

public class TxtFile : IDisposable

{

public TxtFile(string name, string folder)

{

Name = name;

Folder = folder;

FullPath = Folder + "/" + Name;

}

public string Name { get; }

public string Folder { get; }

public string FullPath { get; }

public void Close()

{

Console.WriteLine("Dispose object...");

}

public void Dispose()

{

Close();

}

Obs.: Não vamos entrar na complexidade da lógica de leitura de um arquivo de texto de fato, mas apenas criar um classe que poderia implementá-la, o importante é entender o mecanismo do bloco using.

Então, no projeto de console, altere a classe Program.cs, incluindo um bloco using, conforme o código a seguir, e faça uma referência ao projeto de domínio para acessar a classe TxtFile.

using System;
using UsingAndDispose.Domain;

namespace UsingAndDispose.Prompt
{
    internal class Program
    {
        private static void Main()
        {
            var name = "Test";
            var folder = "C:/Temp";

            using (var file = new TxtFile(name, folder))
            {
                Console.WriteLine(file.FullPath);
            }

            Console.ReadKey();
        }
    }
}

using System;

using UsingAndDispose.Domain;

namespace UsingAndDispose.Prompt

{

internal class Program

{

private static void Main()

{

var name = "Test";

var folder = "C:/Temp";

using (var file = new TxtFile(name, folder))

{

Console.WriteLine(file.FullPath);

}

Console.ReadKey();

}

Ao executar o código acima, percebemos que a mensagem do método Close é exibida em tela, mas o curioso que em nenhum momento o chamamos diretamente. Isso acontece porque a classe TxtFile implementa a interface IDisposable, e quando o using recebe objetos que são implementados a partir desta interface, automaticamente é chamado o método Dispose() ao fechar o bloco. E neste caso, o método Dispose() foi implementado com uma chamada ao método Close().

Acesse o projeto completo no meu GitHub:

https://github.com/tiagopariz/UsingAndDispose

Git: convenção para estrutura de pastas

Desde que comecei trabalhar com repositórios de controle de versão do Git, tenho buscado melhores práticas, tanto para armazenar projetos como versioná-los de forma eficiente. Mas o meu espírito metódico começou perceber que as pessoas e empresas armazenavam coisas muito além dos códigos fontes de seus projetos, criando um verdadeiro ambiente com todas informações e ferramentas usadas centralizadas no mesmo repositório, tornando assim algo que pareça realmente um projeto completo.

Acredito que não há um convenção oficial explicando como a estrutura de pastas deveria ser organizada dentro de um repositório, mas encontrei alguns exemplos, nos quais os desenvolvedores justificam suas escolhas, e estas justificativas fazem muito sentido. Portanto, o melhor modelo, na minha opinião, que encontrei foi este:

$/
 artifacts/
 build/
 core/
 docs/
 lib/
 packages/
 samples/
 sql/
 src/
 tests/
 tools/
 .editorconfig
 .gitignore
 .gitattributes
 build.cmd
 build.sh
 LICENSE
 NuGet.Config
 README.md
 {solution}.sln

artifacts/

build/

core/

docs/

lib/

packages/

samples/

sql/

src/

tests/

tools/

.editorconfig

.gitignore

.gitattributes

build.cmd

build.sh

LICENSE

NuGet.Config

README.md

{solution}.sln

A solução de organização apresentada, possui uma lógica bem coerente, mas que não está livre de sugestões, adaptações e críticas:

src

Projetos principais, ou seja, o código fonte do produto. Mas é preciso deixar claro que, quando criamos uma nova solução no Visual Studio, o padrão criado não é este, então, é preciso alguns ajustes nos projetos existentes e a criar novo selecionar a pasta.

core

Assim como temos a pasta src na raíz do repositório, podemos criar superclasses genéricas que podem ser reaproveitadas em outras soluções, para isso, é possível criar uma pasta chamada core e dentro dela ter outras pastas de projeto, como src e tests.

tests

Projetos de testes. Embora os projetos de testes possam estar incluídos na mesma solução, nesta convenção, eles são fisicamente alocados em um pasta própria. Mas cuidado para não confundir esta pasta física com as Solution folders, que são diretórios que apenas existem dentro da estrutura de projetos do Visual Studio.

tools

Ferramentas e utilitários em geral. Este diretório serve como apoio ao desenvolvimento do projeto, podendo centralizar softwares, addons, executáveis bibliotecas úteis no dia a dia.

docs

Documentação em geral como arquivos de notas, ajuda, relatórios, etc.

samples

Projetos de exemplo ou exemplos de uso. Esta é uma pasta opcional, mas pode ser útil para demonstrar algum recurso ou funcionalidade na prática.

lib

Coisas que nunca poderão estar em um pacote NuGet, por exemplo.

sql

Arquivos SQL para criação do banco de dados ou para suporte.

artifacts

Armezene aqui as saídas de compilações do produto, todavia, é preciso configurar a IDE para usar esta pasta em seus builds, como por exemplo arquivos nupkgs, dlls, pdbs, etc.

packages

Armazene aqui os pacotes NuGet compilados.

build

Builds dos projetos, assim como scripts de build customizados, como por exemplo, para o Msbuild. Pastas bin e obj. É quase igual ao artefacts, mas difere pela relação com o produto final, sendo que em artefacts serão armazenadas já versão estáveis dos builds e aqui é a pasta de cache para o desenvolvimento do dia a dia, podendo até estar no .gitignore.

build.cmd

Arquivos de comando que geram o build para windows

build.sh

Arquivos de comando que geram o build para unix, linux…

global.json

Arquivo de solução ASP.NET Core

LICENSE

Arquivo que contém a licença de uso do software e seu código fonte

README.md

Arquivo com informações relevantes do projeto em formato markdown, podendo ser um tutorial ou resultados de testes

Outros arquivos

Os arquivos .editorconfig, .gitignore, .gitattributes são arquivos do Git e/ou para configurações pessoais de editores

NuGet.Config

Arquivo de configuração para pacotes NuGet

Referências:

https://gist.github.com/davidfowl/ed7564297c61fe9ab814
https://github.com/kriasoft/Folder-Structure-Conventions

Visual Studio: alterar o framework padrão para novos projetos

Introdução

Muitas vezes é preciso que todos os novos projetos já estejam em uma versão do .Net Framework específica, ou simplesmente, que já seja criado com o target na última versão disponível no Visual Studio.

Alterando a versão padrão

Abra o Visual Studio, clique em File, em seguida em New e por último em Project…

Anote a versão do .Net Framework que será a padrão para os novos projetos, como por exemplo “4.6.1”.

Pressione as teclas Win + R, em Abrir digite o comando regedit e clique em Ok.

A janela do Editor do Registro será exibida.

Localize a chave HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\14.0\NewProjectDialog, e edite a chave fxVersion para a versão do .Net Framework desejada.

Observação: onde está escrito 14.0, que equivale a versão do Visual Studio 2015, pode ser alterada para a versão do seu Visual Studio, como por exemplo, 13.0 para o 2013.

O Visual Studio 2017 não precisa desta configuração, pois ele lembra a última versão usada ao criar um projeto.

Pronto, agora todas os novos projetos serão automaticamente definido com a versão configurada por padrão.

NuGet: atualizar um pacote instalado no projeto

Introdução

Para atualizar um pacote NuGet que já está instalado em uma solução, é muito simples, porém, é preciso muita cautela e talvez alguma revisão de código. A seguir eu mostro uma atualização do pacote FluentValidator da versão 2.0.0 para a última versão.

Instale um pacote NuGet antigo

Primeiro, vamos instalar uma versão antiga do pacote FluentValidator, em uma nova solução com um projeto console.

Crie a solução com um projeto do tipo Console Application chamada NugetUpdatePackage.

Clique no menu Tools, em seguida em NuGet Package Manager e finalmente em Package Manager Console.

Em Package Manager Console, em Default project, selecione o projeto que será instalado o pacote.

Digite o comando a seguir, que irá instalar a versão 2.0.0 do FluentValidator, que não é a última:

Install-Package FluentValidator -Version 2.0.0

1	Install-Package FluentValidator -Version 2.0.0

Edite a classe Program.cs, conforme segue:

using System;
using FluentValidator;

namespace NugetUpdatePackage
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Type a email");
            var input = Console.ReadLine();
            var email = new Email(input);

            Console.WriteLine(email.IsValid ? "Valid" : "Not valid");

            Console.ReadKey();
        }
    }

    public class Email : Notifiable
    {
        public Email(string s)
        {
            if (string.IsNullOrWhiteSpace(s))
                AddNotification("E-Mail", "Can not be null");
        }
    }
}

using System;

using FluentValidator;

namespace NugetUpdatePackage

{

class Program

{

static void Main(string[] args)

{

Console.WriteLine("Type a email");

var input = Console.ReadLine();

var email = new Email(input);

Console.WriteLine(email.IsValid ? "Valid" : "Not valid");

Console.ReadKey();

}

public class Email : Notifiable

{

public Email(string s)

{

if (string.IsNullOrWhiteSpace(s))

AddNotification("E-Mail", "Can not be null");

}

Execute o programa, e verifique o funcionamento.

Atualizando o pacote para a ultima versão

Abra a janela Package Manager Console, em Default project, selecione o projeto que será atualizado o pacote, e digite o comando a seguir, que irá atualizar para a ultima versão do FluentValidator:

Update-Package FluentValidator

1	Update-Package FluentValidator

Agora o nosso projeto está com a última versão, todavia, será preciso revisar o código, pois, há algumas alterações na forma de usar o pacote.

O método IsValid parece não estar funcionando, e para entender o problema, precisamos ler a documentação, ou procurar pelo recurso de Intellisense da própria IDE. E neste caso conseguimos deduzir pelo por ele mesmo.

Pronto, nosso código voltou a compilar.