Al desarrollar .NET y .NET Core basados en bases de datos, independientemente de la base de datos que pretendemos implementar al final, a menudo querremos trabajar con un motor de base de datos que sea liviano y rápido, para poder ejecutar pruebas rápidamente y acelerar el desarrollo. . Aquí SQLite es una opción ideal.
Puede utilizar SQLite para obtener un acceso a los datos más rápido y ocupar menos espacio. La base de datos SQLite generalmente se almacena como un archivo de disco único, aunque también puede funcionar como una base de datos en memoria. Sin embargo, a diferencia de una base de datos en memoria, SQLite le permite consultar datos sin tener que cargar todo el conjunto de datos en la memoria.
Dapper: el “micro ORM” ligero y de código abierto que he creado escrito acerca de a menudo— admite muchas bases de datos, incluidas SQL Server, MySQL, SQLite, SQL CE y Firebird. Al utilizar Dapper en sus aplicaciones, puede simplificar el acceso a los datos y al mismo tiempo garantizar un alto rendimiento. En este artículo, examinaremos cómo trabajar con una base de datos SQLite usando Dapper en aplicaciones ASP.NET Core.
Para utilizar los ejemplos de código proporcionados en este artículo, debe tener Visual Studio 2022 instalado en su sistema. Si aún no tienes una copia, puedes descargue Visual Studio 2022 aquí.
Cree un proyecto de API web ASP.NET Core en Visual Studio 2022
Para crear un proyecto de API web ASP.NET Core en Visual Studio 2022, siga los pasos que se describen a continuación.
- Inicie el IDE de Visual Studio 2022.
- Haga clic en «Crear nuevo proyecto».
- En la ventana «Crear nuevo proyecto», seleccione «ASP.NET Core Web API» de la lista de plantillas que se muestran.
- Haga clic en Siguiente.
- En la ventana «Configura tu nuevo proyecto», especifica el nombre y la ubicación del nuevo proyecto. Opcionalmente, marque la casilla de verificación «Colocar solución y proyecto en el mismo directorio», según sus preferencias.
- Haga clic en Siguiente.
- En la ventana «Información adicional» que se muestra a continuación, seleccione «.NET 8.0 (soporte a largo plazo)» como versión del marco. Asegúrese de que la casilla de verificación que dice «Usar controladores» no esté marcada, ya que no usaremos controladores en este proyecto.
- En otra parte de la ventana «Información adicional», deje el «Tipo de autenticación» configurado en «Ninguno» (el valor predeterminado) y asegúrese de que las casillas de verificación «Habilitar compatibilidad con Open API», «Configurar para HTTPS» y «Habilitar Docker» permanezcan sin marcar. . No utilizaremos ninguna de esas funciones aquí.
- Haga clic en Crear.
Usaremos este proyecto ASP.NET Core Web API para trabajar con los ejemplos de código que se proporcionan en las secciones siguientes.
Instale los paquetes Dapper y SQLite NuGet
En este ejemplo, usaremos Dapper para conectarnos y trabajar con una base de datos SQLite. Por lo tanto, necesitaremos instalar los paquetes Dapper y SQLite NuGet en el proyecto. Para hacer esto, seleccione el proyecto en la ventana del Explorador de soluciones, luego haga clic derecho y seleccione «Administrar paquetes NuGet».
En la ventana del Administrador de paquetes NuGet, busque los paquetes Dapper y Microsoft.Data.Sqlite e instálelos. Alternativamente, puede instalar los paquetes a través de la consola del Administrador de paquetes NuGet ingresando el siguiente comando.
PM> Install-Package DapperPM> Install-Package Microsoft.Data.Sqlite
Cree un nuevo DbContext en EF Core
DbContext es un componente integral de Entity Framework Core que representa una sesión de conexión con la base de datos. Cree una nueva clase denominada CustomDbContext extendiendo la clase DbContext de EF Core e ingrese el siguiente código allí.
public class CustomDbContext : DbContext { protected override void OnConfiguring (DbContextOptionsBuilder optionsBuilder) { optionsBuilder.UseInMemoryDatabase(databaseName: "IDGSampleDb"); } public DbSet<User> Users { get; set; } }
Crear una base de datos SQLite
Para crear una nueva base de datos SQLite, todo lo que tiene que hacer es crear una nueva instancia de la clase SqliteConnection y pasar su nombre para la base de datos como parámetro a su constructor como se muestra a continuación.
string databaseName = "demo.db"; _ = new SqliteConnection("Data Source=" + databaseName);
Tenga en cuenta el uso del literal _ (guión bajo) en el lado izquierdo del operador de asignación. Esto también se conoce como descarte y se utiliza para informar al compilador que incluso si el método devuelve un valor, no desea utilizarlo.
Una vez que se haya creado la base de datos SQLite, puede utilizar el siguiente fragmento de código para crear una tabla en la base de datos.
sqliteConnection.Execute( @"create table Author ( ID integer identity primary key, FirstName varchar(50) not null, LastName varchar(50) not null, Address nvarchar(100) not null )");
La Figura 1 muestra la base de datos y su tabla creada en el DBBrowser de SQLiteStudio.
La siguiente clase llamada CustomDataContext contiene el código completo para crear una base de datos SQLite y una tabla dentro de ella.
using Dapper; using Microsoft.Data.Sqlite; public class CustomDataContext { private SqliteConnection CreateDatabaseConnection(string databaseName) { return new SqliteConnection("Data Source=" + databaseName); } public async Task<SqliteConnection> CreateDatabase(string databaseName) { using (var sqliteConnection = CreateDatabaseConnection(databaseName)) { await sqliteConnection.ExecuteAsync( @"CREATE TABLE IF NOT EXISTS Author ( Id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, FirstName TEXT NOT NULL, LastName TEXT NOT NULL, Address TEXT NOT NULL )"); return sqliteConnection; } } }
Puede llamar al método CreateDatabase de la clase CustomDataContext y pasar el nombre de la base de datos SQLite que desea crear usando el siguiente código.
await new CustomDataContext().CreateDatabase("demo.db");
Cree un repositorio de autor y una interfaz en ASP.NET Core
Creemos ahora un repositorio, llamado Author, que comprenderá dos tipos: la interfaz IAuthorRepository y la clase AuthorRepository. Cada uno de estos tipos utilizará la clase Autor como modelo. El código fuente de la clase de modelo Author se proporciona a continuación.
public class Author { public int Id { get; set; } public string FirstName { get; set; } public string LastName { get; set; } public string Address { get; set; } }
A continuación, cree una nueva interfaz llamada IAuthorRepository y reemplace el código generado con la siguiente lista de códigos.
public interface IAuthorRepository { Task<IEnumerable<Author>> GetAll(); Task<Author> GetById(int id); Task Create(Author Author); Task Update(Author Author); Task Delete(int id); }
La clase AuthorRepository implementará cada uno de los métodos de la interfaz IAuthorRepository como se muestra a continuación.
public class AuthorRepository : IAuthorRepository { private CustomDataContext _context; private string databaseName = "demo.db"; public AuthorRepository(CustomDataContext context) { _context = context; } public async Task<IEnumerable<Author>> GetAll() { using var connection = await _context.CreateDatabase(databaseName); var sql = "SELECT * FROM Author"; return await connection.QueryAsync<Author>(sql); } public async Task<Author> GetById(int id) { using var sqliteConnection = await _context.CreateDatabase(databaseName); string sql = "SELECT * FROM Author WHERE Id = @id"; return await sqliteConnection. QueryFirstOrDefaultAsync<Author>(sql, new { id }); } public async Task Create(Author Author) { using var sqliteConnection = await _context.CreateDatabase(databaseName); string sql = "INSERT INTO Author (FirstName, LastName, Address) " + "VALUES (@FirstName, @LastName, @Address)"; await sqliteConnection.ExecuteAsync(sql, Author); } public async Task Update(Author Author) { using var sqliteConnection = await _context.CreateDatabase(databaseName); string sql = "UPDATE Author SET FirstName = @FirstName, " + "LastName = @LastName, Address = @Address WHERE Id = @Id"; await sqliteConnection.ExecuteAsync(sql, Author); } public async Task Delete(int id) { using var sqliteConnection = await _context.CreateDatabase(databaseName); string sql = "DELETE FROM Author WHERE Id = @id"; await sqliteConnection.ExecuteAsync(sql, new { id }); } }
Registrar dependencias en ASP.NET Core
A continuación, debe registrar las dependencias con la canalización de procesamiento de solicitudes para poder utilizar la inyección de dependencias para crear estas instancias donde las necesite. El siguiente código muestra cómo puede registrar instancias de CustomDataContext y AuthorRepository en el archivo Program.cs.
builder.Services.AddScoped<CustomDataContext>(); builder.Services.AddScoped<IAuthorRepository, AuthorRepository>();
Cree puntos finales HTTP en ASP.NET Core
Ahora puede utilizar el siguiente código para crear los puntos finales para realizar operaciones CRUD (crear, leer, actualizar, eliminar) en la base de datos.
app.MapGet("/authors/{id}", async (int id, IAuthorRepository repository) => await repository.GetById(id)); app.MapPut("/authors", async (Author author, IAuthorRepository repository) => await repository.Update(author)); app.MapPost("/authors", async (Author author, IAuthorRepository repository) => await repository.Create(author)); app.MapDelete("/authors/{id}", async (int id, IAuthorRepository repository) => await repository.Delete(id));
Y eso es todo lo que necesitas hacer. Ahora puede invocar los puntos finales según sea necesario. Por ejemplo, puede invocar el punto final HTTP Get /authors para mostrar todos los registros de autor en el navegador web, como se muestra en la Figura 2.
SQLite es liviano, rápido y fácil de usar, pero también tiene ciertas desventajas. No es escalable ni adecuado para almacenar volúmenes masivos de datos. Para el almacenamiento de datos a gran escala y aplicaciones de alto tráfico que atienden a muchos usuarios simultáneos, debe considerar una base de datos cliente/servidor como SQL Server o MySQL. Pero SQLite brilla como compañero de desarrollo y para uso en aplicaciones de escritorio, móviles, IoT y integradas.
Copyright © 2024 IDG Communications, Inc.