Saltar al pie de página
  1. IronPDF
  2. Blog de IronPDF
  3. .NET Ayuda
  4. Sqlite C# .NET
.NET AYUDA

Sqlite C# .NET (Cómo funciona para desarrolladores)

Jacob Mellor, Director de Tecnología @ Team Iron
Jacob Mellor
Actualizado:

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.

Cómo usar SQLite en C#

  1. Descargar la biblioteca de SQLite
  2. Crear una base de datos e insertar los datos
  3. Leer usando el lector
  4. Usar SQLite mediante el método de consulta de Entity Framework y LINQ
  5. Generar informe en PDF usando IronPDF

¿Qué es SQLite?

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 le 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:

  • Instalar el paquete NuGet de Microsoft.Data.Sqlite
  • Crear una conexión SQLite y ejecutar comandos SQL
  • Crear y poblar tablas usando lectores de datos y parámetros
  • Consultar datos usando lectores de datos
  • Implementar EntityFramework Core
  • Consultar datos usando LINQ
  • Generar informe en PDF

Instalación de la biblioteca SQLite

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:

Install-Package Microsoft.Data.Sqlite

El comando anterior instalará el paquete como se muestra a continuación.

Creación de una base de datos SQLite

Para trabajar con una base de datos SQLite, necesita crear un objeto SqliteConnection que represente la conexión al archivo de base de datos. Puede 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 programa de abajo 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 (var connection = new SqliteConnection("Data Source=employee.db"))
{
    connection.Open();
    // ...
}
Using connection = New SqliteConnection("Data Source=employee.db")
	connection.Open()
	' ...
End Using
$vbLabelText   $csharpLabel

La declaración using asegura que la conexión se cierre y elimine cuando salga del ámbito. Para ejecutar comandos SQL, necesita crear un objeto SqlCommand y asociarlo con la conexión. Puede establecer la propiedad CommandText a la declaración SQL que desea ejecutar, y opcionalmente agregar parámetros a la colección Parameters. Puede entonces llamar a uno de los métodos del objeto SqlCommand para ejecutar el comando, como ExecuteNonQuery, ExecuteScalar o ExecuteReader.

Crear tabla en SQLite

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 (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 Using
$vbLabelText   $csharpLabel

Insertar datos en una tabla

Para insertar datos en una tabla, puede usar el mismo objeto SqlCommand y establecer la propiedad CommandText a una declaración 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 (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 Using
$vbLabelText   $csharpLabel

Leer datos de SQLite

Para leer datos de una tabla, puede utilizar el método ExecuteReader del objeto SqlCommand y establecer la propiedad CommandText a una declaración SELECT. Esto devolverá un objeto SqliteDataReader que le permitirá iterar sobre las filas y acceder a los valores por nombre de columna o índice. Puede usar el método Read para moverse a la siguiente fila, y los métodos GetXXX para obtener los valores como el tipo de datos 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 (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 Using
$vbLabelText   $csharpLabel

Resultado

La salida de este código es:

Sqlite C# .NET (Cómo funciona para el desarrollador): Figura 1 - Salida

Consulta de datos

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 necesita 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 desea 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; }
}
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 Class
$vbLabelText   $csharpLabel

Para crear el contexto de la base de datos, necesita usar la clase DbContextOptionsBuilder y especificar la cadena de conexión y el proveedor de base de datos. También puede 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();
}
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 Using
$vbLabelText   $csharpLabel

Para insertar datos en la base de datos, puede usar los métodos Add o AddRange de la propiedad DbSet y pasar los objetos que desea insertar. También puede usar el método SaveChanges para comprometer los cambios en 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();
    }
}
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 Sub
$vbLabelText   $csharpLabel

Para consultar datos, puede usar los métodos LINQ o expresiones 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 (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 Using
$vbLabelText   $csharpLabel

Supongamos que tenemos un escenario donde necesitamos crear un archivo PDF que contenga la lista de Stocks. Podemos hacer eso fácilmente usando IronPDF.

Presentando 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");
    }
}
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 Class
$vbLabelText   $csharpLabel

Instalar IronPDF

Para instalar IronPDF en nuestro proyecto, escriba el siguiente comando en la consola del administrador de paquetes.

Install-Package IronPdf

Este comando instalará IronPDF junto con todas sus dependencias.

Agregar clave de licencia

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";
IronPdf.License.LicenseKey = "IRONSUITE.ABC.XYZ.MYCOMPANY.COM.ABC-DEPLOYMENT.TRIAL-P45MXL.TRIAL.EXPIRES.31.JAN.2028"
$vbLabelText   $csharpLabel

Crear archivo PDF con lista de existencias

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");
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 Microsoft.VisualBasic

Dim optionsBuilder = 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 = 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 stock
End Using
builder.Append("</table></body></html>")
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(builder.ToString())
pdf.SaveAs("stock.pdf")
$vbLabelText   $csharpLabel

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.

El resultado es el siguiente

Sqlite C# .NET (Cómo funciona para el desarrollador): Figura 2 - Salida de Tabla de Stocks

Conclusión

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.

Preguntas Frecuentes

¿Qué es SQLite y por qué es popular para el desarrollo en .NET?

SQLite es un motor de base de datos relacional ligero y autónomo que se usa ampliamente en el desarrollo de .NET debido a su velocidad, fiabilidad y capacidades multiplataforma. Puede ser incrustado en aplicaciones sin necesidad de un componente de servidor separado.

¿Cómo puedo integrar SQLite en mi aplicación .NET?

Puedes integrar SQLite en tu aplicación .NET instalando el paquete Microsoft.Data.Sqlite NuGet. Esto proporciona interfaces ADO.NET, permitiéndote crear, conectar y manipular bases de datos SQLite dentro de aplicaciones Consola, Escritorio, Web o Móviles.

¿Cómo creo y conecto a una base de datos SQLite en C#?

Para crear y conectar a una base de datos SQLite en C#, utiliza la clase SqliteConnection para establecer una conexión. Luego puedes ejecutar comandos SQL para crear tablas y manipular datos usando el objeto SqlCommand.

¿Puedo usar consultas LINQ con SQLite en .NET?

Sí, puedes usar consultas LINQ con SQLite en .NET utilizando Entity Framework Core. Esto permite un mapeo objeto-relacional, habilitándote para realizar consultas LINQ en propiedades DbSet dentro de una clase DbContext.

¿Cómo puedo generar informes PDF a partir de datos de bases de datos SQLite?

Puedes generar informes PDF a partir de datos de bases de datos SQLite utilizando IronPDF. Convirtiendo representaciones HTML de tus datos o usando directamente el contenido de la base de datos, puedes crear informes PDF detallados y exportarlos utilizando las capacidades de renderización de IronPDF.

¿Cómo soluciono problemas comunes de SQLite en aplicaciones .NET?

Los problemas comunes de SQLite en aplicaciones .NET se pueden solucionar asegurando la instalación adecuada del paquete Microsoft.Data.Sqlite, verificando la sintaxis SQL y comprobando las cadenas de conexión. Las herramientas de depuración y los registros también pueden ayudar a identificar y resolver errores.

¿Cómo instalo y uso una biblioteca PDF en un proyecto .NET?

Para instalar una biblioteca PDF como IronPDF en un proyecto .NET, ejecuta Install-Package IronPdf en la Consola del Administrador de Paquetes. Una vez instalado, IronPDF te permite crear, editar y leer archivos PDF utilizando su extensa API.

¿Cuáles son las ventajas de usar SQLite con .NET?

Usar SQLite con .NET ofrece ventajas como simplicidad, no necesidad de un servidor separado, soporte multiplataforma y un rendimiento confiable. Es ideal para aplicaciones ligeras y puede integrarse fácilmente utilizando bibliotecas como Microsoft.Data.Sqlite.

Jacob Mellor, Director de Tecnología @ Team Iron
Jacob Mellor
  Chatea con el equipo de ingeniería ahora
Director de Tecnología

Jacob Mellor es Director de Tecnología en Iron Software y un ingeniero visionario que lidera la tecnología PDF en C#. Como el desarrollador original detrás de la base de código central de Iron Software, ha moldeado la arquitectura de productos de la compañía desde ...

Leer más

Artículos Relacionados

Prueba de 30 días → Producto completo. Sin límites. Sin tarjeta. Comenzar prueba gratuita