Crie uma WebApi usando .NET CORE no Visual Studio Code

webapi-dotcore_fundo

Pessoal, estou iniciando meus estudos em .NET CORE e neste artigo vamos ver como criar uma WebApi usando esta tecnologia no Visual Studio Code.

As “coisas” mudaram muito ao meu ver na criação de aplicativos .NET,  agora temos que ter conhecimento de comandos e digitar muita coisa manualmente (talvez exista modo mais fácil, mas ainda não consegui ver isso).

Estava acostumado ao Visual Studio onde bastava solicitar uma nova aplicação MVC com ou sem WEB API e pronto estava lá o seu projeto criado, bastando apertar F5 para ter o exemplo rodando perfeitamente na sua máquina.

Agora com esse novo mundo do .NET CORE temos que fazer mais coisas na “mão” do que a versão anterior, talvez seja o preço a pagar para ter a nossa plataforma de desenvolvimento em todos os sistemas operacionais. Eu particularmente não vejo problemas nisso, pois isso força que eu saia da minha zona de conforto e consequentemente aprenda mais.

Neste artigo queria demonstrar a quem está estudando como eu, como criar uma WebApi com o .NET CORE e utilizando o Visual Studio Code como IDE para o desenvolvimento.

O cenário descrito nesse artigo foi criado no Windows, mas provavelmente funciona igual nos outros sistemas operacionais (não testei ainda) vamos criar uma API que fornece métodos para manipulação de um CRUD de clientes básico.

Primeiro passo a fazer é baixar o Visual Studio Code caso ainda não tenha e instalar a ferramenta no seu computador, depois disso instale se ainda não tiver o .NET CORE SDK, que pode ser encontrado neste link.

Crie um diretório para sua aplicação. No meu exemplo criei uma pasta com o nome de “api”.

Entre nessa pasta via o windows command prompt, veja abaixo:

webapi-dotcore1

Agora digite o seguinte comando para criar a aplicação .NET CORE:

dotnet new

Quando digitar o comando acima o .NET CORE deverá retornar uma mensagem avisando que foi criado um novo projeto C# em sua pasta, que passará agora a ter os arquivos Program.cs e o o project.json como na imagem abaixo:

webapi-dotcore2

Agora digite o seguinte comando:

dotnet restore

O .NET CORE irá criar o arquivo project.lock.json , neste momento seu projeto deverá estar parecido com a imagem abaixo:

webapi-dotcore3

Agora vamos entrar no Visual Studio Code, para acessar através do prompt de comando basta digitar “code” que o VSC será aberto.

Quando abrir o VSC você deverá receber a mensagem “Required assets to build and debug are missing from ‘api’. Add them?”, clique em “Yes”, neste momento irá ser criado na sua solution a pasta .vscode.

webapi-dotcore4

Abaixo a minha solução no VSC, vou aproveitar e mostrar algumas janelas importantes para utilizar nos próximos passos:

webapi-dotcore5

Agora, caso não esteja instalado ainda na sua máquina, vamos instalar no VSC a extensão para utilizar o C#, abra o Quick Open digitando Ctrl+P e digite o seguinte comando: “ext install csharp” deverá aparecer no VSC uma lista de extensions, mais informações sobre essa extensão pode ser obtida neste link. Esta extensão vai facilitar a escrita do código mais a frente.

Agora para verificar se tudo está ok, digite no terminal integrado o comando “dotnet run”, se tudo estiver correto você deverá receber a incrível notificação de HELLO WORD!!

webapi-dotcore7

Com essa parte funcionado vamos começar efetivamente a criar nossa API, vamos alterar agora o arquivo project.json inserindo a seguinte estrutura para rodar o ASP.NET MVC:

webapi-dotcore8

Vamos inserir no arquivo as seguintes dependências:

  • Kestrel
  • Mvc
  • Mvc Core

Ao efetuar essa alteração e salvar o arquivo  o VSC irá mostrar a mensagem “There are unresolved dependencies from ‘project.json’. Please execute the restore command to continue“. Isso acontece a todo momento que for alterado o arquivo.

Você pode clicar em “Restore” ou ir ao terminal integrado e digitar o comando “dotnet restore”, fica ao seu critério, depois de executar esse passo o VSC irá instalar todas as dependências:

webapi-dotcore9

Após efetuar o restore, vamos alterar a classe Program.cs:


using System;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.DependencyInjection;

namespace MarcDias.Api
{
public class Program
{
public static void Main(string[] args)
{
var host = new WebHostBuilder()
.UseKestrel()
.UseStartup<Program>()
.Build();
host.Run();
}

public void ConfigureServices(IServiceCollection services)
{
services.AddMvc();
}

public void Configure(IApplicationBuilder app)
{
app.UseMvcWithDefaultRoute();
}
}
}

Crie uma pasta na raiz do seu projeto chamada models e nela crie uma classe chamada Cliente.cs com a seguinte estrutura:


using System;
namespace  MarcDias.Api.Models
{
public class Cliente
{
public int Id { get; set; }
public string Nome { get; set; }
}
}

Crie outra pasta na raiz do seu projeto chamada controllers e nela crie a classe de controle da api chamada de ClienteController.cs com a seguinte estrutura:


using System.Collections.Generic;
using Microsoft.AspNetCore.Mvc;
using MarcDias.Api.Models;

namespace  MarcDias.Api.Controllers
{
[Route("api/[controller]")]
public class ClienteController : Controller
{
private static List<Cliente> _clientes;

static ClienteController()
{
_clientes = new List<Cliente>();

_clientes.Add(new Cliente()
{
Id = 1,
Nome = "Marcelo Dias"
});

_clientes.Add(new Cliente()
{
Id = 2,
Nome = "Fulano de tal"
});
}

[HttpGet]
public IEnumerable<Cliente> GetAll()
{
return _clientes.AsReadOnly();
}

[HttpGet("{id}", Name = "GetCliente")]
public IActionResult GetById(int id)
{
var item = _clientes.Find(x => x.Id == id);

if (item == null)
{
return NotFound();
}

return new ObjectResult(item);
}

[HttpPost]
public IActionResult Create([FromBody] Cliente item)
{
if (item == null)
{
return BadRequest();
}

item.Id = (_clientes.Count + 1);

_clientes.Add(item);

return CreatedAtRoute("GetCliente", new { controller = "Cliente", id = item.Id }, item);
}

[HttpDelete("{id}")]
public void Delete(int id)
{
_clientes.RemoveAll(n => n.Id == id);
}
}
}

Agora compile a aplicação usando as teclas Ctrl+Shift+B para ver se correu tudo bem, se sim você deverá ter uma saída na janela de OUTPUT parecida com isso:

webapi-dotcore10

Vamos rodar nossa primeira API usando o comando “dotnet run”, depois de rodar o comando o .NET CORE deverá informar em que servidor e porta está rodando sua API como na imagem abaixo:

webapi-dotcore11

Agora vamos ao browser e inserir o endereço acima para verificar se está respondendo da maneira que programamos:

webapi-dotcore12

webapi-dotcore13

webapi-dotcore14

Olha nossa primeira WebApi construída com o .NET CORE usando o Visual Studio Code rodando perfeitamente!

Bem minha intenção é mostrar os primeiros passos, ainda estou estudando e vou criar mais artigos sobre o tema, no próximo vamos ver todas as operações utilizando o Postman para efetuar as chamadas.

Quem já possuir experiencia, por favor comente o que podemos melhorar, será bem vindo.

Se gostou ou ajudou, comenta! se não gostou ou não te ajudou comenta também!!

Abraço e até o próximo artigo.

Você pode gostar...

1 Resultado

  1. 19 de julho de 2017

    […] Quando você for desenvolver em .NET CORE vai perceber que todas as Web Applications já nascem como OWIN Applications, mas isso fica para um próximo artigo, ah se quiser ver como criar serviço em .NET CORE vá no meu artigo anterior. […]

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *