Global Tools no .NET Core 2.1

Neste artigo vou falar sobre as Global Tools, que é um recurso adicionado na versão 2.1 do .NET Core.

Uma global tool é um pacote “especial” do NuGet que contém uma aplicação console. Quando esta aplicação é instalada como uma ferramenta, o .NET Core CLI irá baixar o seu arquivo, extrair no disco e disponibilizá-la como um comando de terminal.

Nos bastidores, o .NET Core CLI está apenas adicionando o caminho da aplicação na variável de ambiente PATH do sistema. E por ser executada pelo terminal, que este recurso só é valido para as aplicações console.

Aqui não existe limitação do que a aplicação pode implementar. Ou seja: caso a aplicação console esteja executando corretamente, ela pode ser convertida para uma “global tool”.

Para entender isso na prática, vamos criar uma aplicação simples de renomeação de arquivos.

Curso C# (C Sharp) Básico

Conhecer o curso

Ambiente

Antes de colocarmos a mão na massa, é importante que a versão 2.1 (ou superior) do .NET Core esteja instalada na máquina.

Para este artigo, estou utilizando a versão 2.1.4 do .NET Core, em uma máquina Mac OS X.

Colocando a mão na massa

Como dito, uma global tool é criada a partir de uma aplicação console, assim, a primeira coisa que deve ser feita é criar esta aplicação:

dotnet new console -n RenomearArquivos

Em seguida o seu código deve ser definido. No nosso exemplo, ele será:

class Program
{
    static void Main(string[] args)
    {
        if(args.Count() == 0)
            Console.WriteLine("Nenhuma opção foi informada! Indique o diretório (-d), filtro (-t) e prefixo (-n)");
        else
        {
            var diretorio = String.Empty;
            var filtro = "*";
            var prefixo = String.Empty;

            for(var i = 0; i < args.Count(); i++)
            {
                switch (args[i].ToLower())
                {
                    case "-d":
                        diretorio = args[++i];
                        break;
                    case "-t":
                        filtro = args[++i];
                        break;
                    case "-n":
                        prefixo = args[++i];
                        break;
                    default:
                        Console.WriteLine($"Opção {args[i]} inválida!");
                        Environment.Exit(1);
                        break;
                }
            }

            Renomear(diretorio, filtro, prefixo);
        }

    }

static void Renomear(string diretorio, string filtro, string prefixo){

        Console.WriteLine("Arquivos renomeados:");
        foreach(var arq in Directory.GetFiles(diretorio, filtro))
        {
            var novoArquivo = Path.Combine(Path.GetDirectoryName(arq), String.Format("{0} - {1}", prefixo, Path.GetFileName(arq)));
            File.Move(arq, novoArquivo);
            Console.WriteLine(novoArquivo);
        }
    } 
} 

Como é possível notar, esta aplicação é bem simples.

Ao executá-la, veremos o seguinte resultado:

Mas como disse, qualquer aplicação console pode ser transformada em uma global tool. Infelizmente, ainda não há uma página que organize todas as global tools disponíveis, mas aqui contém ótimos exemplos de ferramentas criadas pela equipe do ASP.NET Core.

Empacotando a aplicação

Para disponibilizar a nossa aplicação como uma global tool precisamos empacotá-la em um pacote NuGet. Para isso, temos de adicionar algumas informações no arquivo de configuração do projeto (*.csproj):

<PropertyGroup>
  <OutputType>Exe</OutputType>
  <TargetFramework>netcoreapp2.1</TargetFramework>
  <PackAsTool>true</PackAsTool>
  <ToolCommandName>renarquivos</ToolCommandName>
  <Version>1.0.0</Version>
  <Description>A example of a tool for the Treinaweb Blog</Description>
</PropertyGroup>

Onde:

• PackAsTool: Indica que a aplicação deve ser empacotada como uma global tool;
• ToolCommandName: Indica o comando utilizado para invocar a aplicação. Caso isso não seja especificado, será utilizado o nome da aplicação;
• Version: A versão da aplicação;
• Description: Descrição da ferramenta.

E, deve ser criado na raiz da aplicação um arquivo chamado .nuspec onde deve ser adicionado a informação abaixo:

<?xml version="1.0" encoding="utf-8"?>
<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
  <metadata>
    <!-- Esta parte é obrigatória -->
    <packageTypes>
      <packageType name="DotnetTool" />
    </packageTypes>
    <!-- ... -->
  </metadata>
</package>

Ela indica que o pacote a será criado deve ser tratado como uma global tool. Sem esta informação, o pacote até pode ser criado, mas não seria possível instalá-lo como uma global tool.

Com essas informações definidas, a aplicação pode ser empacotada com o comando abaixo:

dotnet pack . -c Release -o nupkg

Este comando irá compilar a aplicação para “release”, e irá gerar o arquivo de pacote dela na pasta nupkg. Para testar a ferramenta, acesse a pasta nupkg e execute o comando abaixo:

dotnet new nugetconfig

Este comando irá gerar um arquivo de configuração do NetGet (nuget.config) onde deve ser informando o caminho do arquivo NuGet que acabamos de gerar:

<?xml version="1.0" encoding="utf-8"?>
<configuration>
 <packageSources>
    <add key="local" value="." />
 </packageSources>
</configuration>

Desta forma, sempre que o comando de edição de pacotes for executado no nível desta pasta, ele também irá procurar por pacotes contidos nela.

Instalado a Global Tool

Por fim, para instalar a global tool que acabamos de definir, basta executar no nível da sua pasta, o comando abaixo:

dotnet tool install -g RenomearArquivos

Após isso, a nossa global tool estará disponível como comando no terminal:

Simples não, é? O código desta aplicação está disponível aqui.

Em artigos futuros falarei de outros recursos da versão 2.1 do .NET Core. Até lá!

Curso C# - Fundamentos

Conhecer o curso