Desde 1996 Java tem sido minha plataforma favorita de desenvolvimento, mas em 2019 precisei aprender .net a fundo. Sendo assim iniciei um projeto de aprendizado que gerou esta série de posts que tem como objetivo principal ajudar outros desenvolvedores Java que de repente precisem atuar na plataforma .net e não saibam por onde começar.
Você pensa em Java mas precisa lidar com código .net legado ou criar uma nova solução nesta plataforma? Esta série de posts foi escrita para você.
Nota importante: sou iniciante em .net, sendo assim posso cometer algum erro nesta série de posts, por favor me ajude me enviando as correções caso as encontre, ok? Toda ajuda é bem vinda. Publico aqui apenas as impressões que estou obtendo nesta experiência de aprendizado.
Eu, o .net e a Microsoft
O primeiro contato com .net 1.0
Meu background nos últimos dez anos (pelo menos) tem sido essencialmente Java, Linux e diversas tecnologias open source nos projetos em que atuo. Com o passar do tempo o Windows foi se mostrando uma plataforma praticamente irrelevante para mim, até por que pouquíssimos dos clientes da itexto até então tem sistemas executados nesta plataforma. Mas nem sempre foi assim…
Antes do Java se tornar a minha expertise fui um desenvolvedor Microsoft. Visual Basic 6 (comecei no 3), VBA e Delphi eram minhas principais ferramentas (lembro que na época meu sonho era viver de Java, paixão bem antiga). Eram arquiteturas muito mais simples: desktop essencialmente, usando bases de dados como Access (sim, acredite), MySQL (3) e Interbase/Firebird quando o projeto era Delphi. Se algum desenvolvimento web era feito, usava PHP ou HTML/CSS/JavaScript e não mais do que isto.
Mas nesta época senti na pele o que é ver sua plataforma de trabalho ser morta. A Microsoft havia lançado o VB.net que tornava o Visual Basic uma plataforma absolutamente obsoleta por ser incompatível com a nova versão da linguagem. Já o VBA, coitado: se mostrava cada dia mais apagado.
Me lembro que no VB.net inclusive vinha um assistente de migração de código VB 6 pro VB.net que não ajudava muita coisa: apenas te dizia educadamente que você teria de reescrever todo o seu sistema.
A coisa também não ia bem na ponta Delphi. A Borland lançou o Delphi 8 (Octane) que gerava código apenas para a plataforma .net, e esta versão simplesmente não deu certo. Aliás, deu muito errado: deu tão errado que até hoje, mesmo com o Delphi 10 Rio, que parece ser uma linda ferramenta, a esmagadora maioria dos projetos que encontramos no mercado baseados em Delphi ainda usam a versão… 7.
Então resolvi dar meus primeiros passos no C# e aprender a primeira versão do .net, a versão que tinha na época, a 1.0. Meu foco eram aplicações desktop, sendo assim aprendi logo de cara a usar com a mesma interface do tipo arrastar e soltar que estava acostumado no Delphi e VB. Lembro que não achei tão legal quanto estes, mas parecia promissor, bastante promissor inclusive. Cheguei a me empolgar e muito com o .net, aquele parecia ser o caminho e pela primeira vez o Java começava a perder o sentido pra mim, até que…
Veio o .net 1.1 que tinha uma série de incompatibilidades com a versão anterior (foi uma das razões pelas quais não houve mais versões do Delphi focadas em .net). Novamente eu teria todo um esforço de reescrita pela frente. Cansei: foi o momento no qual decidi focar meus esforços em tecnologias open source e nunca mais depender de plataformas proprietárias. Se fosse pra escrever algo, que fosse em algo que não fosse ser desligado em apenas alguns anos. Abracei Java com todas as minhas forças e o resto é história (até agora).
Escrevi algo a respeito na época que ainda faz sentido hoje, caso se interesse: Por que sabendo história Microsoft é carta fora do baralho.
O segundo contato
Meu segundo contato foi alguns anos atrás em um projeto da itexto que foi desenvolvido em .net Core, mas minha participação como desenvolvedor neste caso foi inexistente: atuei mais como arquiteto e gestor. Mas recentemente surgiu um projeto legado que precisava ser evoluído com urgência, escrito em Web Forms, Web API, C# e baseado na versão 4.6 do .NET Framework.
Era um projeto que tinha tantos problemas, tantos erros da equipe anterior, tanta porcaria escrita que não resisti. Quanto mais problemático o projeto mais atraído me sinto por ele. Além disto era a oportunidade de ouro para finalmente dominar o .net.
Aí começou minha imersão na plataforma cujas descobertas (pra mim) começo a descrever agora.
Entendendo as diferentes versões do .net
Como programador Java minha primeira dificuldade com .net foi entender como a plataforma está organizada. O que posso dizer… comparada ao Java é muito mais complicada.
Do lado Java…
Na plataforma Java, se você ignorar o desenvolvimento Android e Java ME (que quase ninguém usa hoje) há essencialmente uma plataforma base que é o Java SE (Standard Edition) que é a base sobre a qual construiu-se a plataforma Java EE (Enterprise Edition), que é o que usamos até agora para criar aplicações web e corporativas. Java SE e EE, simples assim.
Atualmente estamos na versão 13 do Java SE, mas temos completa compatibilidade com as versões anteriores. Dado que ainda hoje a maior parte das pessoas ainda usa o Java 8, podemos inclusive dizer que este é o “Delphi 7” da JVM.
Então do lado Java temos essencialmente o Java SE que usamos pra aplicações desktop, linha de comando, bibliotecas e Java EE pra aplicações web: simples e direto. Não há muito como errar, certo? Errado: você pode se perder entre os inúmeros frameworks disponíveis pra plataforma, mas esta é a história para outro post.
E na base, claro, você tem a JVM, que é a responsável por interpretar o bytecode Java, que é essencialmente a mesma tanto para aplicações Java SE quanto EE. Três atores apenas.
Do lado .net…
A coisa começa a se mostrar um pouco mais complicada. Pra começar, você agora tem duas versões do .net que são oficialmente suportadas pela Microsoft:
- .net Framework
- .net Core
- (outros que citarei mais a frente, mas os que mais recebem publicidade são estes dois)
O primeiro (.net Framework) é o original, aquele que nasce na versão 1.0 que me afastou da plataforma. Atualmente está na sua versão 4.8 e, ao que tudo indica, será sua última versão. É feito para executar apenas no Windows.
O segundo (.net Core) apareceu em 2016 (trabalhamos com a primeira versão dele), e tem como principal diferença o fato de ser realmente multi plataforma: seu código pode ser executado no Windows, Linux e macOS.
.net Framework
Mas espera que a coisa fica ainda mais complicada quando pegamos para analisar o .net Framework. Isto por que com o tempo a Microsoft foi criando diferentes versões deste:
- .net para Windows Desktop – usado para aplicações desktop no Windows.
- .net para Windows Store – para que você escreva aplicações que vão para Windows Store (plataforma UWP).
- .net pra Windows Phone – que morreu :(
- ASP.net 4 – pra desenvolvimento web
- ASP.net 5 – que apesar do nome é OUTRA plataforma e acabou se tornando o ASP.net Core 1.0
- Silverlight – que era uma alternativa aos antigos applets e Flash, que também morreu
- .net Micro framework
E cada uma destas implementações do .net tem três componentes: o runtime de execução (equivalente à JVM), um modelo de aplicação a ser desenvolvido e o framework que contém as APIs essenciais. Na prática você tem uma situação similar à apresentada no diagrama a seguir, extraído deste excelente post que me ajudou muito:
O que vemos são na prática diferentes verticais do .net Framework, uma para cada tipo de aplicação que você deseje criar. A coisa fica ainda mais complicada pra nós, desenvolvedores Java, quando eu for falar sobre ASP.net (que também tem duas versões, o Core e o original (os nomes são péssimos!), mas isto em um post futuro).
Importante: .net Framework está com seus dias contados. Isto ficou nítido no projeto legado em que estou atuando: se você acessar o site oficial da plataforma .net verá que todo o foco hoje está voltado ao .net Core. Repare no que marquei no print a seguir, extraído deste site:
O .net Framework não é open source e é apenas Windows. Ao navegar pela documentação oficial você enfrentará as mesmas dificuldades que eu: atualmente todo o foco está voltado apenas para a versão Core da plataforma.
Como mencionei anteriormente, o último release do .net Framework será o 4.8. Após esta versão este lado do desenvolvimento será considerado como uma plataforma legada, que continuará recebendo atualizações no decorrer dos anos (eles ainda mantém o runtime do VB6, sabia?), mas não deve receber novos desenvolvimentos.
Em paralelo estão lançando o .net Core 3.0, que receberá novos recursos e tudo mais, mas aí não terá o .net Core 4.0, terá o .net Core 5, que finalmente unificará as plataformas, o que é ótimo. Este excelente post detalha a “morte” do .net Framework muito melhor que eu, recomendo sua leitura.
Qual ferramenta usar: não há muito pra onde correr, você precisará usar o Visual Studio tradicional para programar nesta plataforma e no Windows apenas. As tentativas que fiz com outras alternativas, como o Visual Studio Code se mostraram no mínimo “infrutíferas”.
.net Core
Se você vai começar um novo projeto este é sem sombra de dúvidas o caminho a ser trilhado: seus projetos poderão executar no Linux (o que lhe economizará uma fortuna) e é nitidamente aonde a Microsoft irá investir no médio e longo prazo quando o assunto for plataforma .net.
Minha experiência com .net Core até este momento é bastante limitada, mas pelo que pude acompanhar, acaba de ser lançada a versão 3.0 e não estão ocorrendo problemas de compatibilidade tal como o que enfrentei com a versão 1.0 do .net Framework.
É importante que você tenha em mente os objetivos da Microsoft aqui:
- Acabar com a zona que é esta quantidade exagerada de versões da plataforma: o objetivo é termos apenas uma daqui pra frente.
- Termos um ambiente realmente multi plataforma: bem na direção do Java e, na minha opinião, até mais simples de ser entendido pelo usuário final, por que gera executáveis e DLLs ao invés de arquivos JAR que nem sempre são de fácil compreensão por este público (aliás, faz alguma diferença isto hoje em um mundo que é essencialmente web? Algo a se pensar)
- Ser uma plataforma realmente open source, ao contrário do que temos até então.
Se a comunidade for tão boa quanto à que temos no Java, vejo um longo futuro para esta plataforma sem sombra de dúvidas, por que pelo pouco que estou vendo até agora é realmente muito produtiva: dá claramente a impressão de que quem a projetou gosta de programadores.
Aqui há uma quantidade maior de ferramentas para se trabalhar: o .net Core vêm com uma ferramenta de linha de comando que gera nossos projetos bem no formato scaffolding, e também já cuida de todo o processo de compilação, execução e depuração. Então você pode usar seu editor favorito se quiser: no .net core tenho usado o VS Code por que estou essencialmente no Linux.
É muito interessante você observar o suporte ao .net Core no Visual Studio 2019: claramente este é o cidadão de primeira classe e o .net Framework já se mostra em segundo, terceiro, quarto plano. Os templates apresentados por padrão são quase que todos essencialmente .net Core.
Resumo de uso: .net Framework ou .net Core
- Seu projeto é legado e feito em .net Framework? Comece a pensar em estratégias para migrar para o .net Core (não é algo tão fácil assim, escrevo mais sobre isto no futuro).
- É um projeto novo? Vai de .net Core que o futuro está garantido (ao menos por agora, sempre tenho uns dois pés atrás quando o assunto é Microsoft. De novo aquele meu post antigo).
- Sua equipe sabe ASP.net (o do .net Framework) apenas? Vai ser .net Framework.
- Sua equipe quer atuar com ASP.net Core? .net Core (lógico)
- Seu projeto é só Windows e é novo? Pra que pensar em .net Framework se ele vai pro saco?
Mono
Além do .net Framework e do .net Core existe uma outra implementação da plataforma .net que é o projeto Mono, criado por Miguel de Icaza que depois juntou-se à Microsoft quando esta comprou sua empresa, a Xamarin.
Quando o .net Framework foi lançado, junto a este foi também publicado um padrão ECMA que definia como a linguagem C# deveria ser implementada, assim como a plataforma como um todo. O mono foi um projeto iniciado por Miguel de Icaza com o auxílio da comunidade que criou uma implementação totalmente aberta e livre da plataforma .net focando inicialmente o Linux.
Você tem inclusive uma IDE bastante competente pra poder trabalhar com esta plataforma que é o MonoDevelop.
A questão que ainda não sei responder hoje é se o Mono, com o lançamento do .net Core ainda é relevante. Creio que não, por que faz muito mais sentido do ponto de vista de investimento focar na versão mantida pela mãe da plataforma, que é a Microsoft.
Xamarin
Lembra da empresa do Miguel de Icaza? Pois é: ela desenvolvia um produto chamado Xamarin, usado para o desenvolvimento de aplicações mobile para Windows Phone (ainda sinto saudades), iOS e Android. Existe hoje uma quarta versão do .net que tem justamente este nome é desenvolvimento de aplicações móveis para iOS e Android (até a Microsoft desistiu do Windows Phone).
O Xamarin é uma extensão do .net na realidade, e infelizmente, hoje, só pode ser executado no Windows e macOS. Também é open source e, pelo que pude entender até agora, meio que baseado no Mono, razão pela qual no site da Microsoft, no link “What is .net” este é apresentado como tal.
.net Standard: o “Java SE” da Microsoft?
Pense no .net Standard como a tentativa da Microsoft em criar seu próprio “Java SE” que seria a implementação das APIs essenciais compartilhadas pelo .net Framework, .net Core, Xamarin, Mono e outras implemetnações.
É a especificação formal de APIs .NET que deve estar presente em todas as implementações da plataforma .NET. Sendo assim, se futuramente surgir algo como um segundo projeto Mono este, para ser compatível (e ser chamado de plataforma .NET) deve possuir estas APIs implementadas de alguma forma.
Atualmente o .net Standard está na versão 2.1, mas desde o lançamento da versão 4.5 do .net Framework, da versão 1.0 do .net Core e 4.6 do Mono é usado como base. Essencialmente, se sua aplicação usa as APIs presentes no .net Standard, é altíssima a possibilidade de que você consiga porta-lo para diferentes implementações do .net sem grandes problemas.
Na documentação oficial do .net Standard você consegue ver as diferentes implementações do .net (mais menções honrosas: Unity, Xamarin.IOS, Xamarin.Android, Plataforma Universal do Windows).
Fica a cargo do desenvolvedor escolher qual versão do .net Standard focar: lembre-se que quanto menos recente for a versão, maior será o número de plataformas que estarão disponíveis, enquanto que os novos recursos estarão sempre nos últimos releases.
Concluindo, recursos e posts futuros
Resumi aqui as principais implementações do .net. Para um javeiro como eu minha primeira dificuldade foi entender estas diferentes versões para que pudesse focar o meu estudo. Mesmo assim meu foco é um pouco difuso:
- .net Framework para lidar com projetos legados.
- .net Core para novos projetos (foco em APIs e micro serviços) e migração de projetos baseados em .net Framework.
Nos dois casos meu foco é o desenvolvimento de aplicações web, ou seja, vão vir posts aqui sobre ASP.net e ASP.net Core. Se você achou confusa a situação do .NET no que diz respeito às suas diferentes versões, aguarde o que vou te contar sobre o ASP.net e ASP.net Core!
Os nomes não ajudam: geram muita confusão para quem está chegando. A própria documentação se você não ficar muito atento pode te confundir. Não raro me vi lendo sobre .net Core quando meu objetivo era o .net Framework e vice-versa, e esta foi uma das motivações que me levou a iniciar esta série de posts.
Alguns links para aprofundamento
- .net Core Complete Overview – Foi o primeiro post que me ajudou a entender as diferentes versões do .net – https://www.instinctools.com/blog/net-core-framework-complete-review
- Glossário .NET – fundamental para entender os termos usados na documentação da Microsoft –
https://docs.microsoft.com/pt-br/dotnet/standard/glossary - Visão Geral do .NET Framework – fornece uma visão arquitetural macro inicial que me ajudou bastante a entender a plataforma –
https://docs.microsoft.com/pt-br/dotnet/framework/get-started/overview - Application Essentials – leia todos os links, eles te fornecerão a base para entender diversos conceitos que me ajudaram MUITO a entender a linguagem C# –
https://docs.microsoft.com/pt-br/dotnet/standard/application-essentials - Sobre o fim do .NET framework, dois posts que me ajudaram a entender a situação e evitar o FUD: Este aqui da Telerik –
https://www.telerik.com/blogs/dotnet-is-dead-long-live-dotnet e este aqui
https://www.iowacomputergurus.com/insights/article/microsoft-announces-end-of-net-framework-net-core-meet-net-5
No geral me maravilhou como são bem escritos os textos presentes no site da Microsoft. Passei e passo horas lendo cada um dos links como se fosse um romance do qual tiro minhas notas: foram uma grata surpresa. Recomendo que você leia os textos em inglês, por que as traduções nem sempre são muito boas, a impressão que tenho é que são geradas automaticamente em alguns pontos.
Sobre cursos online: quase não encontrei cursos sobre o .net Framework online, idem no que diz respeito a livros. É como se a partir de 2016 as pessoas só escrevessem sobre .net Core. A situação fica ainda mais tensa quando o assunto é ASP.net: mas não fique triste, já trilhei este caminho e vou te mostrar no futuro estes links que irão lhe ajudar muito.
Próximos posts
Acredito que pra entender BEM mesmo o desenvolvimento de aplicações web primeiro preciso conhecer a plataforma na qual estas são executadas. Sendo assim meus próximos posts vão cobrir os seguintes tópicos:
- Minhas impressões sobre como é desenvolver em .NET sendo um desenvolvedor Java (muitos preconceitos estão sendo desfeitos nesta experiência).
- A arquitetura da plataforma .NET (aqui só vimos as diferentes implementações apenas)
- Os conceitos que mais me impressionaram (até agora o que mais me impressionou foi o de assembly, devo escrever muito a respeito).
- Como é organizado tanto o ASP.net (.net Framework) quanto o Asp.net Core (.net Core) – uma zona o negócio
- Estratégias de migração.
- Um ou outro detalhe que tenha me impressionado.
Espero que tenham gostado deste post: lembrem que sou um iniciante ainda (e com uma visão muito enviesada pelo Java), sendo assim erros podem ser cometidos. Caso os encontre, por favor, inclua-os nos comentários pra que eu possa realizar as correções, ok? Valeu!