ASP.NET é uma plataforma para construir APIs da web com C # e .NET. É comumente usado para back-ends de aplicativos e pode serializar classes automaticamente para JSON. Veremos como configurar um serviço que se comunica com um banco de dados e armazena uma lista de objetos.

Criando um Projeto

Usaremos o Visual Studio, pois ele fornece excelente suporte .NET pronto para uso. Crie um novo projeto usando o modelo “ASP.NET Core Web Application”:

criar novo projeto

Dê um nome a ele e selecione “API”, pois não estamos construindo um front-end ASP.NET aqui.

selecione API

Isso inicializará sua solução com todo o padrão necessário para colocar uma API básica em funcionamento. Se você clicar no botão Executar (denominado IIS Express, que inicia um servidor da Web IIS), verá a API exibindo alguns dados fictícios sobre o clima.

iniciar programa

dados fictícios

Usaremos essa base para configurar uma API simples que se conectará a um banco de dados e lerá e escreverá objetos personalizados. Nesse caso, é uma coleção de dados do usuário, mas a API funcionará basicamente da mesma forma para modelos de entidade mais complicados.

Conectando um banco de dados

É uma boa ideia dividir a lógica de tratamento de solicitações e a lógica de tratamento de comunicação com o banco de dados. Criaremos um serviço de banco de dados com algumas funções para leitura e gravação e, em seguida, um controlador de API que responderá às solicitações conversando com o serviço de banco de dados. A primeira coisa a fazer, entretanto, é fazer com que o ASP.NET converse com um banco de dados em primeiro lugar.

Precisaremos instalar alguns pacotes para trabalhar com um banco de dados. Clique em Ferramentas> Gerenciador de pacotes NuGet e selecione “Gerenciar pacotes NuGet para solução”.

instalar pacotes nugest

Se você estiver usando um banco de dados SQL, a conexão do banco de dados é tratada com pacotes de plug-ins específicos que implementam EntityFrameworkCore para o banco de dados subjacente. Esta é uma estrutura que mapeia objetos C # para um banco de dados relacional e permite que você use consultas LINQ e outras ferramentas nativas para interagir com ele. Você pode encontrar uma lista completa de provedores de banco de dados aqui para os bancos de dados relacionais mais populares.

Faremos o MongoDB aqui, porque os bancos de dados de documentos NoSQL se traduzem em um List<Object> perfeitamente, e o driver MongoDB suporta consultas LINQ muito parecidas com EF Core.

Instale o pacote MongoDB.Driver:

Instalando o pacote MongoDB.Driver

Crie uma nova pasta na raiz do seu projeto chamada “Modelos”. Nele, crie um modelo de entidade chamado User.cs, que será o esquema da coleção que é armazenada no banco de dados. Você pode usar o [BsonId] e [BsonRepresentation(BsonType.ObjectId)] atributos para informar ao driver MongoDB que esta string de ID deve ser interpretada como a ID de coleção e pode ser passada como tipo string embora o Mongo queira digitar internamente ObjectId.

using MongoDB.Bson;
 using MongoDB.Bson.Serialization.Attributes;
 using System;
 
 namespace ExampleService.Models
 {
 public class User
 {
 [BsonId]
 [BsonRepresentation(BsonType.ObjectId)]
 public string Id { get; set; }
 
 [BsonElement("Name")]
 public string Name { get; set; }
 public string Email { get; set; }
 // etc...
 }
 }

Nesta mesma pasta, crie um arquivo chamado DatabaseSettings.cs, que armazenará uma classe e uma interface para as configurações do banco de dados.

namespace ExampleService.Models
 {
 public class ExampleDatabaseSettings : IExampleDatabaseSettings
 {
 public string ExampleCollectionName { get; set; }
 public string ConnectionString { get; set; }
 public string DatabaseName { get; set; }
 }
 
 public interface IExampleDatabaseSettings
 { 
 string ExampleCollectionName { get; set; }
 string ConnectionString { get; set; }
 string DatabaseName { get; set; }
 }
 }

Podemos preencher esses valores de propriedade em appsettings.json, adicionando a seguinte configuração:

"ExampleDatabaseSettings": {
 "ExampleCollectionName": "Users",
 "ConnectionString": "mongodb://localhost:27017",
 "DatabaseName": "Example"
 }

Você, é claro, precisará criar ou renomear o Example banco de dados, bem como criar o Users coleção nele.

Finalmente, vamos adicionar algum código em Startup.cs no ConfigureServices método, que irá buscar as configurações do appsettings.json arquivo e registrar a interface por meio de injeção de dependência:

public void ConfigureServices(IServiceCollection services)
 {
 services.Configure<ExampleDatabaseSettings>(
 Configuration.GetSection(nameof(ExampleDatabaseSettings)));
 
 services.AddSingleton<IExampleDatabaseSettings>(sp =>
 sp.GetRequiredService<IOptions<ExampleDatabaseSettings>>().Value);
 
 services.AddControllers();
 }

Você precisará adicionar uma diretiva no topo usando o namespace de modelos.

Escrevendo um serviço de banco de dados CRUD

Assim que o banco de dados estiver conectado, você pode adicionar o serviço que fará a conversa. A seguinte classe contém um IMongoCollection que representa a coleção MongoDB em um formato com o qual C # pode interagir facilmente. Leituras, gravações, atualizações e exclusões afetarão diretamente a coleção subjacente.

O método construtor pega as configurações do banco de dados, inicia um novo cliente, busca o banco de dados e inicializa o _users coleção.

using ExampleService.Models;
 using MongoDB.Driver;
 using System.Collections.Generic;
 using System.Linq;
 
 namespace ExampleService.Services
 {
 public class ExampleService
 {
 private readonly IMongoCollection<User> _users;
 
 public UserService(IExampleDatabaseSettings settings)
 {
 var client = new MongoClient(settings.ConnectionString);
 var database = client.GetDatabase(settings.DatabaseName);
 
 _users = database.GetCollection<User>(settings.ExampleCollectionName);
 }
 
 public List<User> Get() =>
 _users.Find(user => true).ToList();
 
 public User Get(string id) =>
 _users.Find<User>(user => user.Id == id).FirstOrDefault();
 
 public User Create(User user)
 {
 _users.InsertOne(user);
 return user;
 }
 
 public void Update(string id, User userIn) =>
 _users.ReplaceOne(user=> user.Id == id, userIn);
 
 public void Remove(User userIn) =>
 _users.DeleteOne(user => user.Id == userIn.Id);
 
 public void Remove(string id) => 
 _users.DeleteOne(user=> user.Id == id);
 }
 }

O resto da classe é simplesmente um conjunto de operações CRUD para interagir com o banco de dados. Sinta-se à vontade para implementar qualquer lógica personalizada aqui.

De volta Startup.cs, você vai querer adicionar isto como um serviço na inicialização:

public void ConfigureServices(IServiceCollection services)
 {
 services.Configure<ExampleDatabaseSettings>(
 Configuration.GetSection(nameof(ExampleDatabaseSettings)));
 
 services.AddSingleton<IExampleDatabaseSettings>(sp =>
 sp.GetRequiredService<IOptions<ExampleDatabaseSettings>>().Value);
 
 services.AddSingleton<ExampleService>();
 
 services.AddControllers();
 }

Você precisará de outro using diretiva, desta vez para ExampleService.Services.

Configurando um controlador de API

Em seguida, você precisará de um controlador para lidar com as ações da API. Felizmente, o Visual Studio torna isso fácil; você pode clicar com o botão direito em “Controladores” para adicionar um novo controlador, com ações de leitura / gravação. Isso criará um novo controlador com alguns métodos básicos.

Clique com o botão direito em "Controladores" para adicionar um novo controlador com ações de leitura / gravação

A rota é definida no topo. Por padrão, isso é definido como /api/controller, onde controlador é o nome do controlador (menos a parte “Controlador”). Você pode mudar isso se quiser, mas esse é um bom padrão para a maioria das pessoas.

[Route("api/[controller]")]

Você deseja adicionar uma referência ao seu serviço de banco de dados no início da classe e preenchê-la no construtor:

private readonly ExampleService _exampleService;
 
 public ExampleController(ExampleService exampleService)
 {
 _exampleService = exampleService;
 }

Você vai querer mudar o método HttpGet para retornar um ActionResult<List<T>> do esquema que você está armazenando. (Você precisará adicionar uma referência ao namespace de Modelos, é claro.) ActionResult é um tipo dinâmico que envolve o TValue dentro dele ou um resultado de resposta HTTP.

[HttpGet]
 public ActionResult<List<User>> Get()
 {
 return _exampleService.Get();
 }

Se quiser adicionar outro método Get, mas em uma rota diferente, você pode passá-lo como um parâmetro no atributo:

[HttpGet("otherroute")]
 public ActionResult<List<User>> GetSomeThingElse()
 {
 return _exampleService.GetSomeThingElse();
 }

Então, para o método HttpPost, chame o método Create do seu serviço de banco de dados e retorne CreatedAtRoute, que enviará uma resposta 201 para o cliente informando que a criação do objeto foi bem-sucedida.

[HttpPost]
 public ActionResult<User> Create(User userIn)
 {
 _exampleService.Create(userIn);
 
 return CreatedAtRoute("GetUser", new { id = userIn.Id.ToString() }, userIn);
 }

Para as outras rotas, você pode configurá-las como quiser. A ideia geral é lidar com a entrada do usuário, realizar as validações necessárias e chamar as ações adequadas do banco de dados, retornando ao usuário algo útil ou um código de status informando o que aconteceu.

Neste ponto, porém, você deve conseguir clicar no botão de execução do IIS Express na parte superior e testar a API. A rota padrão será a API de serviços meteorológicos que veio com o boilerplate, então, em vez de digitá-la toda vez, você pode alterar a rota de depuração em Projeto> Propriedades> Depurar e alterar a opção Iniciar navegador.

alterar rota de depuração

Assim que desejar testar em um servidor remoto, você pode criar um build de produção em Build> Publish Service. Selecione o arquivo de saída e edite a configuração para atender às suas necessidades. Por exemplo, você pode escolher construir como autocontido, o que empacotará todas as dependências do .NET com a construção, e também publicar como um único executável. Você pode alterar o tempo de execução de destino aqui também.

configurações de construção de produção

Se você deseja publicar no Linux, você precisará adicionar um identificador de tempo de execução ao seu .csproj Arquivo.

<RuntimeIdentifier>linux-x64</RuntimeIdentifier>

Claro, a API apresentada aqui não é segura. ASP.NET tem um ótimo sistema de autenticação, oferecendo suporte para tokens baseados em JWT, e pode ser configurado para funcionar com provedores de OAuth como Google e Facebook.

Adicione ao Google Notícias
Neste artigo
  1. Criando um Projeto
  2. Conectando um banco de dados
  3. Escrevendo um serviço de banco de dados CRUD
  4. Configurando um controlador de API