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”:
![]()
Dê um nome a ele e selecione “API”, pois não estamos construindo um front-end ASP.NET aqui.
![]()
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.
![]()
![]()
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”.
![]()
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:
![]()
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.
![]()
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.
![]()
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.
![]()
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.



