Compartilhar via

Agosto de 2016

Volume 31, Número 8

ASP.NET Core - Grave Aplicativos com o Visual Studio Code e o Entity Framework

Por Alessandro Del Del | Agosto de 2016

O desenvolvimento de plataformas cruzadas e software livre são essenciais para as estratégias atuais e futuras da Microsoft. Muitos blocos de construção da pilha .NET foram disponibilizados como software livre enquanto outros foram desenvolvidos para adotar e oferecer suporte à nova estratégia. O ASP.NET Core 1.0, atualmente em modo Release Candidate (RC), é a mais recente tecnologia de software livre para a criação de aplicativos de plataforma cruzada para a Web e para a nuvem em execução no Linux, Mac OS X e Windows.

O ASP.NET Core permite gravar aplicativos Model-View-Controller (MVC) com C# e depende do .NET Core (dotnet.github.io), o novo conjunto modular de tempos de execução, bibliotecas e compiladores de plataformas cruzadas e de software livre, também no modo RC. A maior vantagem do ASP.NET Core é que ele é completamente independente de qualquer sistema de projetos proprietário ou ambiente de desenvolvimento integrado, ou seja, você também pode compilar um aplicativo ASP.NET Core fora do Microsoft Visual Studio e em sistemas operacionais que não sejam o Windows.

Para alcançar esse objetivo, é possível usar uma série de ferramentas de linha de comando para construir, executar e gerar aplicativos automaticamente e usar o Visual Studio Code para editar. Ainda há muito trabalho em andamento, portanto, alguns recursos podem mudar até atingir a etapa de versão RTM (Release-to-Manufacturing). Por exemplo, o ASP.NET Core usado para depender do Ambiente de Execução .NET (DNX) e sua interface de linha de comando (CLI) para compilar e gerenciar aplicativos. Como o ASP.NET Core é compilado no .NET Core, o DNX será desativado e sua CLI migrará para as ferramentas de linha de comando do .NET Core para lançamentos futuros. Portanto, lembre-se disso se quiser começar a gravar aplicativos Web de plataforma cruzada com ASP.NET Core e C#.

Esse artigo explica como criar um aplicativo Web ASP.NET Core de plataforma cruzada que aproveita o Entity Framework 7 para executar operações de dados em um banco de dados e como gravar código no Visual Studio Code (code.visualstudio.com) que é usado no Linux, OS X e Windows. Como o foco é nos dados, recomendo que você leia o documento ".NET Core e Visual Studio Code" no site oficial (bit.ly/1PhzoC7). Você gravará vários comandos com base no ambiente DNX para ser consistente com o RC atual. Lembre-se de que ele será substituído por comandos da CLI do .NET Core após o ASP.NET Core passar a ser uma versão RTM.

Mostrarei comandos que serão substituídos quando apropriado. Criarei um aplicativo de exemplo usando a nova ferramenta do Visual Studio Code. O Visual Studio Code é uma ferramenta de desenvolvimento de plataforma cruzada sofisticada e multilíngue que coloca a gravação de código como foco central e possui ganchos para que você possa emitir comandos de compilação. Presumo que você já tenha instalado o Visual Studio Code, Node.js (nodejs.org), SQL Server Express Edition (bit.ly/1PhzoC7) e ASP.NET Core 1.0 RC (get.asp.net/OtherDownloads).

Criando um Banco de Dados de Exemplo

Em primeiro lugar, crie um banco de dados para trabalhar. Você pode usar um banco de dados existente ou definir o modelo de dados com a abordagem do Entity Framework Code First. No entanto, o suporte para migrações de código no ASP.NET Core ainda está em andamento e não é estável no momento. Dessa forma, basta criar um novo banco de dados que armazena uma lista de modelos de carros e os nomes de seus fabricantes. No SQL Server Management Studio, crie um novo banco de dados chamado Carros e grave e execute a consulta exibida na Figura 1, que define uma tabela chamada Carros, com três colunas: ID (chave primária e incrementada automaticamente), ModelodoCarro (de tipo NVarChar(Max)) e Fabricante (de tipo NVarChar(Max)).

Figura 1 - Criando uma Tabela de Exemplo

CREATE TABLE [dbo].[Cars](
  [id] [int] IDENTITY(1,1) NOT NULL,
  [CarModel] [nvarchar](max) NOT NULL,
  [Brand] [nvarchar](max) NOT NULL,
CONSTRAINT [PK_Cars] PRIMARY KEY CLUSTERED
(
  [id] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF,
  ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]
GO
SET IDENTITY_INSERT [dbo].[Cars] ON
GO
INSERT [dbo].[Cars] ([id], [CarModel], [Brand]) VALUES (1, N'Mustang', N'Ford')
GO
INSERT [dbo].[Cars] ([id], [CarModel], [Brand]) VALUES (2, N'500', N'Fiat')
GO
INSERT [dbo].[Cars] ([id], [CarModel], [Brand]) VALUES (3, N'Giulia', N'Alfa Romeo')
GO
SET IDENTITY_INSERT [dbo].[Cars] OFF
GO
USE [master]
GO
ALTER DATABASE [CARS] SET  READ_WRITE
GO

Dependendo do cenário, talvez você queira considerar uma coluna de bit de tipo usada para marcar um item como excluído, mas, que na verdade, nunca é removido dos dados armazenados fisicamente.

Verifique se o banco de dados, os dados da tabela e de exemplo são exibidos adequadamente no Explorador de Objetos do Management Studio.

Instalando C# para Visual Studio Code

No Visual Studio Code, o suporte à linguagem C# foi recentemente migrado para uma extensão que precisa ser baixada e instalada separadamente. É extremamente recomendado instalar a extensão C# para obter todos os recursos de edição evoluídos, como colorização da sintaxe, IntelliSense, detecção de problema de código enquanto você digita e muito mais. Para instalar o C#, execute o Visual Studio Code, abra a Paleta de Comandos (F1), digite “ext install” e pressione Enter. Na lista de extensões, clique duas vezes em C# e aguarde a conclusão da instalação. Ao ser solicitado, aceite reiniciar o Visual Studio Code.

Gerar Automaticamente um Aplicativo ASP.NET Core

O Visual Studio Code não possui comandos internos que automatizam a geração de um projeto ASP.NET Core e criar projetos manualmente é um pouco mais difícil. Com o atual RC do ASP.NET Core, é possível usar uma ferramenta de linha de comando chamada Yeoman (yeoman.io), uma conhecida ferramenta de geração automática de aplicativos que oferece, entre outras coisas, uma opção para gerar um esqueleto de aplicativo ASP.NET Core. O Yeoman depende do Node.js e deve ser instalado a partir da linha de comando usando o gerenciador de pacotes Node.js (npm). Dito isso, abra um prompt de comando e digite a seguinte linha:

> npm install -g yo generator-aspnet gulp bower

Isso instalará o Yeoman (representado por “yo”) na localização global (-g) juntamente com gulp (uma ferramenta usada para automatizar tarefas) e bower (um gerenciador de bibliotecas no lado do cliente). Observe que o Yeoman vem com vários geradores, incluindo o gerador do ASP.NET e o gerador de extensão do Visual Studio Code. A opção generator-aspnet na linha de comando anterior baixará e instalará o gerador do ASP.NET Core para simplificar seu trabalho. Quando estiver pronto, usando o comando cd (ou chdir), acesse uma pasta em que gostaria de criar um novo aplicativo (cd C:\temp). Neste ponto, digite a seguinte linha de comando:

> yo aspnet

Isso abrirá o gerador do Yeoman ASP.NET, como pode ser visto na Figura 2.

Iniciando o Yeoman Generator
Figura 2 - Iniciando o Yeoman Generator

Escolha o modelo do Aplicativo Web e pressione Enter. Na tela a seguir, insira ModelosdeCarros como o nome do aplicativo e pressione Enter. O gerador define o namespace raiz do aplicativo com base na capitalização do nome do aplicativo. Consequentemente, se ModelosdeCarros for o nome do aplicativo, então, o namespace raiz também será ModelosdeCarros. No entanto, se você inserir modelosdecarros ou Modelosdecarros como nome do aplicativo, então seu namespace raiz será modelosdecarros ou Modelosdecarros, respectivamente. Preste atenção nisso ao especificar o nome do aplicativo. Após alguns segundos, o Yeoman finaliza a geração de um novo aplicativo ASP.NET Core na subpasta chamada ModelosdeCarros. Com versões futuras do ASP.NET Core, também será possível usar a CLI do .NET Core para gerar um aplicativo Web automaticamente. A linha de comando exibida terá essa aparência:

> dotnet new

A versão atual da CLI ainda não oferece suporte à geração automática de aplicativos Web. Em vez disso, ela gera um aplicativo de console vazio, portanto, essa é outra razão para você ver o Yeoman em ação aqui. Insira a pasta ModelosdeCarros escrevendo “cd ModelosdeCarros” e, em seguida, digite “code” e o Visual Studio Code iniciará abrindo a pasta atual e seu conteúdo. Quando o Visual Studio Code abre uma pasta, ele verifica se há nomes de arquivos de projetos conhecidos, como arquivos de solução project.json, package.json ou .sln MSBuild. No caso de um projeto ASP.NET Core, o Visual Studio Code localiza o arquivo project.json, coleta informações de dependência e organiza subpastas e arquivos de código de forma apropriada. A primeira vez que o projeto é aberto, o Visual Studio Code detecta pacotes NuGet ausentes e propõe fazer uma restauração para você.

Clique em Restaurar na barra informativa e aguarde que os pacotes NuGet sejam baixados. Ao concluir, você pode aproveitar todos os recursos avançados de edição de código do Visual Studio Code para gravar e editar arquivos de código e reutilizar a maior parte de suas habilidades existentes com o ASP.NET MVC. Na verdade, o Visual Studio Code não só oferece suporte ao C#, mas também oferece colorização de sintaxe e outros recursos avançados para todos os tipos de arquivos que compõem um aplicativo ASP.NET Core, incluindo .cshtml, folhas de estilo CSS, JavaScript e arquivos .json.

Criando o Modelo de Dados com o Entity Framework 7

Agora que você tem um aplicativo ASP.NET Core vazio, o próximo passo é criar um modelo de dados com o Entity Framework 7, a nova versão do conhecido mapeador objeto-relacional da Microsoft que oferece suporte para ASP.NET Core. Quando esse artigo foi escrito, o Entity Framework 7 estava em RC1. A criação do modelo se realizará com a execução dos comandos dnx adequados a partir do prompt de comando e envolve alguns pacotes NuGet. O primeiro pacote NuGet é chamado EntityFramework.MicrosoftSqlServer e é automaticamente referenciado pelo projeto recém-criado. O segundo pacote NuGet é chamado EntityFramework.MicrosoftSqlServer.Design e deve ser adicionado manualmente às dependências do projeto. Para fazer isso, no Visual Studio Code, abra o arquivo project.json e localize a seguinte linha no nó de dependências:

"EntityFramework.MicrosoftSqlServer": "7.0.0-rc1-final",

Após essa linha, adicione:

"EntityFramework.MicrosoftSqlServer.Design": "7.0.0-rc1-final",

Observe que os dois pacotes devem ter o mesmo número de versão, que mudará em versões futuras. Salve project.json. O Visual Studio Code detectará um pacote NuGet ausente e tornará a solicitar uma restauração de pacote. Como de costume, aceite essa oferta.

Agora, abra um prompt de comando na pasta que contém o projeto ASP.NET Core. O ambiente dnx oferece o comando do ef que permite gerar modelos de dados de entidade a partir da linha de comando. Esse comando oferece comandos extras, como banco de dados, dbcontext e migrações. O comando do banco de dados permite gerenciar um banco de dados, o comando dbcontext permite gerar automaticamente entidades e um tipo de DbContext e as migrações permitem trabalhar com migrações de código. Você usará o comando dbcontext para gerar uma classe DbContext e as entidades necessárias. Você pode gravar o ef do dnx para exibir a lista de comandos disponíveis (confira a Figura 3) ou digite um comando completo diretamente.

Lista de Comandos Disponíveis do Entity Framework
Figura 3 - Lista de Comandos Disponíveis do Entity Framework

Quando estiver pronto, grave a seguinte linha de comando:

> dnx ef dbcontext scaffold "Server=.\sqlexpress;Database=Cars;Trusted_Connection=True;" 
EntityFramework.MicrosoftSqlServer --outputDir Models

O comando dbcontext tem uma opção chamada scaffold, que gera as entidades e o DbContext adequados a partir do banco de dados especificado na cadeia de conexão fornecida. E, claro, será necessário substituir o nome do servidor pelo seu nome. EntityFramework.Micro­softSqlServer especifica o provedor de dados que será usado para scaffolding. Observe como você pode especificar um diretório de saída para seu modelo de dados através da opção --outputDir, que diferencia maiúsculas de minúsculas. Nesse caso, o diretório de saída é uma pasta chamada Modelos que já existe no projeto e é o lugar lógico e apropriado para a classe e as entidades DbContext. Após a mensagem de conclusão, você verá que a pasta Modelos contém um arquivo de classe chamado CarsContext.cs, que contém a classe CarsContext herdeira de DbContext, e um arquivo chamado Cars.cs que define uma classe chamada Cars e que expõe as propriedades que mapeiam colunas a partir da tabela Carros no banco de dados (confira a Figura 4). Observe que não há opções para controlar a pluralização dos nomes de entidades, portanto, essa questão deve ser gerenciada manualmente e está fora do escopo deste artigo.

Classe de Modelo Carros no Editor de Códigos
Figura 4 - Classe de Modelo Carros no Editor de Códigos

Neste ponto, você deve fornecer a cadeia de conexão que o aplicativo usará para se conectar ao banco de dados. Em vez de colocar a cadeia de conexão no arquivo Web.config, isso pode ser feito na classe Startup. Essa classe declara um método chamado ConfigureServices que é invocado pelo tempo de execução para configurar os serviços necessários usando a injeção de dependência (ID, dependency injection) e é o local recomendado para fornecer a cadeia de conexão. ConfigureServices usa um argumento chamado serviços, de tipo Microsoft.Extensions.Dependency­Injection.IServiceCollection, que armazena uma lista de serviços que serão inseridos. Considere essas linhas de código:

var connection = @"Server=.\sqlexpress;Database=Cars;Trusted_Connection=True;";
services.AddEntityFramework()
  .AddSqlServer()
  .AddDbContext<CarsContext>(options => options.UseSqlServer(connection));

O que a segunda linha faz é registrar os serviços Entity Framework e SQL Server necessários para a DI e registra a classe DbContext como um serviço. O método AddDbContext permite especificar a cadeia de conexão usando o método DbContextBuilder.UseSqlServer, invocado por um delegado chamado opções. Ambas as linhas devem ser colocadas bem no início do método ConfigureServices cujo código completo é mostrado na Figura 5.

Figura 5 - Registrando a Classe DbContext para a Injeção de Dependência

public void ConfigureServices(IServiceCollection services)
{
  // Add framework services
  var connection = @"Server=.\sqlexpress;Database=Cars;Trusted_Connection=True;";
  services.AddEntityFramework()
    .AddSqlServer()
    .AddDbContext<CarsContext>(options => options.UseSqlServer(
      connection));
  services.AddEntityFramework()
    .AddSqlite()
    .AddDbContext<ApplicationDbContext>(options => options.UseSqlite(
      Configuration["Data:DefaultConnection:ConnectionString"]));
  services.AddIdentity<ApplicationUser, IdentityRole>()
    .AddEntityFrameworkStores<ApplicationDbContext>()
    .AddDefaultTokenProviders();
  services.AddMvc();
  // Add application services
  services.AddTransient<IEmailSender, AuthMessageSender>();
  services.AddTransient<ISmsSender, AuthMessageSender>();
}

Até aqui, você implementou seu modelo de dados. Agora você precisa de uma forma de expor as ações que a interface do usuário invocará para trabalhar com dados.

Implementando Controladores do MVC

O ASP.NET Core é compatível com os serviços da API Web e aplicativos MVC. A API Web é a abordagem preferida se você estiver criando um serviço RESTful. O exemplo atual é um aplicativo Web com uma interface do usuário, portanto, usarei o MVC. Você pode implementar as exibições e controladores MVC que desejar em qualquer aplicativo ASP.NET MVC. Um controlador é uma classe herdeira de Microsoft.AspNet.Mvc.Controller e expõe ações que a interface do usuário (ou outros clientes) pode invocar para trabalhar com dados. Para adicionar um controlador, no Visual Studio Code, clique com o botão direito do mouse na pasta Controladores e escolha Novo Arquivo. Quando a caixa de texto for exibida, insira CarsController.cs como o novo nome do arquivo. Isso adicionará um novo arquivo C# que também será exibido no editor de códigos. O novo controlador precisa de implementar métodos que permitam consultar, adicionar e excluir dados. A listagem completa de controladores é exibida na Figura 6 (com comentários). Embora o código possa parecer um pouco longo, o IntelliSense ajudará você a gravar códigos com maior rapidez e eficiência.

Figura 6 - Implementando um Controlador MVC que Funciona em Dados

using System.Linq;
using Microsoft.AspNet.Mvc;
using CarModels.Models;
namespace CarModels.Controllers
{
  public class CarsController : Controller
  {
    // Declares the DbContext class
    private CarsContext dataContext;
    // The instance of DbContext is passed via dependency injection
    public CarsController(CarsContext context)
    {
      this.dataContext=context;
    }
    // GET: /<controller>/
    // Return the list of cars to the caller view
    public IActionResult Index()
    {
      return View(this.dataContext.Cars.ToList());
    }
    public IActionResult Create()
    {
      return View();
    }
    // Add a new object via a POST request
    [HttpPost]
    [ValidateAntiForgeryToken]
    public IActionResult Create(Cars car)
    {
      // If the data model is in a valid state ...
      if (ModelState.IsValid)
      {
        // ... add the new object to the collection
        dataContext.Cars.Add(car);
        // Save changes and return to the Index method
        dataContext.SaveChanges();
        return RedirectToAction("Index");
      }
      return View(car);
    }
    [ActionName("Delete")]
    public IActionResult Delete(int? id)
    {
      if (id == null)
      {
        return HttpNotFound();
      }
      Cars car = dataContext.Cars.Single(m => m.id == id);
      if (car == null)
      {
        return HttpNotFound();
      }
      return View(car);
    }
    // POST: Cars/Delete/5
    // Delete an object via a POST request
    [HttpPost, ActionName("Delete")]
    [ValidateAntiForgeryToken]
    public IActionResult DeleteConfirmed(int id)
    {
      Cars car = dataContext.Cars.SingleOrDefault(m => m.id == id);
      // Remove the car from the collection and save changes
      dataContext.Cars.Remove(car);
      dataContext.SaveChanges();
      return RedirectToAction("Index");
    }
  }
}

Em resumo, há quatro ações: Index, que retorna a lista de carros na exibição do chamador; Create, que adiciona um novo carro usando a solicitação HTTP POST e Delete e DeleteConfirmed, que aguarda pela confirmação do usuário e remove um carro usando uma solicitação HTTP POST, respectivamente. Com About Index, você também poderia gravar uma consulta do LINQ para retornar uma lista filtrada.

Adicionando e Criando Exibições do MVC

No MVC, as exibições são páginas da Web vinculadas a dados que formam a interface do usuário do aplicativo. Neste exemplo, são necessárias três exibições: uma página Index que exibe a lista de carros, uma página Create que permite aos usuários adicionar novos carros e uma página Delete que solicita a confirmação antes de excluir um carro de um banco de dados. As exibições devem ser organizadas em subpastas que residam na pasta Exibições cujo nome é usado pelo aplicativo para rotear solicitações da Web. Por exemplo, se você criar uma pasta chamada Carros, todas as exibições nessa pasta serão abertas pela convenção de roteamento ApplicationName/Cars. Considerando que você tenha criado uma pasta chamada Carros em Exibições, clique com o botão direito do mouse e escolha Novo Arquivo. Insira Index.cshtml como nome do arquivo e pressione Enter para que o novo arquivo fique imediatamente disponível no editor de códigos. Baseando-se na extensão, o Visual Studio Code reconhece-o como um arquivo do Razor. Essa exibição é usada para mostrar a lista completa de itens por meio de uma tabela. Cada linha mostra o modelo do carro, o nome do fabricante e um hiperlink que os usuários podem clicar para excluir um item. A Figura 7 mostra o código completo para a página Index.cshtml.

Figura 7 - Criando uma Exibição de Index

@model IEnumerable<CarModels.Models.Cars>
@{
  ViewBag.Title = "Cars";
}
<h2>Car models</h2>
<p>
  <a asp-controller="Cars" asp-action="Create">Add New</a>
</p>
<table class="table">
  <tr>
    <th>Car Model</th>
    <th>Brand</th>
  </tr>
  @foreach (var item in Model)
  {
    <tr>
      <td>
        @Html.DisplayFor(modelItem => item.CarModel)
      </td>
      <td>
        @Html.DisplayFor(modelItem => item.Brand)
      </td>
      <td>
        <a asp-controller="Cars" asp-action="Delete"
          asp-route-id="@item.id">Delete</a>
      </td>
    </tr>
  }
</table>

Observe como a marcação aproveita a chamada vinculação do modelo para especificar o tipo .NET da classe do modelo e para invocar e vincular suas propriedades para cada linha. Além disso, observe como o link de Delete aponta para a ação de mesmo nome no controlador Carros, fornecendo a ID do item através da vinculação do modelo. De forma semelhante, uma ação chamada Create aponta para a ação Create no controlador Carros e abre uma nova exibição que permite adicionar novos objetos. Essa exibição é chamada Create e é possível criar uma ação seguindo as mesmas etapas anteriormente utilizadas na exibição Index, ou seja, adicionando um arquivo Create.cshtml à subpasta Exibições\Carros. Nessa nova exibição, você basicamente cria um formulário de dados no qual os usuários podem gravar informações com base nas propriedades do modelo, disponibilizando um botão que envia informações ao controlador de ligação. A Figura 8 mostra como realizar isso.

Figura 8 - Definindo uma Exibição Create

@model CarModels.Models.Cars
@{
  ViewBag.Title = "New car";
}
<h2>@ViewData["Title"]</h2>
<form asp-controller="Cars" asp-action="Create" method="post"
  class="form-horizontal" role="form">
  <div class="form-horizontal">
    <div asp-validation-summary="ValidationSummary.All" class="text-danger"></div>
    <div class="form-group">
      <label asp-for="CarModel" class="col-md-2 control-label"></label>
      <div class="col-md-10">
        <input asp-for="CarModel" class="form-control" />
        <span asp-validation-for="CarModel" class="text-danger"></span>
      </div>
      <label asp-for="Brand" class="col-md-2 control-label"></label>
      <div class="col-md-10">
        <input asp-for="Brand" class="form-control" />
        <span asp-validation-for="Brand" class="text-danger"></span>
      </div>
    </div>
    <div class="form-group">
      <div class="col-md-offset-2 col-md-10">
        <input type="submit" value="Create" class="btn btn-default" />
      </div>
    </div>
  </div>
</form>

A última etapa é a adição de uma nova exibição chamada Delete.cshtml na subpasta Exibições\Carros. Após ser adicionada, digite o código exibido na Figura 9 que mostra informações detalhadas sobre o item que será excluído e oferece uma opção para enviar ou cancelar alterações.

Figura 9 - Criando uma Exibição Delete

@model CarModels.Models.Cars
@{
  ViewData["Title"] = "Delete";
}
<h2>Delete</h2>
<h3>Are you sure you? The operation cannot be undone.</h3>
<div>
  <h4>Cars</h4>
  <hr />
  <dl class="dl-horizontal">
    <dt>
      @Html.DisplayNameFor(model => model.Brand)
    </dt>
    <dd>
      @Html.DisplayFor(model => model.Brand)
    </dd>
    <dt>
      @Html.DisplayNameFor(model => model.CarModel)
    </dt>
    <dd>
      @Html.DisplayFor(model => model.CarModel)
    </dd>
  </dl>
  <form asp-action="Delete">
    <div class="form-actions no-color">
      <input type="submit" value="Delete" class="btn btn-default" /> |
      <a asp-action="Index">Back to List</a>
    </div>
  </form>
</div>

Neste ponto você tem um modelo de dados, ações e interface do usuário. Isso significa que você está pronto para começar a testar o aplicativo de exemplo.

Executando o Aplicativo

Você pode executar um aplicativo ASP.NET Core diretamente no Visual Studio Code. Para que isso ocorra, abra a Paleta de Comandos, digite dnx e pressione Enter. Em seguida, escolha dnx: Execute o Comando e pressione Enter. Depois, clique em dnx web. Isso equivale a digitar dnx web em um prompt de comando. Em versões futuras, você escreverá dotnet run na linha de comando. Nesse ponto, o Visual Studio Code inicia o Kestrel, um servidor Web de software livre para aplicativos ASP.NET Core (bit.ly/1rdEfxV), para hospedar seu aplicativo Web. No Visual Studio Code, você também verá uma janela do Console na qual o Kestrel redireciona seus resultados e mensagens enviadas pelo tempo de execução, incluindo o rastreamento de pilha no caso de exceções, especialmente útil para fins de depuração. Por padrão, o Kestrel começa a ouvir a porta 5000, ou seja, você pode abrir seu navegador preferido e digitar http://localhost:5000 para iniciar o aplicativo. A Figura 10 mostra o aplicativo em execução.

O Aplicativo em Execução
Figura 10 - O Aplicativo em Execução

Na barra de endereços da Web do navegador, digite localhost:5000/Carros para abrir a exibição padrão do controlador Carros. Como pode ser visto na Figura 11, o aplicativo mostra a lista de carros, conforme o esperado.

Aplicativo Exibindo a Lista de Carros no Banco de Dados
Figura 11 - Aplicativo Exibindo a Lista de Carros no Banco de Dados

Clique em Adicionar Novo para ter uma opção para adicionar um novo item (confira a Figura 12). Ao clicar em Create, o novo item é salvo no banco de dados e o aplicativo retornará à exibição anterior na qual você verá uma lista de carros atualizada.

Adicionando um Novo Item
Figura 12 - Adicionando um Novo Item

Agora, clique no hiperlink Excluir próximo ao carro que você adicionou anteriormente. A exibição Delete aparece e mostra os detalhes do item selecionado e, em seguida, solicita a confirmação do usuário (confira a Figura 13). Basta clicar em Excluir para remover o item e retornar ao índice. Lembre-se de que isso é um aplicativo Web de plataforma cruzada, portanto, pode ser publicado no Linux, OS X e Windows.

Excluindo um Item
Figura 13 - Excluindo um Item

Dicas sobre como Publicar seu Aplicativo

Há alternativas para publicar seu aplicativo ASP.NET Core, incluindo (mas não exclusivamente) o Microsoft Azure e IIS. A primeira opção envolve a ativação da integração com o Git, enquanto a segunda envolve atualmente o Utilitário DNX (dnu) e a linha de comando dnu publish e envolverá a linha de comando dotnet publish em versões futuras. A publicação foi discutida nos recursos da Microsoft. A publicação no Azure é discutida em bit.ly/22QXTh6 e o uso do dnu é discutido em bit.ly/1TWvfWh.

Conclusão

O Visual Studio Code permite gravar aplicativos ASP.NET Core aproveitando todos os recursos evoluídos de edição disponíveis para C# e para outros tipos de arquivo no projeto. Por ser uma plataforma cruzada, é a companhia perfeita para iniciar a gravação de aplicativos MVC para Linux, OS X e Windows. A disponibilidade do Entity Framework para plataformas diferentes e a oportunidade de reutilizar suas habilidades em C# e MVC tornam a gravação de aplicativos Web centrados em dados uma experiência ainda mais incrível. Não se esqueça de consultar a documentação do ASP.NET Core e .NET Core para obter informações sobre atualizações da CLI do .NET Core.

Alessandro Del Sole é Microsoft MVP desde 2008. Premiado cinco vezes como MVP of the Year, é autor de muitos livros, eBooks, vídeos instrutivos e artigos sobre o desenvolvimento em .NET com o Visual Studio. Del Sole trabalha como desenvolvedor especialista em soluções para a Brain-Sys (www.brain-sys.it), com foco em desenvolvimento, treinamento e consultoria em .NET. Você pode segui-lo no Twitter: @progalex.

Agradecemos ao seguinte especialista técnico da Microsoft pela revisão deste artigo: James McCaffrey
Entre em contato com o Dr. James McCaffrey trabalha para a Microsoft Research em Redmond, Washington. Ele trabalhou em vários produtos da Microsoft, incluindo Internet Explorer e Bing. Entre em contato com o Dr. McCaffrey pelo email jammc@microsoft.com.