Com o lançamento do novo Visual Studio 2017 e as novas opções da plataforma .Net disponíveis, os termos .Net Core, .Net Framework, e .Net Standard ficaram meio confusos.

Recentemente li um artigo interessante que me ajudou a entender a diferença entre esses termos e gostaria de escrever sobre o assunto.

.Net Core

O .Net Core é a novidade no mundo .Net. Sua característica mais importante é ser cross-plataform, isto é, ser suportado em diferentes plataformas. Ele suporta o desenvolvimento de software para Windows, Linux e MacOS.

O .Net Core não possui alguns dos recursos mais comuns do .Net Framework, portanto, ele dificilmente poderá ser aplicado em ambientes legados ou ambientes desenvolvidos anteriormente ao seu lançamento.

Seu uso deve ser encarado principalmente em novos desenvolvimentos.

E o .Net Standard / netstandard?

O nome .Net Standard é referente as bibliotecas do .Net. Elas garantem uma sintonia maior do .Net Core com o .Net Framework e o Mono.

.Net Standard também é o nome do build target (usado como “netstandard”) de aplicações .Net.

A Microsoft padronizou as APIs de runtime da plataforma .NET para possibilitar que um código seja compatível com diferentes runtimes.

Nem todas as classes existentes foram padronizadas para esse suporte e é aí que entra o .Net Standard para definir quais APIs funcionam entre as diversas implementações do .Net.

Um ponto importante é que o .Net Standard é suportado em diferentes níveis dependendo da versão utilizada. Se você está desenvolvendo um código para funcionar em diferentes versões do .Net, você terá que usar uma versão da biblioteca .Net Standard que seja comum nos targets desejados.

Por exemplo, o .Net Standard 1.2 suporta: .Net Framework 4.5.1, Windows e Windows Phone 8.1. Mas, se você também quiser que o código funcione no Windows 8.0, será necessário utilizar o .Net Standard 1.1 que usa o .Net Framework 4.5. Com isso, o código pode perder algumas features presentes na versão mais avançada do .Net Framework.

A documentação oficial da Microsoft possui uma tabela mostrando as versões do .Net Standard e sua correspondência com outras implementações da plataforma.

O importante disso tudo é tomar cuidado para informar o target correto do .Net Standard que será utilizado.

 

 

Nesse post vou explicar como criar um projeto novo com .NET Core usando apenas alguns comandos e o Visual Studio Code.

O .NET Core é uma plataforma de desenvolvimento mantida pela Microsoft e pela comunidade .NET. Ela é suportada no Windows, no macOS e no Linux.

O passo inicial é acessar o site da Microsoft e seguir o guia que ensina como instalar o .NET Core. Basta clicar aqui e seguir os passos.

Também vamos precisar usar o Visual Studio Code. Assim como o .NET Core, ele também possui versões para Windows, macOS e Linux. Basta clicar aqui e seguir com a instalação no seu sistema operacional.

Para iniciar, você deve criar uma pasta para o projeto. Neste caso, foi criada a pasta DotNetCoreConsoleSample. Você pode fazer isso manualmente ou direto pela linha de comando.

Agora, usando a linha de comando no seu sistema operacional, vá até o diretório do projeto e use o comando dotnet new. A resposta deve ser uma mensagem semelhante a essa: Created new C# project in DotNetCoreConsoleSample.

O comando dotnet new pode ser usado juntamente com a opção -t acompanhada do tipo do projeto, podendo ser um console, web, lib ou xunittest. Por exemplo, o comando dotnet new -t web, cria um projeto web. Na documentação oficial temos todas as opções disponíveis para esse comando.

O próximo passo é usar o comando dotnet restore. Esse comando chama o NuGet e restaura os pacotes que estão informados no atributo dependences dentro do arquivo project.json. Ele também cria o project.lock.json. Uma explicação bem detalhada sobre o comando pode ser encontrada aqui.

Ao abrir a pasta do projeto com o Visual Studio Code você deverá ver algo como a imagem abaixo.

Ao abrir o arquivo project.json temos a seguinte configuração:

{
  "version": "1.0.0-*",
  "buildOptions": {
    "debugType": "portable",
    "emitEntryPoint": true
  },
  "dependencies": {},
  "frameworks": {
    "netcoreapp1.0": {
      "dependencies": {
        "Microsoft.NETCore.App": {
          "type": "platform",
          "version": "1.0.1"
        }
      },
      "imports": "dnxcore50"
    }
  }
}

Cada um desses atributos significa uma especificação para o projeto.

• version: é a versão do projeto. Se o projeto fosse uma lib, ele poderia representar a versão do pacote NuGet a ser gerado.
• buildOptions: controla as especificações de compilação do projeto.
• debugTipe: indica o tipo de arquivo .PDB (arquivo que contém as informações para o debugger funcionar corretamente) a ser gerado. É usada a opção portable para projetos .NET Core.
• emitEntryPoint: é um boolean que informa se a compilação deve criar um executável (.exe).
• dependences: é aqui que colocamos os pacotes a serem usados no projeto.
• frameworks: informa o framework do projeto.

Na documentação oficial tem um artigo que explica todas as opções existentes e suportadas no project.json.

Ao abrir o arquivo Program.cs temos o código que exibe um Hello World.

using System;

namespace ConsoleApplication
{
    public class Program
    {
        public static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
        }
    }
}

Por fim, é só usar o comando dotnet run para executar a aplicação. Esse comando chama o dotnet build e logo após já executa a aplicação.

O resultado deve ser algo como a imagem abaixo:

O código completo do projeto está no GitHub, basta clicar aqui para vê-lo.

Se quiserem conhecer mais sobre mim, basta ir aqui no blog no menu quem sou e conferir também o meu LinkedIn.

Se ficou alguma dúvida, comenta aqui no blog que eu tento ajudar. 🙂