Trabalhando com Tipos Complexos no EF Core

O Entity Framework Core apesar de funcional ainda não está 100%. Algumas funcionalidades requerem workarounds ou simplesmente não existem. Mas temos algo para comemorar, agora podemos trabalhar com tipos complexos sem impactar na modelagem de nossas entidades.

Entity Framework Core

Trabalhando com Tipos Complexos no EF Core

Eu trabalho muito com entidades ricas que seguem as boas práticas de modelagem do DDD. Para possuirmos um domínio rico é necessário dar a maior expressividade possível ao nosso código muitas vezes deixando de usar tipos primitivos para usar tipos complexos.

O Entity Framework Core antes da versão 2 simplesmente não conseguia mapear tipos complexos, ou seja, era necessário impactar diretamente na modelagem de nossas entidades apenas para contornar uma deficiência do ORM. Que coisa horrível não?

Inclusive muitos desenvolvedores simplesmente abriram mão de usar o EF Core e adotaram outras soluções como o Dapper por exemplo. Mas agora esse problema não existe mais!

Mapeando um Tipo Complexo

Vamos supor que sua entidade Cliente possui um campo CPF, muitas vezes basta criar um tipo string e pronto, mas o ideal seria que o CPF fosse um Value Object, pois permite reusabilidade de código além de permitir que a própria classe CPF cuide da questão da validação. Além disso podem existir outros dados como Data de Emissão por exemplo:

Os tipos complexos podem ser Value Objects ou outras entidades, o importante é que o modelo seja o mais rico e expressivo possível.

No EF Core 2 agora é possível utilizar Fluent API de forma nativa (sem gambiarras) e mapear os tipos complexos a partir do recurso OwnsOne:

Depois de todo trabalho de modelagem feito basta executar os comandos:

  • Add-Migration
  • Update-Database

E pronto! Seu modelo está criado.

Mapeamento Gerado no Entity Framework Core

Inserindo e recuperando a entidade através do EF Core

Uma vez que estamos trabalhando com modelos ricos, devemos seguir as boas práticas (utilizar private setters, ad-hoc setters, construtores e validação de consistência):

  • É necessário criar um construtor protected nas classes para que o EF Core possa recuperar do banco e criar a instância, pois ele não entende o construtor.
  • As validações foram feitas na mão e lançando exceptions para fins de demonstração
  • O objeto é recuperado exatamente como se deseja do banco

Entidade recuperada no Entity Framework Core

Testes

Testar é importante certo? Esse projeto foi disponibilizado com o código fonte completo inclusive testando todas as situações previstas:

Testes de Unidade no Entity Framework Core

Com este código fonte eu espero ajudar você a não ter mais nenhum problema de mapeamento de tipos complexos do seu domínio rico com Entity Framework Core.

Resumindo

O projeto completo está no meu GitHub

O EF Core ainda apresenta problemas irritantes como não possuir mapeamento Many to Many. É necessário fazer uma gambiarra horrível (mas funciona).

Não deixe de utilizar modelos ricos em suas aplicações, é muito importante para um bom design de código e uma modelagem correta de seu domínio. Agora o EF Core não será mais um problema.


Caso esteja interessado em conhecer mais sobre Testes, TDD, ASP.NET, DDD, Padrões de Arquitetura e boas práticas de desenvolvimento não deixe de conferir as ementas dos meus cursos:

Vamos continuar a troca de experiências, deixe seu comentário abaixo. Se gostou e concorda com o artigo, compartilhe com seus colegas para transmitirmos o conhecimento para o máximo de pessoas possíveis.

2017 – Um ano muito especial!

O ano de 2017 foi muito especial, um ano de consolidação, preparação e conhecimento para as futuras conquistas.

Primeiramente agradeço a você leitor deste site! Suas visitas, feedbacks e interações tem sido a minha maior motivação para continuar escrevendo e entregando conteúdos para a comunidade técnica.

É muito satisfatório saber que por dia cerca de 3.000 pessoas acessam este site e que de alguma forma estou ajudando estes em suas carreiras, resolução de problemas e etc.

Vamos aos melhores momentos de 2017:

Microsoft MVP Award

Microsoft MVP 2017 - 2018

O programa MVP está passando por diversas mudanças. Está mais aberto, agora todo mês são selecionados novos premiados e está significantemente mais simples/fácil receber essa premiação da Microsoft. Independente do mês todos renovam em Julho, como eu era do ciclo de Janeiro eu renovei para 2017 e 2018 de uma só vez!

DevXperience

DevXperience 2017

O DevXperience é a revolução do ASP.NET Brasil Conference. Nesse ano de estréia tivemos um evento para 700 pessoas com 3 trilhas e 42 palestras. Foi um sucesso! Por ser um evento novo e mais amplo eu fiquei feliz com o resultado.

Cursos de Desenvolvimento Web e Arquitetura

Esses são os números de 2017:

  • Cursos Realizados: 19
  • Alunos: 974
  • Horas ministrando curso: 1.140

Saiba mais sobre meus cursos

Site / Blog

Onde tudo começou, ter um site foi a minha primeira iniciativa de compartilhar meus conteúdos na comunidade técnica. Os resultados tem me surpreendido muito, recebo feedbacks fantásticos, eu mal consigo responder todos em tempo. O site aumentou em 37% o número de visitantes em relação ao ano passado.

Alguns números sobre o site:

  • Acessos: 1.527.180 mais de um milhão e meio de visitas em 2017 \o/
  • Média diária: 3.100
  • Posts: 137
  • Horas de vídeo: 36
  • Comentários: 3.544

O que dizer sobre esse resultado? São tantas coisas, fico muito satisfeito e gostaria de dizer MUITO obrigado a todos que fizeram parte destes números.

Conquistas pessoais

Em 2017 eu foquei um pouco mais em mim, cuidei da saúde, visual, comecei a comer melhor, praticar exercícios e etc. Foi um passo inicial, agora em 2018 além de manter eu pretendo melhorar ainda mais.

Minha visão de 2017

O ano de 2017 no geral foi um ano de transição, tivemos uma pequena melhora na economia e no cenário nacional, mas ainda tem muito chão para chegar próximo do aceitável.

O meu ano de 2017 também foi de transição, observei vários aspectos de minhas atuações no mercado e planejei mudanças que irei colocar em prática em 2018. Foi um ótimo ano, bati todas minhas metas e me preparei para colocar muita coisa em prática neste novo ano.

O que vem pela frente?

Parte das mudanças que planejei no aspecto profissional é na minha atuação com a comunidade técnica.

Percebi que com o crescimento da demanda pelos meus treinamentos e consultoria eu acabei me afastando um pouco da comunidade e contribuí com menos do que queria.

Por isso deixo aqui um compromisso público de entregar mais conteúdos (gratuitos):

  • Entregar 10 palestras em eventos
  • Escrever no 20 posts neste blog
  • Realizar 5 Meetups presenciais
  • Gravar 5 vídeos para meu canal no Eduardo Pires
  • Retornar com o canal Sou Desenvolvedor
  • Entregar a versão 2.0 do Equinox Project

Esses números são o mínimo, sendo que pode vir a ser muito mais 🙂

2017 foi um ano inesquecível. Muito obrigado por fazer parte dele.

Desejo a você um excelente 2018! Muito sucesso, estudos, foco e dedicação!
Grande Abraço.

10 Boas práticas no desenvolvimento com ASP.NET Core

O ASP.NET Core trouxe uma série de novidades e mudanças em relação ao ASP.NET Clássico e essas novidades vieram para facilitar nossa vida no desenvolvimento, portanto são essenciais para qualquer desenvolvedor.

O conteúdo deste material está em vídeo, pois foi uma palestra online que realizei no Canal .NET e foi gravada ao vivo.

10BoasPraticasAspNetCore

Por que selecionei estas 10 boas práticas? Eu poderia selecionar 50 ou mais, porém estas 10 são essenciais para fazer o bom uso do ASP.NET Core portanto assista, pratique e implemente em seus projetos, fará um grande diferencial.

Tanto o PPT quando o código fonte estão disponíveis em meu GitHub.

Espero que vocês aproveitem as dicas e qualquer dúvida estou a disposição.

* Assine meu canal no Youtube ?


Caso esteja interessado em conhecer mais sobre Testes, TDD, ASP.NET, DDD, Padrões de Arquitetura e boas práticas de desenvolvimento não deixe de conferir as ementas dos meus cursos:

Vamos continuar a troca de experiências, deixe seu comentário abaixo. Se gostou e concorda com o artigo, compartilhe com seus colegas para transmitirmos o conhecimento para o máximo de pessoas possíveis.

Ferramentas para escrever testes de unidade mais eficientes

Além dos famosos frameworks para testes de unidade, existem muitas outras ferramentas para nos auxiliar a escrever testes com menos código, mais eficientes e muito mais fáceis de manter.

Testes de Unidade

Testes de unidade não são um artefato comum no cenário de desenvolvimento de software corporativo, todos já ouviram falar, alguns tentam colocar em prática mas a questão da falta de design de código acaba não permitindo.

Além disso existem os famosos gestores que inibem a prática, pois acreditam que escrever um código para testar outro código é perda de tempo e aumenta o tempo de projeto.

TDD? Isso é coisa de Jedi! Apenas os desenvolvedores mais graduados na arte da codificação são capazes de escrever o teste de um código que ainda não existe.

Não é bem por ai!

Testes de unidade fazem parte da tarefa de escrever código! Código bom é aquele que pode ser testado. O que vale mais? Rodar a aplicação até o ponto desejado, colocar um break point no código e validar linha a linha se o código está realmente cumprindo a necessidade ou escrever um teste que valide isto?

Além do teste lhe prover um feedback em milissegundos, você só precisa escrever ele uma vez. Rodar a aplicação e realizar o debug pode demorar minutos e este tipo de validação precisa ser repetida dezenas de vezes (ou até mais).

TDD não é a uma técnica complicada, pelo contrário, é simples! Não existem motivos para não testar, na verdade muitos problemas do dia-a-dia seriam evitados com os testes.

Então por que não testamos?

Acredito que o principal fator é que o desenvolvedor não sabe testar! Como eu costumo dizer, isto é uma questão de “tooling”. Tooling seria o ferramental, a prática necessária e ferramentas utilizadas para a escrita de testes de unidade.

Meu objetivo não é provar que testes de unidade vão resolver muitos dos seus problemas e melhorar a qualidade das suas entregas (mas vão sim, acredite).
Meu objetivo é apresentar um ótimo conjunto de ferramentas para que você comece a escrever testes de unidade da melhor forma possível!

Todas as ferramentas são open-source e gratuitas 😉

Frameworks de Testes

São os responsáveis por rodar os testes de unidade e fazer as asserções (Assert) para garantir que o resultado do teste bateu com o esperado.

É a ferramenta mais importante e é necessário fazer uma boa escolha, afinal depois de ter escrito centenas de testes mudar de framework não será simples.

Para .NET não temos tantas opções (ainda bem)

  • MSTest
  • NUnit
  • XUnit

O MSTest é o framework padrão do Visual Studio, desenvolvido pela Microsoft e utilizado em muitos projetos. Eu não costumo utilizar, mas também não o julgo como ruim.

O NUnit é o framework mais utilizado entre desenvolvedores .NET, possui anos de história e atende muito bem as necessidades, podemos ver o NUnit como uma portabilidade do JUnit do Java para .NET.

XUnit é o mais novo desta lista e atualmente meu preferido. Ele foi criado pelos mesmos desenvolvedores do NUnit. A ideia do XUnit surgiu em simplificar e modernizar a forma de escrever testes. Estas mudanças seriam impossíveis de serem aplicadas no NUnit, pois resultaria num gigantesco breaking change nos testes já existentes.

Mas esse XUnit é confiável mesmo? Os desenvolvedores do novo stack do .NET estão utilizando o XUnit. Sim o nosso .NET Core, ASP.NET Core, EF Core, etc estão sendo testados com XUnit. Acho que somente este fato já nos trás bastante segurança certo?

Um pouco mais sobre o XUnit

Escrever testes com o XUnit é um pouco diferente, afinal algumas coisas fogem do padrão, não é necessário fazer Setup, Tear Down etc, basta usar o construtor da clase e o dispose. É um framework muito flexível e é possível criar extensões para diversas finalidades.

Eu sugiro que você leia a comparação feita entre o XUnit e os outros frameworks para começar a ter uma ideia das mudanças. Não deixe também de ler a documentação e visitar o projeto no GitHub.

Para que o Visual Studio reconheça seus testes (uma vez que é o MSTest o padrão) é necessário instalar um “Runner“, existem runners para Visual Studio, Xamarin, Console, MSBuild e etc.

Eu preparei um projeto implementando todas as ferramentas listadas e com exemplos de como utilizar. O link está no final do post (mas continue lendo, tem muito mais).

Frameworks de Mock

O que seriam dos testes sem os Mocks? Para quem não conhece o termo, realizar o Mock de algo é criar em tempo de execução uma instância de uma classe ou a implementação de uma interface. Imagine que seu teste depende de ler algo do banco de dados, você não precisa que ele vá até o banco de fato, basta “fingir” que foi.

O Mock é uma instância de determinado objeto mas nós podemos ensinar este objeto “mockado” a responder conforme nossas necessidades, por exemplo ao invés de ir até o banco simplemente traga uma lista de objetos que já foi definida como retorno. Para isto basta “ensinar” o método do objeto mockado o que ele deve fazer ao ser invocado.

Para Mock também existem algumas opções:

Existem mais opções além dos listados, estes são os mais utilizados atualmente.
O meu preferido e o que utilizo atualmente é o MOQ.

Este MOQ é o melhor? Devo-utilizar?
Não existe o melhor, é questão de afinidade também, mas com certeza o MOQ é um dos melhores e temos mais uma vantagem. A Microsoft utiliza o MOQ junto com o XUnit para desenvolver nosso novo stack do .NET Core.

Um exemplo de Mock com MOQ

Vamos simular que desejamos validar o retorno de um objeto que seria recuperado do banco de dados através de um repositório.

[Fact]
public void CustomerRepository_GetCustomer_ShouldReturnUniqueCustomer()
{
    // Arrange
    var customer = new Customer(Guid.NewGuid(), 
                                "Eduardo Pires");

    var repository = new Mock<ICustomerRepository>();

    repository.Setup(r => r.GetById(customer.Id))
        .Returns(customer);

    // Act
    var customerRet = repository.Object.GetById(customer.Id);

    // Assert
    Assert.Equal(customer, customerRet);
    repository.Verify(r => r.GetById(It.IsAny<Guid>()), 
                           Times.Once);
}

Criamos uma instância do objeto baseado na interface, “ensinamos” ao método o que ele devolveria retornar ao receber determinado parâmetro e pronto.

O MOQ ainda nos oferece o Verify que é um método de Asserção para validarmos se aquele método foi realmente chamado e quantas vezes foi.

Poderíamos ter parado por aqui, pois apenas um bom framework de teste e um de mock já nos bastariam para escrever nossos testes de unidade, mas tem como melhorar bastante esta experiência.

Apresentando o AutoMoq

Imagine que você precisa criar a instância de um objeto mas este objeto recebe diversas dependências injetadas no construtor. Obviamente no teste você não terá um container de DI, nesse caso você precisaria criar um mock de cada dependência e depois passar todas no construtor.

Tranquilo! Mas dá para ser melhor! E se fosse possível criar de uma vez só este objeto com todos os mocks gerados e injetados? Pouparia bastante código né?

É para isto que existe o AutoMoq! Sim você vai querer muito ele em seu projeto.
O AutoMoq gera os mocks do MOQ, está tudo em casa!

A classe CustomerService possui duas dependências injetadas no construtor

public class CustomerService : ICustomerService
{
    private readonly ICustomerRepository _customerRepository;
    private readonly IMediator _mediator;

    public CustomerService(
                ICustomerRepository customerRepository,
                IMediator mediator)
    {
        _customerRepository = customerRepository;
        _mediator = mediator;
    }
}

Vamos criar uma instância dela e automaticamente seus mocks com o AutoMoq

[Fact]
public void CustomerService_RegisterNewCustomer_ShouldRegisterWithSuccess()
{
    // Arrange
    var customer = new Customer(Guid.NewGuid(),
        "Eduardo Pires");

    var mocker = new AutoMoqer();
    mocker.Create<CustomerService>();

    var customerService = mocker.Resolve<CustomerService>();
    var repository = mocker.GetMock<ICustomerRepository>();

    // Act
    customerService.Register(customer);

    // Assert
    repository.Verify(r => r.Add(It.IsAny<Customer>()), 
                           Times.Once);
}

Note de que além de criar o objeto com seus mocks injetados é possível ainda obter estes mocks para que possam ser “ensinados” ou apenas validados como no caso do nosso teste, isso significa que o repositório salvou o cliente, logo podemos entender que o teste conseguiu validar o processo.

O AutoMoq é indispensável para nos poupar da tarefa de criar e injetar cada mock e é basicamente isto que ele faz.

Bogus

Você já deve ter imaginado que é muito chato ter que ficar criando dados de testes (e-mails, telefone, nome, sobrenome, endereço etc). Além disso muitas vezes é necessário simular uma grande lista de dados únicos. Como fazer?

O Bogus é um gerador de dados aleatórios! Existem outros que fazem isto, mas o Bogus é mais humano. Ele gera dados reais e em diversos idiomas \o/

Vamos simular que desejo criar uma lista de 100 clientes

var customerTests = new Faker<Customer>("pt-BR")
    .CustomInstantiator(f => new Customer(
        Guid.NewGuid(),
        f.Name.FirstName(Name.Gender.Male),
        f.Name.LastName(Name.Gender.Male),
        f.Date.Past(80, DateTime.Now.AddYears(-18)),
        f.Internet.Email().ToLower(),
        true,
        DateTime.Now)).Generate(100);

O resultado é muito interessante! Dados humanos gerados com muita facilidade e a garantia de unicidade. Note que não é problema criar um objeto que depende de um construtor.

Bogus Random Data

Uma grande chateação a menos! O Bogus é capaz de gerar diversos tipos de informações e até imagens, recomendo que leia a documentação.

FluentAssertions

É a asserção que garante o resultado do teste, os frameworks tradicionais possuem uma série de métodos para validar se é igual, verdadeiro, falso, maior, menor e etc. Mas a escrita de diversos Asserts pode ser chata e deixar o código inexpressível.

O Fluent Assertions pode te ajudar nisto! Além de utilizar a sintaxe fluente existem inúmeros tipos de asserções que podem ser feitas deixando nosso código mais reduzido e fácil de entender.

[Fact]
public void CustomerService_GetAllActive_ShouldReturnsOnlyActiveCustomers()
{
    // Arrange
    var customerService = Fixture.GetCustomerService();
    Fixture.CustomerRepositoryMock.Setup(c => c.GetAll())
        .Returns(Fixture.GetMixedCustomers());

    // Act
    var customers = customerService.GetAllActive().ToList();

    // Assert Fluent Assertions
    customers.Should().HaveCount(c => c > 1)
        .And.OnlyHaveUniqueItems();

    customers.Should().NotContain(c => !c.Active);
}

É possível mesclar diversas asserções em uma única linha de código.
Bonito né? Não deixe de conferir a documentação.

Outras ferramentas

O meu set básico é este, porém contamos com outras ferramentas como por exemplo o AutoFixture que facilita a criação de objetos comumente utilizados, tudo depende muito das ferramentas que utiliza, o XUnit por exemplo possui um ótimo suporte a Fixture Collections e resolve com elegância esta questão (confira implementação no meu projeto).

Escrever testes é preciso, mas como validar se a cobertura de código está boa?
Ferramentas de Code Coverage servem para validar se o seus testes estão cobrindo bem todo seu código. Não adianta dizer que tem mais de 5.000 testes se estes estão cobrindo apenas 50% do seu código.

Isso significa que metade do seu código corre o risco de ter bugs ou até pior, significa que numa manutenção de rotina você pode mandar um bug para produção por que os testes não estão validando partes da sua aplicação.

O Visual Studio possui uma ótima ferramenta de Code Coverage, mas só está disponível para as versões mais completas. Mas não se preocupe existem boas alternativas.

NCrunch

O NChunch reúne diversas ferramentas para atender nossas necessidades

  • Code coverage
  • Métricas de performance
  • Detalhes das exceptions
  • Execução inteligente dos testes

NDepend

O NDepend possui ferramentas mais avançadas que são muito importantes para quem leva teste de unidade a sério e possui processos de integração contínua, automatização de build e etc.

Ferramentas Gratuitas

Algumas destas features que citei podem ser obtidas separadamente através de outras ferramentas, é questão de buscar e testar!

Uma que eu recomendo é o OpenCover que faz o Code Coverage para qualquer versão do Visual Studio.

Dicas sobre testes

Testar é necessário. Leia, treine, pratique! O “tooling” só desenvolve que bota a mão na massa. Aprenda a testar, aplique esta prática no dia-a-dia e mostre aos seus colegas de trabalho que as vantagens são muito grandes.

Uma ótima sensação é ver um teste falhar após efetuar uma manutenção e pensar:
“Poxa! Eu teria deixado esse bug escapar! Mais um problema evitado!”

Após dominar o processo de escrever bons testes de unidade coloque o TDD em prática e comece a escrever código limpo, desacoplado e testável!

Recomendo dois livros para quem quiser aprender TDD, sugiro ler nesta mesma ordem.

Dica Extra

Evite utilizar o termo “Testes Unitários”, muitas pessoas sentem uma dor forte no ouvido quando mencionado (eu sou uma delas). É um termo errado, utilize sempre “Testes de Unidade”, afinal é isso que é de fato!

Projeto de Exemplo

Agora que você já conhece as ferramentas e para que servem, dê uma conferida no meu projeto de exemplo. É um projeto de domínio simples e outro de testes cobrindo algumas funcionalidades. Fique a vontade para mandar seu Pull Request.


Caso esteja interessado em conhecer mais sobre Testes, TDD, ASP.NET, DDD, Padrões de Arquitetura e boas práticas de desenvolvimento não deixe de conferir as ementas dos meus cursos:

Vamos continuar a troca de experiências, deixe seu comentário abaixo. Se gostou e concorda com o artigo, compartilhe com seus colegas para transmitirmos o conhecimento para o máximo de pessoas possíveis.

10 Motivos para ir ao DevXperience

O DevXperience é um novo evento de tecnologia para o desenvolvimento de software moderno. Precisa de motivos para ir? Aqui vai 10 deles!

O DevXperience é um novo evento de tecnologia para o desenvolvimento de software moderno.

“Eduardo, como você faz para se atualizar tecnicamente e acompanhar tantas novidades na nossa área?”

Acredito que esta é uma das perguntas que eu mais recebo e minha resposta é sempre a mesma:

“Eu participo de muitos eventos, leio bastante e me envolvo em discussões técnicas.”

1 – Atualização tecnológica

Este é o primeiro motivo! Atualização rápida e fácil!

Participar de eventos é algo que potencializa a nossa capacidade de absorção de novos conhecimentos, afinal um palestrante aborda um tema de dias / horas de pesquisas e experiências profissionais e resume todos os aspectos mais importantes em uma palestra de minutos.

É informação pronta! Não requer horas de pesquisa e ainda conta com a experiência de quem apresenta.

2 – O mundo do desenvolvimento de software mudou

Desenvolver software hoje não é mais como anos atrás! Você está pronto para projetar uma arquitetura baseada em nuvem? Garantir que sua aplicação não caia? Entregar aplicações para diversas plataformas? Garantir a qualidade com processos de testes automatizados?

Você precisa conhecer sobre o desenvolvimento de software moderno! Nossos palestrantes são especialistas no assunto e estão ansiosos para lhe contar.

3 – Seja um desenvolvedor fora da caixinha

Desenvolver software é nossa profissão, mas algumas oportunidades realmente nos desafiam.

Como tornar uma ideia numa Startup? Como pensar na melhor experiência de usuário para uma nova aplicação? Blockchain o que é isto? Bots podem conversar com meu cliente e poupar esforço humano?

Saia da caixa conosco e mergulhe num mundo de novidades impactantes!

4 – Ganhar destaque no trabalho

É inegável! Uma pessoa bem informada possui uma credibilidade muito maior e por consequência recebe mais oportunidades.

Você ser capaz de identificar uma chance de adotar alguma novidade que ficou sabendo através de suas participações em eventos técnicos irá lhe render uma ótima visibilidade.

5 – Injeção de ânimo / realidade

Cansado da rotina do trabalho? Já pensou em largar tudo e vender coco na praia?

As vezes o que precisamos é conhecer novas formas de como inovar em nossa carreira, novos caminhos a seguir, assuntos novos a se especializar. O DevXperience criou uma agenda com diversos temas para impactar de verdade e lhe dar uma injeção de ânimo e também de realidade!

6 – Melhor custo / benefício

Quanto de investimento financeiro seria necessário para aprender sobre todos os assuntos abordados na grade de forma independente? Calcule o valor de sua hora, livros e até cursos que poderiam ser necessários para adquirir o conhecimento desejado.

Investir em eventos é uma ótima opção que com certeza lhe poupará muito tempo e dinheiro.

7 – Aprender a vender

Já encontrou alguma tecnologia que gostou e quis levar para a sua empresa mas na hora faltaram palavras para convencer seu time a utilizar? Acontece!

No DevXperience você será apresentado a uma série de novidades e além disso entenderá por que deve adotá-las, quais as vantagens, como o mercado está reagindo e muito mais.

8 – Networking

Estar em contato com centenas de profissionais em 2 dias de evento é uma ótima oportunidade de ampliar fortemente sua rede de contatos.

Buscando um novo emprego? Procurando a pessoa certa para lançar uma Startup? Gostaria de fazer novas amizades dentro de sua área? O DevXperience receberá 900 participantes de diversos níveis, desenvolvedores, empreendedores, CIO’s, CTO’s e etc.

9 – Palestrantes de grande reconhecimento

Todos os palestrantes são profissionais de grande reconhecimento no mercado e que trabalham no dia-a-dia com as tecnologias que irão apresentar.

Tivemos um grande cuidado em selecionar os palestrantes conforme seu foco técnico para lhe oferecer uma grande experiência de troca de conhecimentos.

10 – Estrutura e local privilegiado

Serão 42 palestras em 3 trilhas simultâneas durante 2 os dias de evento, escolha quais palestras gostaria de assistir, pare para tomar um café e conversar em nosso espaço de networking.

Escolhemos uma estrutura muito bem localizada para facilitar o acesso de todos ao evento. Além da localização também priorizamos o conforto, todas as salas contam com telões de alta qualidade e cadeiras confortáveis planejadas em disposição para que não perca nenhum detalhe.


O que está esperando? Junte se a nós neste grande evento!

Confira nossa agenda, palestrantes e demais detalhes no nosso site:
www.devxperience.com.br

Estarei lá apresentando 2 palestras e espero lhe encontrar também! 🙂

 

AngularJS, Angular 2, 4 e etc – Passando a confusão a limpo

AngularJS 1.x ou Angular 2? Qual utilizar? Vale a pena migrar ou aprender?
O Angular 4 é um novo (novo) Angular? Vamos passar a confusão a limpo!

Angular é o framework SPA mais utilizado do mundo, disto não temos dúvidas.
Escrevo este post para inaugurar minha série sobre Angular e para passar a limpo a grande confusão que este tema gerou com a chegada das novas versões.

Angular

AngularJS vs Angular 2, 4, etc…

It’s just “Angular”

Vamos começar esclarecendo uma das maiores confusões:

  • AngularJS – Primeira versão do Angular (1.x)
  • Angular – (apenas Angular) nova versão do Angular

Quando quiser se referir a versão 1.x chame de AngularJS, para a nova versão chame apenas de Angular. Vejo muitas pessoas ainda chamando de Angular 2 (eu mesmo fazia isto) mas o problema é que o versionamento do Angular está sendo feito de forma diferente e estes números estão mudando bem rápido, afinal já estamos no Angular 4.

Novo Versionamento

Assim como a maioria dos projetos sérios, o time do Angular adotou o versionamento SemVer a partir desta nova versão. É por isto que não existe um Angular 3 😉

SemVer

Para levar a sério o versionamento é necessário trocar o número da versão a cada Breaking Change que surgir, ou seja, se algo for deixar de funcionar ao atualizar para a próxima versão, então esta nova versão deve ganhar um novo Major.

O que explica o salto de 2 para 4 é o pacote @angular/router que já estava na versão 3.3.x enquanto os demais estavam na 2.3.x, logo para termos uma nova versão (utilizando o SemVer de forma séria) foi necessário alinhar todos os pacotes para a versão 4.x.x

O time do Angular planeja soltar 2 major versions a cada ano, então podemos esperar um Angular 6 em 2018. Outro detalhe importante é que será garantida a retrocompatibilidade a cada salto, ou seja, a versão 5 será compatível com a 4, porém com a 6 não é garantido.

Como se prevenir?
Quando houver um break change a classe será marcada como “deprecated” e será mantida na próxima versão, no ciclo seguinte será removida e assim o desenvolvedor ao compilar a aplicação conseguirá identificar as mudanças necessárias para que o código nunca quebre durante as atualizações.

Grandes mudanças

Acredito não ser correto considerar o Angular apenas uma nova versão do AngularJS, pois é basicamente um novo framework com uma nova arquitetura, novo paradigma e praticamente incompatível com a versão 1.x.

Esta incompatibilidade na migração para o novo Angular causou muitas frustrações na comunidade técnica e entre a maioria dos desenvolvedores, inclusive durante um tempo deixou a adoção do Angular numa posição delicada, afinal quem gostaria de escolher um framework que não garante retrocompatibilidade com as versões anteriores?

Após os abalos emocionais as coisas ficaram mais claras, as mudanças foram realmente necessárias! O AngularJS apesar de muito popular e muito amado, possuía muitos problemas entre outros detalhes que desagradavam muitos desenvolvedores (inclusive eu).

Listei algumas grandes mudanças que valem muito serem comentadas:

Component-Based

O Angular é totalmente baseado em componentes. Controllers e o $scope não são mais utilizados e foram substituidos por componentes e diretivas.

Os web-components não são uma novidade, desde 2012 o W3C já possuía um rascunho sobre esta possibilidade. O Angular também não é o único framework que entrega web-components, temos também o Vue.JS, React, Aurelia e etc.

Um componente encapsula uma estrutura (html), estilo (css) e comportamento (javascript) e podem ser utilizados como Tags HTML customizadas. Veja isto como uma grande oportunidade de reaproveitamento de código e padronização de desenvolvimento.

Angular Component

Note que um componente Angular possui uma tag própria (selector) e define o HTML e CSS que utilizará. Como o componente é uma classe é nele que são definidos os comportamentos.

Directives

O Angular fornece uma série de diretivas e também é possível escrever diretivas customizadas.

Angular Directive

Podemos dizer que um componente é uma diretiva que possui template (html, css).

As diretivas manipulam o DOM, possuem um papel muito importante e dão muito poder ao framework. Pretendo dedicar um post inteiro sobre funcionamento e detalhes das diretivas.

TypeScript

Foi possível notar que os códigos de exemplo estão um pouco diferentes?

É possível escrever uma aplicação em Angular utilizando TypeScript. Caso não conheça o TypeScript entenda que trata-se de um superset de JavaScript dando superpoderes a linguagem. O TypeScript foi desenvolvido pela Microsoft (o mesmo criador do C#). Leia meu post sobre esta linguagem.

Eu como desenvolvedor C# adoro o TypeScript, pois a linguagem me permite escrever código JavaScript com muitos conceitos de OOP, muito mais organizado e fácil de entender. É possível utilizar expressões lambda, generics, heranças, interfaces e etc.

No final tudo vira JavaScript de novo!
Quando uma aplicação Angular é compilada ocorre um processo chamado de “Transpile” que transforma o TypeScript para JavaScript, mas não se engane! É possível debugar um código JavaScript olhando para o source original em TypeScript!

Angular Linguagens

É possível utilizar também JavaScript ou Dart para escrever aplicações em Angular, apesar de que existe uma forte preferência ao TypeScript pela grande maioria dos desenvolvedores.

Outros pontos interessantes

Além destes diferenciais apresentados existem muitos outros que eu acho muito relevantes como o mecanismo de injeção de dependência (DI) nativo, o ferramental do Angular CLI, WebPack, Reactive Forms entre outros. Pretendo detalhar cada um deles nos próximos posts desta série.

Um outro detalhe que vale muito a pena ser lembrado é a facilidade de criar aplicações híbridas para Mobile utilizando Angular e Ionic.

Vale a pena migrar para o Angular?

Eu diria que sim! O Angular é um framework completo, possui muitos componentes disponíveis para diversas necessidades e já está pronto! Além disso temos uma certa segurança que é o Google por trás disto tudo.

Migrar ou não migrar pode ser mais uma restrição financeira ou de prazo do que realmente técnica. Certamente um projeto escrito em AngularJS que está em perfeito funcionamento não precisaria ser migrado para o Angular.

Eu tomaria a decisão de migrar quando o projeto tem ainda muito a crescer e no futuro a manutenção se tornará mais vantajosa com o Angular (considere também um bom ganho de performance). A curva de aprendizado é pequena na minha opinião, eu aprendi Angular em 3 dias.

Qual devo aprender primeiro? AngularJS ou Angular?

Depende para qual finalidade deseja aprender!

Se for para atuar no mercado como desenvolvedor, obviamente existem muito mais projetos escritos em AngularJS, sendo assim, seria muito vantajoso dominar o AngularJS e a curva de aprendizado para o Angular seria bem mais tranquila.

Se for para estudos ou futuros projetos com certeza vá de Angular! Não é necessário conhecer AngularJS antes, vá direto para a novidade do momento.

E sobre o React, Vue.JS e etc?

Eu considero o React e Vue.JS bibliotecas, não chegam a ser frameworks. Não que isto seja ruim, mas é diferente! Claro que é possível escrever aplicações maravilhosas com eles, não é este o ponto.

Profissionalmente devido a demanda de mercado eu recomendaria aprender Angular e após adquirir domínio pleno, partir para estudar React, Vue.JS e etc.
É apenas a minha opinião e existem outras que diferem da minha.

Resumindo

Espero ter esclarecido a grande confusão causada pelas versões, novidades e incompatibilidades entre AngularJS e Angular, deixo também algumas referências para enriquecer mais o assunto:

Site oficial do Angular
https://angular.io

Documentação do Angular
https://angular.io/docs


Caso esteja interessado em conhecer mais sobre Angular, ASP.NET, DDD, Padrões de Arquitetura e boas práticas de desenvolvimento não deixe de conferir as ementas dos meus cursos:

Vamos continuar a troca de experiências, deixe seu comentário abaixo. Se gostou e concorda com o artigo, compartilhe com seus colegas para transmitirmos o conhecimento para o máximo de pessoas possíveis.

.NET Standard – Você precisa conhecer!

.NET Standard é a nova palavra do momento, quem acompanha de perto as novidades do mundo .NET com certeza já deparou com este novo conceito e é realmente muito importante que você compreenda bem o que ele significa.

O .NET Standard é um conceito essencial para compreender a unificação das plataformas .NET sendo que atualmente podemos entender como 3 plataformas:

.NET Standard

Por que precisamos de um padrão?

O .NET Framework foi lançado em meados de 2002 no formato de um framework único para desenvolvimento na plataforma Windows. Com o passar do tempo ganhou suporte para Web, Silverlight, WCF, WPF, etc…

Após o lançamento do .NET surgiram outros frameworks como Mono, Unity, etc. Que são implementações open-source do .NET Framework e aceitam a linguagem C#, pois implementam os padrões ECMA do C# e o CLR do .NET.

E para finalizar ainda temos o .NET Core o mais recente “sabor” de .NET Framework 100% open-source e multi-plataforma.

Problemas a vista

  • Sendo que todos estes “sabores” de frameworks suportam a linguagem C#, seria possível escrever um único código e rodar em qualquer plataforma?
  • Posso escrever uma biblioteca em .NET 4.6.1 e utilizá-la como referência no .NET Core?
  • É possível garantir que o código não irá quebrar ao trocar a versão do framework?

Não! Sempre existiram diversas limitações. Tanto no suporte das funcionalidades de cada versão quanto no número de APIs suportadas em cada framework.

Para que o .NET continue evoluindo rapidamente é necessário evitar a fragmentação entre tantas versões de frameworks e proporcionar a escrita de um código único para qualquer plataforma. A solução é implementar um padrão para que todas as versões dos frameworks suportem o mesmo conjunto de APIs.

Conceituando o .NET Standard

O .NET Standard não é mais um “sabor” de .NET, você não instala o .NET Standard na sua máquina e também não devemos considerar o .NET Standard uma nova tecnologia.

O .NET Standard é uma interface, uma espécie de contrato que define a lista de APIs que aquela determinada versão do .NET deve suportar. Para entender de forma muito simples o conceito do .NET Standard imagine o seguinte cenário:

.NET Standard Analogia

O David Fowler também criou uma analogia bem interessante sobre o assunto.

Entenda que o .NET Standard é uma espécie de interface que define as APIs que cada versão do .NET irá oferecer suporte. O código do .NET Standard não possui implementação de comportamento, apenas a declaração das classes e métodos. Através deste padrão único conseguiremos uma total compatibilidade de um código .NET Framework para .NET Core por exemplo.

Mas o PCL não serve para isto?

O PCL (Portable Class Libraries) resolvia isto mas de uma outra forma, uma forma bem menos eficiente e que limitava a entrada de novas plataformas. O .NET Standard substituiu o PCL.

Como o .NET Standard resolve esta questão?

O código será compilado para uma versão específica do framework .NET que é suportado em versões específicas do .NET Standard. Cada versão do .NET Standard suporta um número determinado de APIs.

.NET Standard Versões

O .NET Standard 2.0 suporta o .NET Core 2.0 e .NET Framework 4.6.1.
No futuro suportará também as novas versões do Mono, UWP e Xamarin.

Um ponto muito interessante é a evolução da versão 1.6 para a versão 2.0:

Versão #APIs Crescimento%
1.0 7,949
1.1 10,239 +29%
1.2 10,285 +0%
1.3 13,122 +28%
1.4 13,140 +0%
1.5 13,355 +2%
1.6 13,501 +1%
2.0 32,638 +142%

A versão 2.0 do .NET Standard suporta 142% mais APIs que a versão anterior. Um salto incrível no número de APIs suportadas.

Muita calma nessa hora!

Isto não significa que um código escrito para .NET Framework 4.6.1 seja 100% compatível com o .NET Core 2.0.
Existem muitas APIs no .NET Framework que não são implementadas pelo .NET Standard 2.0, logo também não serão suportadas no .NET Core 2.0.

A única compatibilidade entre versões .NET são aquelas cobertas pelo .NET Standard.

Como descobrir se o código está 100% coberto pelo .NET Standard?

Utilize o API Port para analisar se o código está 100% coberto por uma versão específica do .NET Standard. É possível rodar o analyzer via linha de comando ou via Visual Studio.

apiport analyze -f C:\src\mylibs\ -t “.NET Standard,Version=2.0”

Com .NET Standard é muito mais fácil!

O .NET Standard foi criado para que o compartilhamento e a reutilização de código entre várias plataformas .NET se tornem muito mais fáceis.

Desenvolver um Nuget Package será muito mais fácil, basta apontar o target da class library para uma versão específica do .NET Standard ao invés de distribuir uma versão específica para cada framework.

Saiba mais

Documentação oficial
https://docs.microsoft.com/pt-br/dotnet/standard/net-standard

Explore quais APIs são suportadas em cada versão do .NET Standard
https://docs.microsoft.com/en-us/dotnet/api/?view=netstandard-2.0

Confira a FAQ do .NET Standard
https://github.com/dotnet/standard/blob/master/docs/faq.md

Acompanhe a atualização de versões do .NET Standard
https://github.com/dotnet/standard/blob/master/docs/versions.md


Caso esteja interessado em conhecer mais sobre ASP.NET, DDD, Padrões de Arquitetura e boas práticas de desenvolvimento não deixe de conferir as ementas dos meus cursos:

Vamos continuar a troca de experiências, deixe seu comentário abaixo. Se gostou e concorda com o artigo, compartilhe com seus colegas para transmitirmos o conhecimento para o máximo de pessoas possíveis.

Microsoft MVP 2017

Mais um ano inicia e mais uma vez com uma ótima notícia. Fui reconhecido pela quarta vez como Microsoft MVP.

O primeiro dia do ano é um dia muito especial, planejar os sonhos, refazer as metas e iniciar o primeiro dia da melhor forma possível. Para mim é mais que especial, afinal além de todo este ritual pessoal eu recebo neste dia a notícia da renovação da minha premiação como Microsoft MVP.

MVP Awards

Existem muitos motivos que me motivam a fazer parte para sempre deste programa e quero destacar os quatro principais:

  • Estar em contato direto um time muito seleto de profissionais em todo o mundo.
  • Acesso direto ao time de produto / desenvolvimento da Microsoft.
  • Atender ao MVP Summit em Redmond sede global da Microsoft.
  • Ser reconhecido no mercado como um profissional de destaque.

Existe um quinto ótimo motivo que é receber os mimos da nomeação, quem não adoraria ter esta linda coleção de awards? 😀

MVP Awards 2017

Mudança no reconhecimento

Desde 2016 eu deixei de ser MVP em ASP.NET e passei a ser MVP em Visual Studio and Development Technologies. Essa mudança faz parte da nova taxonomia da premiação que foi atualizada, confira o anúncio oficial.

Isto não significa que deixarei falar de ASP.NET, pelo contrário, porém contribuições em outras tecnologias também serão válidas para o programa.

O ano de 2016 foi muito importante para mim, veja minha retrospectiva, e eu atribuo grande parte destas conquistas ao fato de ser reconhecido como Microsoft MVP.

Quem quiser conferir todas minhas contribuições utilize este link, ele também é válido para buscar MVP’s por nome, país e competência.

Para quem quiser saber mais sobre o programa:

Gostaria de agradecer a todos pelas milhares de visitas, feedbacks, agradecimentos e etc. Com certeza é esse meu maior motivador, colaborar e contribuir com o crescimento e especialização da nossa área.

Um grande abraço!

2016 – O melhor ano da minha história

O ano de 2016 foi intenso, complexo e marcante para todos os brasileiros e para a história de nosso país. Para mim 2016 foi um ano muito especial e merece uma retrospectiva.

Primeiramente agradeço a você leitor deste site! Suas visitas, feedbacks e interações tem sido a minha maior motivação para continuar escrevendo e entregando conteúdos para a comunidade técnica.
É muito satisfatório saber que por dia cerca de 3.000 pessoas acessam este site e que de alguma forma estou ajudando estes em suas carreiras, resolução de problemas e etc.

Vamos aos melhores momentos de 2016

Microsoft MVP Award

Microsoft MVP Awards

O primeiro dia do ano já inicia com uma excelente notícia! Em 2016 eu fui agraciado pela terceira vez com o prêmio Microsoft MVP. Fico muito feliz com este prêmio, é muito recompensador ter meu trabalho reconhecido globalmente e pela maior empresa de software do mundo.

ASP.NET Brasil Conference

O ASP.NET Brasil Conference é o maior evento de ASP.NET da América Latina e reuniu mais de 600 pessoas na última edição. O evento foi um sucesso e eu fico muito satisfeito, pois além de palestrar eu também sou idealizador / organizador do evento.

Para 2017 mudamos o formato e o nome, agora teremos o evento DevXperience um evento muito maior, 2 dias de evento e 6 trilhas diferentes. Temos planejado uma expectativa de 1800 participantes.

Fiquem atentos, logo mais iniciaremos as inscrições.

MVP Global Summit

Estive em Redmond na sede da Microsoft para o meu terceiro MVP Summit e como de costume foi uma experiência incrível! Conhecer, aprender e conversar com os engenheiros das tecnologias que usamos diariamente é uma oportunidade ímpar, além de tudo isso a sede da Microsoft é uma cidade de tão grande, vale muito a pena conhecer.

Eu sempre aproveito esta viagem para conversar com pessoas especiais, consegui conversar um pouco com o ScottGu – Vice Presidente Executivo e pai de diversas tecnologias que utilizamos. Aproveito também para passar um tempo com amigos que moram em diversas partes do Brasil e do mundo.

Cursos de Desenvolvimento Web e Arquitetura

2016 foi o ano que bati meu record de cursos e horas de aula.
Gostaria de dividir alguns números deste ano:

  • Cursos Realizados: 39
  • Alunos: 768
  • Cursos In Company: 10
  • Cursos Online: 29
  • Horas ministrando curso: 936

Saiba mais sobre meus cursos.

Site / Blog

Onde tudo começou, ter um site foi a minha primeira iniciativa de compartilhar meus conteúdos na comunidade técnica. Os resultados tem me surpreendido muito, recebo feedbacks fantásticos, eu mal consigo responder todos em tempo. O site aumentou em 45% o número de visitantes em relação ao ano passado.

Alguns números sobre o site:

  • Acessos: 1.365.120 mais de um milhão de visitas em 2016 \o/
  • Média diária: 3.000
  • Posts: 130
  • Horas de vídeo: 30
  • Comentários: 2.785

O que dizer sobre esse resultado? São tantas coisas, fico muito satisfeito e gostaria de dizer MUITO obrigado a todos que fizeram parte destes números.

Conquistas pessoais

Em 2016 eu consegui realizar muitos planos, alguns com mais de 10 anos de existência. Foi o ano de maiores realizações da minha vida, apesar de toda turbulência econômica deste ano para mim foi ótimo, consegui bater minhas metas e fechar o ano com chave de ouro.

Minha visão de 2016

Este foi um ano muito intenso, vivemos desde o primeiro dia do ano cenários de crises políticas, passamos por um impeachment, crises financeiras, inúmeros protestos, uma insegurança enorme, foi um ano realmente complicado para a grande maioria dos brasileiros.

Por outro lado foi um ano de grandes mudanças, estamos vendo uma nova esperança surgindo com a justiça fazendo um trabalho mais sério, desmascarando ícones da política nacional entre outros e prometendo mais estabilidade para os próximos anos com a conscientização do povo e com a derrubada de um regime de mais de 14 anos de poder.

Eu sou um eterno otimista, procuro não me afetar com os problemas da vida, acredito no sucesso do meu trabalho e uma parte deste trabalho é ajudar as demais pessoas a vencerem também, seja ensinando, aconselhando ou motivando.

O que vem pela frente?

Em 2016 eu iniciei um projeto pessoal que colocarei em funcionamento em 2017, espero ter muito sucesso nisso e em breve quero compartilhar com vocês.

Para 2017 teremos novos cursos, mais postagens e vídeos técnicos (mais do que em 2016, prometo!).

Será um ano de muito trabalho, muito foco e pretendo fazer algumas viagens para compensar tudo isso 😉

2016 foi um ano inesquecível. Muito obrigado por fazer parte dele.

Desejo a você um excelente 2017! Muito sucesso, estudos, foco e dedicação!
Grande Abraço.

 

Integrando ASP.NET Core com ASP.NET MVC 5

Migrando para o ASP.NET Core? Não é necessário migrar todo o projeto de uma única vez, utilize migrações modulares e compartilhe o Cookie de autorização de usuários.

O ASP.NET Core está pronto e muitas demandas de migração de projetos ASP.NET 4.X para a nova plataforma irão surgir. Como planejar e executar esta migração?

ASP.NET Core & ASP.NET 4.X

Uma migração total pode ser complexa, afinal vai exigir a alocação de diversas pessoas e enquanto isto as duas aplicações precisarão receber futuras implementações. Alguns projetos são tão grandes que simplesmente não seriam migrados se esta fosse a única alternativa, seria impossível atender as duas demandas simultaneamente.

Por que não ter duas aplicações?

Não há motivos para uma migração total se sua aplicação já funciona bem. Portar parcialmente módulos da aplicação para um projeto ASP.NET Core é uma alternativa bem mais interessante e que vai exigir muito menos esforço.

Imagine que em sua aplicação o módulo de gestão de Produtos funciona no ASP.NET MVC 5 e o módulo de gestão de Clientes no ASP.NET Core, o usuário final mal poderá perceber a diferença!

Integração de dados entre duas aplicações.

Certo! Posso migrar parcialmente, mas como faço a integração entre os dados que estão em aplicações diferentes?

Uma aplicação que utiliza uma boa arquitetura e uma boa modelagem estratégica pode facilmente integrar diversas entidades através dos ORM’s. Se a aplicação possuir uma modelagem DDD cada Bounded Context resolve seus próprios problemas, migre um BC de cada vez! (está mais fácil do que você imagina).

Compartilhando o usuário entre duas aplicações

Este é o grande foco da abordagem que apresento, como realizar uma integração para uma aplicação ASP.NET Core compartilhar o mesmo usuário de uma aplicação ASP.NET MVC 5.

Disponibilizei um novo repositório no meu GitHub com o projeto AspNetInterop este projeto implementa exatamente este cenário onde duas aplicações ASP.NET Core 1.1 e ASP.NET MVC 5 compartilham o mesmo Usuário, Cookies, Claims e Token para o AntiForgery.

Para reproduzir este projeto você precisa utilizar alguns Nuget Packages

Utilize o mesmo Cookie entre as aplicações

Esta abordagem faz a utilização do ASP.NET Identity, mas é possível produzir o mesmo resultado utilizando somente as classes do Microsoft.Owin.Security.

O importante é setar o mesmo cookie entre as duas aplicações:

services.AddIdentity<ApplicationUser, IdentityRole>(options =>
{
    options.Cookies = new Microsoft.AspNetCore.Identity.IdentityCookieOptions
    {
        ApplicationCookie = new CookieAuthenticationOptions
        {
            AuthenticationScheme = "Cookie",
            LoginPath = new PathString("/Account/Login/"),
            AccessDeniedPath = new PathString("/Account/Forbidden/"),
            AutomaticAuthenticate = true,
            AutomaticChallenge = true,
            CookieName = ".AspNet.SharedCookie"

            // If you have subdomains use this config:
            CookieDomain = "localhost"
        };
    })
    .AddEntityFrameworkStores<ApplicationDbContext>()
    .AddDefaultTokenProviders();

É necessário que as aplicações rodem no mesmo nome de domínio, se você tiver sub-dominios para cada aplicação basta setar a raíz do domínio em CookieDomain.

Selecione um repositório para Data Protection

O exemplo está utilizando um diretório como repositório, mas o ASP.NET Core 1.1 já suporta Redis, Azure Blob Storage e Azure Key Vault.

No ASP.NET MVC 5 além de configurar o Identity para utilizar o mesmo cookie (verifique implementação no código fonte) é necessário configurar o AntiForgery para que o usuário consiga utilizar a mesma chave entre as aplicações, para isto é necessário esta configuração no Global.asax

AntiForgeryConfig.UniqueClaimTypeIdentifier = ClaimTypes.NameIdentifier;

O AntiForgery faz a validação baseada em claims e no cookie do usuário logado.

Migre o módulo de gestão de usuários primeiro

Para utilizar este recurso é importante que esteja utilizando o ASP.NET Core com o ASP.NET Identity 3.0, portanto eu sugiro que este seja o primeiro módulo a ser migrado. A implementação deste projeto compartilha a mesma base do ASP.NET Identity entre as aplicações.

Compartilhando Cookies entre ASP.NET Core e ASP.NET MVC 5

Esta implementação foi baseada no repositório idunno.CookieSharing do qual o Scott Hanselman faz parte dos integrantes. O projeto que disponibilizo no repositório AspNetInterop é uma melhoria da implementação original, no meu projeto as melhorias implementadas foram:

  • Utilização do ASP.NET Identity ao invés do Cookie Middleware
  • Implementação de controle de acesso com base em claims para o ASP.NET Core e ASP.NET MVC 5 (cada um possui uma implementação diferente devido a forma de autorizar usuários no ASP.NET Core ter mudado)
  • Compartilhamento do Cookie no AntiForgery
  • CRUD’s de entidades em cada aplicação
  • Navegação integrada para o usuário não notar a mudança

Este projeto não conta com divisão em camadas para implementar separação de responsabilidades de Dados, Negócios e etc, porém é muito simples de implementar, pois isto não gera impacto na implementação existente.

Código fonte


Caso esteja interessado em conhecer mais sobre ASP.NET, DDD, Padrões de Arquitetura como CQRS, Event Sourcing e boas práticas de desenvolvimento não deixe de conferir as ementas dos meus cursos:

Vamos continuar a troca de experiências, deixe seu comentário abaixo. Se gostou e concorda com o artigo, compartilhe com seus colegas para transmitirmos o conhecimento para o máximo de pessoas possíveis.