SQLite es un motor de base de datos relacional popular, ligero y autónomo que se utiliza ampliamente en diversas aplicaciones de acceso a datos y plataformas de entorno. En el contexto del desarrollo .NET, el código fuente de SQLite es una excelente opción para integrar un control de solución de base de datos confiable en sus aplicaciones de sistema. Este artículo explorará el mundo de las transacciones SQLite, analizando sus características, ventajas y cómo usarlas eficazmente en sus proyectos .NET.
SQLite es un motor de base de datos de código abierto popular que se puede incrustar en aplicaciones sin requerir un componente de servidor separado. Es rápido, fiable y multiplataforma. SQLite puede utilizarse con aplicaciones de proyectos .NET a través de diversas bibliotecas que proporcionan interfaces de ADO.NET. Una de estas bibliotecas es Microsoft.Data.SQLite. Esto le permite usar SQLite como fuente de datos para sus aplicaciones .NET, ya sean de consola, escritorio, web o móviles. También puede usar Entity Framework Core para realizar mapeo objeto-relacional y consultar su base de datos SQLite usando LINQ.
Este artículo te muestra cómo usar Microsoft.Data.Sqlite para desarrollar, conectar y manipular una base de datos SQLite en una aplicación de consola .NET. Aprenderá cómo:
Para usar Microsoft.Data.Sqlite, necesita instalar el paquete NuGet que contiene la biblioteca y sus dependencias. Puede hacer esto usando el administrador de paquetes de Visual Studio, el CLI de .NET Core o cualquier otra herramienta que soporte NuGet. Este artículo utiliza el administrador de paquetes para crear una aplicación de consola e instalar Microsoft.Data.Sqlite. Para hacerlo, abra una consola del administrador de paquetes y ejecute los siguientes comandos:
El comando anterior instalará el paquete como se muestra a continuación.
Para trabajar con una base de datos SQLite, necesitas crear un objeto SqliteConnection que represente la conexión al archivo de base de datos. Puedes especificar el nombre del archivo y otras opciones en la cadena de conexión. Si el archivo no existe, se creará automáticamente. Por ejemplo, el siguiente programa crea una conexión a un archivo de base de datos llamado employee.db en el directorio actual:
using (var connection = new SqliteConnection("Data Source=employee.db"))
{
connection.Open();
// ...
}Using connection = New SqliteConnection("Data Source=employee.db")
connection.Open()
' ...
End UsingLa instrucción using asegura que la conexión se cierre y se elimine cuando salga del alcance. Para ejecutar comandos SQL, necesitas crear un objeto SqlCommand y asociarlo con la conexión. Puedes establecer la propiedad CommandText a la sentencia SQL que deseas ejecutar, y opcionalmente agregar parámetros a la colección Parameters. Luego puedes llamar a uno de los métodos del objeto SqlCommand para ejecutar el comando, como ExecuteNonQuery, ExecuteScalar o ExecuteReader.
El siguiente código crea una tabla llamada Employee usando el método ExecuteNonQuery:
using (var connection = new SqliteConnection("Data Source=employee.db"))
{
connection.Open();
var command = connection.CreateCommand();
command.CommandText = @"CREATE TABLE Employee (
Id INTEGER PRIMARY KEY,
FirstName TEXT NOT NULL,
LastName TEXT NOT NULL,
Designation TEXT NOT NULL )";
command.ExecuteNonQuery();
}Using connection = New SqliteConnection("Data Source=employee.db")
connection.Open()
Dim command = connection.CreateCommand()
command.CommandText = "CREATE TABLE Employee (
Id INTEGER PRIMARY KEY,
FirstName TEXT NOT NULL,
LastName TEXT NOT NULL,
Designation TEXT NOT NULL )"
command.ExecuteNonQuery()
End UsingPara insertar datos en una tabla, puedes usar el mismo objeto SqlCommand y establecer la propiedad CommandText a una sentencia INSERT. Por ejemplo, el siguiente código inserta tres filas en la tabla Employee.
using (var connection = new SqliteConnection("Data Source=employee.db"))
{
var command = connection.CreateCommand();
StringBuilder builder = new StringBuilder();
builder.Append("INSERT INTO Employee VALUES(1, 'John', 'Sami', 'CEO');");
builder.Append("INSERT INTO Employee VALUES(2, 'David', 'Watson', 'Software Engineer');");
builder.Append("INSERT INTO Employee VALUES(3, 'Victor', 'Khan', 'Content Writer');");
connection.Open();
command.CommandText = builder.ToString();
command.ExecuteNonQuery();
}Using connection = New SqliteConnection("Data Source=employee.db")
Dim command = connection.CreateCommand()
Dim builder As New StringBuilder()
builder.Append("INSERT INTO Employee VALUES(1, 'John', 'Sami', 'CEO');")
builder.Append("INSERT INTO Employee VALUES(2, 'David', 'Watson', 'Software Engineer');")
builder.Append("INSERT INTO Employee VALUES(3, 'Victor', 'Khan', 'Content Writer');")
connection.Open()
command.CommandText = builder.ToString()
command.ExecuteNonQuery()
End UsingPara leer datos de una tabla, puedes usar el método ExecuteReader del objeto SqlCommand y establecer la propiedad CommandText a una sentencia SELECT. Esto devolverá un objeto SqliteDataReader que te permitirá iterar sobre las filas y acceder a los valores por nombre de columna o índice. Puedes usar el método Read para moverte a la siguiente fila, y los métodos GetXXX para obtener los valores como el tipo de dato apropiado. Por ejemplo, el siguiente código lee todas las filas de la tabla Employee y las imprime en la consola:
using (var connection = new SqliteConnection("Data Source=employee.db"))
{
var command = connection.CreateCommand();
command.CommandText = @"SELECT * FROM Employee";
connection.Open();
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
var id = reader.GetInt32(0);
string firstName = reader.GetString(1);
string lastName = reader.GetString(2);
string designation = reader.GetString(3);
Console.WriteLine($"{id}: {firstName} - {lastName} - {designation}");
}
}
}Using connection = New SqliteConnection("Data Source=employee.db")
Dim command = connection.CreateCommand()
command.CommandText = "SELECT * FROM Employee"
connection.Open()
Using reader = command.ExecuteReader()
Do While reader.Read()
Dim id = reader.GetInt32(0)
Dim firstName As String = reader.GetString(1)
Dim lastName As String = reader.GetString(2)
Dim designation As String = reader.GetString(3)
Console.WriteLine($"{id}: {firstName} - {lastName} - {designation}")
Loop
End Using
End UsingLa salida de este código es:
Si prefiere usar LINQ para consultar su base de datos SQLite, puede usar Entity Framework Core para mapear sus tablas a clases y realizar consultas usando expresiones LINQ. Para hacer esto, necesita instalar el paquete Microsoft.EntityFrameworkCore.Sqlite, que depende del paquete Microsoft.Data.Sqlite. También necesitas crear una clase que herede de DbContext y represente el contexto de la base de datos. Esta clase debe tener un constructor que acepte un parámetro DbContextOptions y lo pase al constructor base. También debe tener una propiedad DbSet para cada tabla que desees mapear a una clase. Por ejemplo, el siguiente código define una clase Stock y una clase DatabaseContext:
using Microsoft.EntityFrameworkCore;
public class Stock
{
public int Id { get; set; }
public string Name { get; set; } = string.Empty;
public string Symbol { get; set; } = string.Empty;
public double Price { get; set; }
}
public class DatabaseContext : DbContext
{
public DatabaseContext(DbContextOptions options) : base(options) { }
public DbSet<Stock> Stock { get; set; }
}Imports Microsoft.EntityFrameworkCore
Public Class Stock
Public Property Id() As Integer
Public Property Name() As String = String.Empty
Public Property Symbol() As String = String.Empty
Public Property Price() As Double
End Class
Public Class DatabaseContext
Inherits DbContext
Public Sub New(ByVal options As DbContextOptions)
MyBase.New(options)
End Sub
Public Property Stock() As DbSet(Of Stock)
End ClassPara crear el contexto de la base de datos, necesitas usar la clase DbContextOptionsBuilder y especificar la cadena de conexión y el proveedor de la base de datos. También puedes usar el método Database.EnsureCreated para crear la base de datos y las tablas si no existen. Por ejemplo, el siguiente código crea el contexto de la base de datos y la base de datos:
var optionsBuilder = new DbContextOptionsBuilder<DatabaseContext>();
optionsBuilder.UseSqlite("Data Source=stock.db");
using (var context = new DatabaseContext(optionsBuilder.Options))
{
context.Database.EnsureCreated();
}Dim optionsBuilder = New DbContextOptionsBuilder(Of DatabaseContext)()
optionsBuilder.UseSqlite("Data Source=stock.db")
Using context = New DatabaseContext(optionsBuilder.Options)
context.Database.EnsureCreated()
End UsingPara insertar datos en la base de datos, puedes usar los métodos Add o AddRange de la propiedad DbSet y pasar los objetos que deseas insertar. También puedes usar el método SaveChanges para comprometer los cambios a la base de datos. Por ejemplo, el siguiente código inserta tres Stocks en la base de datos:
static void Main(string[] args)
{
var optionsBuilder = new DbContextOptionsBuilder<DatabaseContext>();
optionsBuilder.UseSqlite("Data Source=stock.db");
using (var context = new DatabaseContext(optionsBuilder.Options))
{
context.Database.EnsureCreated();
var stock = new List<Stock> {
new Stock { Id = 1, Name = "NCR", Symbol = "$$", Price = 5.6 },
new Stock { Id = 2, Name = "Google", Symbol = "GG", Price = 10.6 },
new Stock { Id = 3, Name = "Apple", Symbol = "AA", Price = 3.6 }
};
context.AddRange(stock);
context.SaveChanges();
}
}Shared Sub Main(ByVal args() As String)
Dim optionsBuilder = New DbContextOptionsBuilder(Of DatabaseContext)()
optionsBuilder.UseSqlite("Data Source=stock.db")
Using context = New DatabaseContext(optionsBuilder.Options)
context.Database.EnsureCreated()
Dim stock As New List(Of Stock) From {
New Stock With {
.Id = 1,
.Name = "NCR",
.Symbol = "$$",
.Price = 5.6
},
New Stock With {
.Id = 2,
.Name = "Google",
.Symbol = "GG",
.Price = 10.6
},
New Stock With {
.Id = 3,
.Name = "Apple",
.Symbol = "AA",
.Price = 3.6
}
}
context.AddRange(stock)
context.SaveChanges()
End Using
End SubPara consultar datos, puedes usar los métodos o expresiones LINQ sobre la propiedad DbSet y aplicar filtros, proyecciones, agregaciones y otras operaciones. Las consultas se traducirán a declaraciones SQL y se ejecutarán en la base de datos. Por ejemplo, el siguiente código consulta los stocks cuyo precio es menor a seis dólares e imprime sus nombres:
using (var context = new DatabaseContext(optionsBuilder.Options))
{
var cheapStocks = context.Stock.Where(p => p.Price < 6).Select(p => p.Name);
Console.WriteLine("Stock Less than $6 are:");
foreach (string stock in cheapStocks)
{
Console.WriteLine(stock);
}
}Using context = New DatabaseContext(optionsBuilder.Options)
Dim cheapStocks = context.Stock.Where(Function(p) p.Price < 6).Select(Function(p) p.Name)
Console.WriteLine("Stock Less than $6 are:")
For Each stock As String In cheapStocks
Console.WriteLine(stock)
Next stock
End UsingSupongamos que tenemos un escenario donde necesitamos crear un archivo PDF que contenga la lista de Stocks. Podemos hacer eso fácilmente usando IronPDF.
IronPDF es una biblioteca que le ayuda a crear, editar y leer archivos PDF en sus aplicaciones .NET sin la necesidad de múltiples paquetes. Puede generar PDFs desde HTML, URL, JavaScript, CSS y muchos formatos de imagen, así como agregar encabezados, pies de página, firmas, archivos adjuntos y contraseñas. También soporta compatibilidad multiplataforma, multihilos y soporte asincrónico.
La función HTML a PDF de IronPDF es su principal destacado, preservando todos los diseños y estilos. Genera PDFs a partir de contenido web, ideal para informes, facturas y documentación. Puedes convertir archivos HTML, URLs y cadenas HTML a PDFs de manera fluida.
using IronPdf;
class Program
{
static void Main(string[] args)
{
var renderer = new ChromePdfRenderer();
// 1. Convert HTML String to PDF
var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");
// 2. Convert HTML File to PDF
var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");
// 3. Convert URL to PDF
var url = "http://ironpdf.com"; // Specify the URL
var pdfFromUrl = renderer.RenderUrlAsPdf(url);
pdfFromUrl.SaveAs("URLToPDF.pdf");
}
}Imports IronPdf
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim renderer = New ChromePdfRenderer()
' 1. Convert HTML String to PDF
Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")
' 2. Convert HTML File to PDF
Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")
' 3. Convert URL to PDF
Dim url = "http://ironpdf.com" ' Specify the URL
Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
pdfFromUrl.SaveAs("URLToPDF.pdf")
End Sub
End ClassPara instalar IronPDF en nuestro proyecto, escriba el siguiente comando en la consola del administrador de paquetes.
Este comando instalará IronPDF junto con todas sus dependencias.
IronPDF requiere una clave de licencia para usarlo. Podemos obtener fácilmente una clave de licencia de prueba desde la Página de Licencia de Prueba de IronPDF.
Agregue este código al inicio de su aplicación antes de que se use IronPDF. Este enfoque es universalmente efectivo y sencillo, funcionando tanto para aplicaciones de .NET Core como de .NET Framework.
IronPdf.License.LicenseKey = "IRONSUITE.ABC.XYZ.MYCOMPANY.COM.ABC-DEPLOYMENT.TRIAL-P45MXL.TRIAL.EXPIRES.31.JAN.2028";IronPdf.License.LicenseKey = "IRONSUITE.ABC.XYZ.MYCOMPANY.COM.ABC-DEPLOYMENT.TRIAL-P45MXL.TRIAL.EXPIRES.31.JAN.2028"Este código de C# genera un informe en PDF a partir de datos de stocks almacenados en una base de datos SQLite. Crea dinámicamente una tabla HTML, la llena con información de stock y utiliza un renderizador de PDF basado en Chrome para convertir la tabla en un archivo "stock.pdf" descargable, facilitando la elaboración de informes y distribución de detalles de stocks.
var optionsBuilder = new DbContextOptionsBuilder<DatabaseContext>();
optionsBuilder.UseSqlite("Data Source=stock.db");
StringBuilder builder = new StringBuilder();
string style="<!DOCTYPE html>\r\n<html>\r\n<head>\r\n<style>\r\n#stock {\r\n font-family: Arial, Helvetica, sans-serif;\r\n border-collapse: collapse;\r\n width: 100%;\r\n}\r\n\r\n#stock td, #stock th {\r\n border: 1px solid #ddd;\r\n padding: 8px;\r\n}\r\n\r\n#stock tr:nth-child(even){background-color: #f2f2f2;}\r\n\r\n#stock tr:hover {background-color: #ddd;}\r\n\r\n#stock th {\r\n padding-top: 12px;\r\n padding-bottom: 12px;\r\n text-align: left;\r\n background-color: #04AA6D;\r\n color: white;\r\n}\r\n</style>\r\n</head>\r\n<body>\r\n\r\n<h1>A Stock Table</h1>";
builder.Append(style);
builder.Append("<table id=\"stock\"><tr><td>Stock Symbol</td><td>Stock Name</td><td>Stock Price</td></tr>");
using (var context = new DatabaseContext(optionsBuilder.Options))
{
var stocks = context.Stock;
foreach (Stock stock in stocks)
{
builder.Append($"<tr><td>{stock.Symbol}</td><td>{stock.Name}</td><td>{stock.Price}</td></tr>");
}
}
builder.Append("</table></body></html>");
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(builder.ToString());
pdf.SaveAs("stock.pdf");Imports System.Text
Imports Microsoft.EntityFrameworkCore
Dim optionsBuilder As New DbContextOptionsBuilder(Of DatabaseContext)()
optionsBuilder.UseSqlite("Data Source=stock.db")
Dim builder As New StringBuilder()
Dim style As String = "<!DOCTYPE html>" & vbCrLf & "<html>" & vbCrLf & "<head>" & vbCrLf & "<style>" & vbCrLf & "#stock {" & vbCrLf & " font-family: Arial, Helvetica, sans-serif;" & vbCrLf & " border-collapse: collapse;" & vbCrLf & " width: 100%;" & vbCrLf & "}" & vbCrLf & vbCrLf & "#stock td, #stock th {" & vbCrLf & " border: 1px solid #ddd;" & vbCrLf & " padding: 8px;" & vbCrLf & "}" & vbCrLf & vbCrLf & "#stock tr:nth-child(even){background-color: #f2f2f2;}" & vbCrLf & vbCrLf & "#stock tr:hover {background-color: #ddd;}" & vbCrLf & vbCrLf & "#stock th {" & vbCrLf & " padding-top: 12px;" & vbCrLf & " padding-bottom: 12px;" & vbCrLf & " text-align: left;" & vbCrLf & " background-color: #04AA6D;" & vbCrLf & " color: white;" & vbCrLf & "}" & vbCrLf & "</style>" & vbCrLf & "</head>" & vbCrLf & "<body>" & vbCrLf & vbCrLf & "<h1>A Stock Table</h1>"
builder.Append(style)
builder.Append("<table id=""stock""><tr><td>Stock Symbol</td><td>Stock Name</td><td>Stock Price</td></tr>")
Using context As New DatabaseContext(optionsBuilder.Options)
Dim stocks = context.Stock
For Each stock As Stock In stocks
builder.Append($"<tr><td>{stock.Symbol}</td><td>{stock.Name}</td><td>{stock.Price}</td></tr>")
Next
End Using
builder.Append("</table></body></html>")
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(builder.ToString())
pdf.SaveAs("stock.pdf")El fragmento de código C# anterior está diseñado para crear una tabla HTML que muestra información de stock desde una base de datos SQLite y posteriormente convertirla en un archivo PDF. Utiliza la biblioteca Entity Framework Core para interactuar con la base de datos. Inicialmente, configura un DbContextOptionsBuilder para usar SQLite con una cadena de conexión específica. El código luego construye una cadena HTML con estilos CSS incrustados para la apariencia de la tabla, crea una estructura de tabla con encabezados, consulta la base de datos SQLite para obtener información del stock, llena la tabla HTML con los datos recuperados y finalmente, utiliza un renderizador de PDF basado en Chrome para convertir el contenido HTML en un archivo PDF llamado "stock.pdf". El PDF resultante contendrá una tabla presentando símbolos de stocks, nombres y precios.
En conclusión, aprovechar SQLite en .NET para la gestión de bases de datos ofrece una solución ligera y versátil. Este artículo exploró la integración de SQLite en aplicaciones .NET, mostrando sus características clave y ventajas. El código proporcionado demostró pasos prácticos para crear, conectar y manipular una base de datos SQLite en una aplicación de consola .NET. Además, destacó el uso de Microsoft.Data.Sqlite y Entity Framework Core para un manejo eficiente de datos. La incorporación de IronPDF ilustró cómo generar un informe PDF de la base de datos SQLite sin problemas, mejorando las capacidades de la aplicación para la elaboración de informes y distribución de datos.
IronPDF ofrece varias opciones de licencias, dependiendo del número de desarrolladores, ubicaciones, proyectos y necesidades de redistribución. Las licencias son perpetuas e incluyen un año de soporte y actualizaciones gratuitas.
Jacob Mellor es Director de Tecnología de Iron Software y un ingeniero visionario pionero en la tecnología C# PDF. Como desarrollador original de la base de código principal de Iron Software, ha dado forma a la arquitectura de productos de la empresa desde su creación, transformándola, junto con el director ejecutivo Cameron Rimington, en una empresa de más de 50 personas que presta servicios a la NASA, Tesla y organismos gubernamentales de todo el mundo.
IronPDF es parte de IRONSUITE
10 productos API .NET para tus documentos de oficina
Cuando necesitas que tu PDF se parezca al HTML, rápido.
