Mês: dezembro 2016

Compilando uma aplicação .NET Core em um runtime específico

Neste post vou explicar como fazer para o .NET Core compilar uma aplicação em um runtime específico detalhando os runtimes desejados no project.json.

Em um post anterior (Criando um projeto .NET Core usando a linha de comando e o Visual Studio Code) eu expliquei como criar uma aplicação simples. Vou usar esse mesmo projeto neste post.

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"
    }
  }
}

Para uma aplicação .NET Core em um runtime específico devemos remover o atributo “type”: “platform” das dependences dentro das especificações dos frameworks, neste caso, netcoreapp1.0.

Nesse projeto só é preciso fazer isso na dependência Microsoft.NETCore.App. O atributo vai ficar como o código abaixo.

        "Microsoft.NETCore.App": {
          "version": "1.0.1"
        }

O próximo passo é adicionar o atributo runtimes ao arquivo project.json. O atributo runtimes define para quais runtimes o projeto deve ser compilado. A documentação oficial possui uma lista de runtimes disponíveis através da explicação do .NET Core Runtime IDentifier (RID).

Neste caso, vou usar o Windows 10. Para isso é preciso informar no arquivo project.json o identificador do runtime desejado como win10-x64.

Por fim, o arquivo project.json vai ficar da seguinte maneira:

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

Agora, ao usar o comando dotnet restore seguido do dotnet build a compilação gerada será especificamente para Windows 10 e estará no caminho \bin\Debug\netcoreapp1.0\win10-x64.

Quando o projeto é compilado para um runtime específico ele possibilita usar o comando dotnet publish. Ele copia o executável, as DLLs e o framework para um diretório publish dentro do diretório do runtime especificado. Neste caso, \bin\Debug\netcoreapp1.0\win10-x64\publish.

É possível notar que agora, dentro do diretório publish, temos o nosso executável e todas as DLLs necessárias, inclusive as do .NET Core, como mostra a imagem abaixo:

Captura de Tela 2016-12-07 às 22.53.36.png

Com isso feito, é possível executar a aplicação em qualquer computador com Windows 10, mesmo que ele não tenha o .NET Core instalado.

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. 🙂

 

Criando um projeto .NET Core usando a linha de comando e o Visual Studio Code

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.

dotnetnew

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:

dotnetrun

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. 🙂