Resumo
Será possível criar uma aplicação dotnet WebApi utilizando apenas Linux e o VSCode? Esse artigo tem como objeto criar uma WebAPI utilizando apenas Linux, DotNetCore e VSCode.
Apesar de mais trabalhoso, você adquirirá conhecimentos significativos.
Introdução
Desde o lançamento do DotNetCore e VSCode pela Microsoft, que inclusive abalaram o mundo da tecnologia, venho me perguntando, será que é possível criar uma aplicação dotnet utilizando apenas Linux e o VSCode? Esse artigo tem como objeto criar uma WebAPI utilizando apenas Linux, DotNetCore e VSCode. Eu que utilizo Linux em meus desktops desde meados de 2002, e que tenho nos últimos 7 anos desenvolvendo na tecnologia .NET precisava tirar a prova. Então vamos lá.
Criando os projetos
Para criação da WEBAPI iremos utilizar uma arquitetura bem simples, dividindo em 3 Camadas (Negócio/Dados/Model). Antes de criarmos nosso primeiro projeto, vou ensinar alguns comandos, para quem está familiarizado com Linux é quase que um feijão com arroz, porém para os usuários de Windows que não estão tão acostumados com linha de comando, podem estranhar no começo.
O primeiro comando é dotnet –help, irá exibir todas as opções que temos dentro do programa dotnet, conforme ilustra a imagem1. Atenção para a opção “new”, ela será muito utilizada.
Imagem1 – Opções programa dotnet
Agora utilizaremos o comando dotnet new –help, listando assim as do comando new,
conforme ilustra a imagem2. Duas considerações importantes, utilizaremos a opção dotnet
new webapi, onde será criada uma nova webapi. Para definirmos um nome para essa
webapi precisamos adicionar o comando -n, ou seja, dotnet new webapi -n
ProjetoVSCodeLinux. Caso utilize apenas dotnet new webapi, será criada uma WebApi com
o nome do diretório corrente.
Imagem2 – Opções programa dotnet new
Após as explicações acima, vamos criar nosso projeto, utilize o comando:
dotnet new webapi -n ProjetoVSCodeLinux
O resultado, deve ser algo parecido com a imagem3:
Imagem3 – Criação WebAPI
Após criado o Projeto, seguiremos criando os projetos “Class Library”, que chamaremos de VSCodeLinuxBLL, VSCodeLinuxDAL e VSCodeLinuxModel. Para isso execute os comandos abaixo:
dotnet new classlib -n VSCodeLinuxBLL
dotnet new classlib -n VSCodeLinuxDAL
dotnet new classlib -n VSCodeLinuxModel
Os resultados deverão ser algo parecido com as imagens 4, 5 e 6:
Imagem 4 – Criação Projeto ClassLib VSCodeLinuxBLL
Imagem 5 – Criação Projeto ClassLib VSCodeLinuxDAL
Imagem 6 – Criação Projeto ClassLib VSCodeLinuxModel
Todos os nosso projetos estarão criados e ao executar o comando “ls”, devemos ter algo do tipo, conforme ilustra a imagem7:
Imagem7 – Lista de Projetos Criados
Criando a Solutions
Acredito que muitos desenvolvedores .Net estão se perguntando, ok, criei os projetos, mas como criar a Solution? Para quem não é desenvolvedor .Net vou explicar rapidamente o conceito de solution. No Visual Studio, é possível vincularmos um ou mais projetos, dentro de uma única “Solução”, que em miúdos quer dizer, quando eu abrir o arquivo “Solution” ele carrega todos os projetos que estou utilizando para criar aquela “Solução”.
Sim, conseguimos fazer isso via linha de comando. Para isso execute o comando abaixo:
dotnet new sln
O resultado, deve ser algo parecido com a imagem8:
Imagem8 – Criação da Solutions
Observe que não utilizamos o parâmetro “-n”, o que significa que será criado um arquivo sln com o nome do diretório ProjetoVSCodeLinux. Após a criação da solution, teremos algo parecido com a imagem9:
Imagem9 – Projetos criados
Agora precisamos vincular os projetos a solution, para isso utilize o comando abaixo:
dotnet sln add ProjetoVSCodeLinux/ProjetoVSCodeLinux.csproj
O resultado deve ser algo parecido com a imagem10:
Imagem10 – Adicionando projeto a solution
Agora vamos adicionar os demais projetos:
dotnet sln add VSCodeLinuxBLL/VSCodeLinuxBLL.csproj
dotnet sln add VSCodeLinuxModel/VSCodeLinuxModel.csproj
dotnet sln add VSCodeLinuxDAL/VSCodeLinuxDAL.csproj
Para ter certeza que foram adicionados com sucesso, abra o arquivo ProjetoVSCodeLinux.sln com um editor de texto qualquer, no meu caso, estou utilizando Debian 10 com LXDE, então utilizei o editor “Mousepad”. Teremos algo conforme ilustra a imagem11:
Imagem 11 – Verificação de projetos vinculados a solution
Agora que já criamos nossos projetos e vinculamos a nossa solution, bora “codar”.
Banco de Dados
Para o nosso exemplo utilizaremos o banco de dados Mysql. Não é objetivo deste artigo explicar como configurar o banco de dados, porém abaixo segue o script para criação da tabela “setor”, a qual será utilizada como base para nosso exemplo
-- CREATE TABLE "setor" ----------------------------------------
CREATE TABLE `setor` (
`codigo` BIGINT( 20 ) UNSIGNED AUTO_INCREMENT NOT NULL,
`setor` VARCHAR( 45 ) CHARACTER SET latin1 COLLATE latin1_swedish_ci NULL,
`status` TINYINT( 3 ) UNSIGNED NULL DEFAULT 1,
`cadastro` BIGINT( 20 ) UNSIGNED NULL,
`dataCadastro` DATETIME NULL
PRIMARY KEY ( `codigo` ) )
CHARACTER SET = latin1
COLLATE = latin1_swedish_ci
ENGINE = INNODB
AUTO_INCREMENT = 225;
-- -------------------------------------------------------------
Talk is cheap. Show me the code
Após toda a configuração da nossa aplicação, vamos aos códigos. O primeiro passo é abrir o VSCode, e abrir o diretório com o projeto. Para isso clique em File → Open Folder, conforme ilustra a imagem12 abaixo:
Imagem 12 – VSCode selecionando diretório
Selecione o diretório onde se encontra o arquivo sln (Solution), aparecerá a solutions e os diretórios dos projetos que criamos acima, conforme ilustra a imagem13:
Imagem13 – Projeto aberto no VSCode
O primeiro projeto que será alterado “VSCodeLinuxModel”, primeiramente renomearemos o arquivo Class1.cs para SetorModel.cs, depois criaremos os atributos com os mesmos nomes das colunas da tabela “setor”, conforme ilustra a imagem14 e código abaixo:
Imagem14 – nome model SetorModel
SetorModel.cs
using System;
namespace VSCodeLinuxModel
{
public class SetorModel
{
public Int64 Codigo { get; set; }
public string Setor { get; set; }
public int Status { get; set; }
public Int64 Cadastro { get; set; }
public DateTime DataCadastro { get; set; }
}
}
Agora mexeremos no Projeto DAL, responsável por acessar o banco de dados. Novamente será necessário alterar o nome do arquivo para SetorRepository.cs. Nesse projeto também precisaremos adicionar uma referência de projeto e dois pacotes Nugets. Primeiramente adicionaremos a referência do projeto Model ao projeto DAL, conforme comando abaixo:
dotnet add VSCodeLinuxDAL/VSCodeLinuxDAL.csproj reference VSCodeLinuxModel/VSCodeLinuxModel.csproj
Agora adicionaremos os dois pacotes, um para conexão com o Mysql e o segundo o pacote para utilização do Dapper. Uma dica, é possível verificar o pacote correto e até o comando no site https://www.nuget.org/ .
dotnet add VSCodeLinuxDAL/VSCodeLinuxDAL.csproj package MySql.Data
dotnet add VSCodeLinuxDAL/VSCodeLinuxDAL.csproj package Dapper
Como utilizaremos injeção de dependência, será necessário criar um novo arquivo de Interface, eu criei chamado ISetorRepository.cs
ISetorRepository.cs
using System.Collections.Generic;
using VSCodeLinuxModel;
namespace ServerLessDAL
{
public interface ISetorRepository
{
List<SetorModel> RetornarSetoresAtivos();
}
}
SetorRepository.cs
using System;
using System.Collections.Generic;
using System.Linq;
using Dapper;
using MySql.Data.MySqlClient;
using VSCodeLinuxModel;
namespace ServerLessDAL
{
public class SetorRepository:ISetorRepository
{
public List<SetorModel> RetornarSetoresAtivos(){
string strConexao = "Persist Security Info=False;server=179.188.16.18;database=clienteocultoa;uid=clienteocultoa;pwd=clientepass";
string sql = "select * from setor where status = 1";
List<SetorModel> lstRet = null;
using (MySqlConnection conexao = new MySqlConnection(strConexao))
{
lstRet = conexao.Query<SetorModel>(sql).ToList();
}
return lstRet;
}
}
}
Agora adicionaremos os Projetos VSCodeLinuxDAL e VSCodeLinuxModel.csproj ao projeto VSCodeLinuxBLL, conforme comando abaixo:
dotnet add VSCodeLinuxBLL/VSCodeLinuxBLL.csproj reference VSCodeLinuxDAL/VSCodeLinuxDAL.csproj
dotnet add VSCodeLinuxBLL/VSCodeLinuxBLL.csproj reference VSCodeLinuxModel/VSCodeLinuxModel.csproj
Criamos o arquivo interface ISetorBLL.cs, abaixo os códigos dos arquivos SetorBLL.cs e ISetorBLL.cs
ISetorBLL.cs
using System;
using System.Collections.Generic;
using VSCodeLinuxModel;
namespace VSCodeLinuxBLL
{
public interface ISetorBLL
{
List<SetorModel> RetornarSetoresAtivos();
}
}
SetorBLL.cs
using System;
using System.Collections.Generic;
using ServerLessDAL;
using VSCodeLinuxModel;
namespace VSCodeLinuxBLL
{
public class SetorBLL:ISetorBLL
{
private ISetorRepository iSetorDAL;
public SetorBLL(ISetorRepository iSetorDAL){
this.iSetorDAL = iSetorDAL;
}
public List<SetorModel> RetornarSetoresAtivos(){
return iSetorDAL.RetornarSetoresAtivos();
}
}
}
Agora precisaremos adicionar todos os nossos projetos ao “projeto principal”, isso se faz necessário, pois como utilizaremos “injeção”, precisamos mapear no arquivo “Startup”, o qual fica no projeto “ProjetoVSCodeLinux”. Abaixo os comandos para adicionarmos os projetos
dotnet add ProjetoVSCodeLinux/ProjetoVSCodeLinux.csproj reference VSCodeLinuxModel/VSCodeLinuxModel.csproj
dotnet add ProjetoVSCodeLinux/ProjetoVSCodeLinux.csproj reference
VSCodeLinuxBLL/VSCodeLinuxBLL.csproj
dotnet add ProjetoVSCodeLinux/ProjetoVSCodeLinux.csproj reference
VSCodeLinuxDAL/VSCodeLinuxDAL.csproj
Abaixo os códigos dos arquivos SetorController.cs e Startup.cs que se encontram no projeto “ProjetoVSCodeLinux”
SetorController.cs
using System.Collections.Generic;
using Microsoft.AspNetCore.Mvc;
using VSCodeLinuxBLL;
using VSCodeLinuxModel;
namespace ProjetoVSCodeLinux.Controllers
{
[Route("api/[controller]")]
[ApiController]
public class SetorController : ControllerBase
{
private ISetorBLL iSetorBLL;
public SetorController(ISetorBLL iSetorBLL)
{
this.iSetorBLL = iSetorBLL;
}
[Route("RetornarSetoresAtivos")]
public List<SetorModel> RetornarSetoresAtivos(){
return iSetorBLL.RetornarSetoresAtivos();
}
}
}
Startup.cs
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
services.AddSingleton<ISetorBLL, SetorBLL>();
services.AddSingleton<ISetorRepository, SetorRepository>();
}
Agora, só compilar o sistema e acessá-lo conforme imagem15:
Conclusão
Apesar de “um pouco” mais trabalhoso, é 100% possível criar uma WebApi utilizando apenas DotNetCore, VSCode e Linux. O legal de utilizar linha de comando, é que no meu ponto de vista você aprende os conceitos e não apenas um processo automático de fazer as coisas. Faço aqui um paralelo, quando iniciei no mundo Linux lá por volta de 2003, utilizei por muito tempo a distribuição “Slackware”, onde muitas coisas não tinham tela gráfica, era preciso utilizar e muito linha de comando. Isso foi muito benéfico para mim, pois me trouxe um embasamento teórico do funcionamento do Linux, conhecimento esse que me ajuda muito hoje em dia, mesmo a grande parte das distribuições terem interfaces gráficas muito interessantes.
Fonte: https://github.com/ztiago3/ProjetoVSCodeLinux