AYUDA .NET

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

Actualizado 14 de enero, 2024
Compartir:

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 constituye una excelente opción para integrar en sus aplicaciones de sistema un control fiable de soluciones de bases de datos. Este artículo se adentrará en el mundo de las transacciones SQLite, explorando sus características, ventajas y cómo utilizarlas en tus proyectos .NET de forma eficaz.

Cómo utilizar SQLite en C#

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

¿Qué es SQLite?

SQLite es un popular motor de bases de datos de código abierto que puede integrarse en las aplicaciones sin necesidad de un componente de servidor independiente. Es rápido, fiable y multiplataforma. SQLite puede utilizarse con aplicaciones de proyectos .NET a través de diversas bibliotecas que proporcionan interfaces ADO.NET. Una de estas bibliotecas es Microsoft.Data.SQLite. Esto le permite utilizar SQLite como fuente de datos para sus aplicaciones .NET, ya sean de consola, escritorio, web o móviles. También puede utilizar Entity Framework Core para realizar mapeos objeto-relacionales y consultar su base de datos SQLite utilizando LINQ.

Este artículo muestra cómo utilizar Microsoft.Data.Sqlite para desarrollar, conectar y manipular un SQLite en una Aplicación de Consola .NET. Aprenderás a:

  • Instale el paquete Microsoft.Data.Sqlite NuGet
  • Crear una conexión SQLite y ejecutar comandos SQL
  • Crear y rellenar tablas utilizando lectores de datos y parámetros
  • Consulta de datos mediante lectores de datos
  • Implantar EntityFramework Core
  • Consulta de datos mediante LINQ
  • Generar informe PDF

Instalación de la biblioteca SQLite

Para utilizar Microsoft.Data.Sqlite, debe instalar el paquete NuGet que contiene la biblioteca y sus dependencias. Puede hacerlo utilizando el gestor de paquetes de Visual Studio, la CLI de .NET Core o cualquier otra herramienta compatible con NuGet. Este artículo utilizará el Gestor de Paquetes para crear una Aplicación de Consola e instalar Microsoft.Data.Sqlite. Para ello, 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, es necesario crear un objeto SQLiteConnection que represente la conexión con el archivo de base de datos. Puede especificar el nombre del archivo y otras opciones en la conexión. Si el fichero no existe, se creará automáticamente. Por ejemplo, el siguiente programa crea una conexión a un archivo de base de datos llamado empleado.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
VB   C#

La sentencia using garantiza que la conexión se cierre y se elimine cuando salga del ámbito. Para ejecutar comandos SQL, es necesario crear un objeto SQLiteCommand y asociarlo a la conexión. Puede establecer la propiedad CommandText a la sentencia SQL que desea ejecutar, y opcionalmente añadir parámetros a la colección Parameters. A continuación, puede llamar a uno de los métodos del objeto SQLiteCommand para ejecutar el comando, como ExecuteNonQuery, ExecuteScalar o ExecuteReader.

Crear tabla en SQLite

El siguiente código crea una tabla llamada Empleado utilizando 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
VB   C#

Insertar datos en una tabla

Para insertar datos en una tabla, puede utilizar el mismo objeto SQLiteCommand y establecer la propiedad CommandText en una sentencia INSERT. Por ejemplo, el siguiente código inserta tres filas en la tabla Empleado.

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
VB   C#

Leer datos de SQLite

Para leer datos de una tabla, puede utilizar el método ExecuteReader del objeto SQLiteCommand y establecer la propiedad CommandText a una sentencia SELECT. Esto devolverá un objeto SQLiteDataReader que permite iterar sobre las filas y acceder a los valores por nombre de columna o índice. Puede utilizar el método Read para pasar a la siguiente fila, y el método GetXXX para obtener los valores como el tipo de datos apropiado. Por ejemplo, el siguiente código lee todas las filas de la tabla Empleado 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).ToString();
            string designation = reader.GetString(3).ToString();
            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).ToString();
            string designation = reader.GetString(3).ToString();
            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).ToString()
			Dim designation As String = reader.GetString(3).ToString()
			Console.WriteLine($"{id}: {firstName} - {lastName} - {designation}")
		Loop
	End Using
End Using
VB   C#

Salida

La salida de este código es:

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

Consulta de datos

Si prefiere utilizar LINQ para consultar su base de datos SQLite, puede utilizar Entity Framework Core para asignar sus tablas a clases y realizar consultas utilizando expresiones LINQ. Para ello, debe 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 desee asignar 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
VB   C#

Para crear el contexto de base de datos, es necesario utilizar la clase DbContextOptionsBuilder y especificar la cadena de conexión y el proveedor de base de datos. También puede utilizar 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 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
VB   C#

Para insertar datos en la base de datos, puede utilizar los métodos Add o AddRange de la propiedad DbSet y pasar los objetos que desea insertar. También puede utilizar el método SaveChanges para confirmar 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
VB   C#

Para consultar datos, puede utilizar los métodos o expresiones LINQ sobre la propiedad DbSet y aplicar filtros, proyecciones, agregaciones y otras operaciones. Las consultas se traducirán a sentencias SQL y se ejecutarán en la base de datos. Por ejemplo, el siguiente código consulta las acciones cuyo precio es inferior 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
VB   C#

Supongamos que necesitamos crear un archivo PDF que contenga la lista de acciones. Podemos hacerlo fácilmente utilizando IronPDF.

Presentación de IronPDF

IronPDF es una biblioteca que le ayuda a crear, editary leer PDF en sus aplicaciones .NET sin necesidad de varios paquetes. Puede generar PDF a partir de HTML, URL, JavaScript, CSS y muchos formatos de imagen, además de añadir cabeceraspies de página, firmas, archivos adjuntos y contraseñas. También admite compatibilidad multiplataforma, multihilo y soporte asíncrono.

Instalar IronPDF

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

Install-Package IronPdf

Este comando instalará IronPDF junto con todas sus dependencias.

Añadir clave de licencia

IronPDF requiere una clave de licencia para su uso. Podemos obtener fácilmente una clave de licencia de prueba en aquí.

Añada este código al inicio de su aplicación, antes de utilizar IronPDF. Este enfoque funciona y es universalmente eficaz y sencillo. Funciona para .NET Core y también para aplicaciones .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"
VB   C#

Crear un archivo PDF a partir de una lista de existencias

Este código C# genera un informe PDF a partir de datos de existencias almacenados en una base de datos SQLite. Crea dinámicamente una tabla HTML, la rellena con información sobre las existencias y utiliza un renderizador de PDF basado en Chrome para convertir la tabla en un archivo descargable "stock.pdf", lo que facilita la elaboración de informes y la distribución eficaz de los detalles de las existencias.

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")
VB   C#

El fragmento de código C# anterior está diseñado para crear una tabla HTML que muestre información de existencias a partir de una base de datos SQLite y convertirla posteriormente en un archivo PDF. Utiliza la biblioteca Entity Framework Core para interactuar con la base de datos. Inicialmente, configura un DbContextOptionsBuilder para utilizar SQLite con una cadena de conexión específica. A continuación, el código 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 sobre acciones, rellena la tabla HTML con los datos recuperados y, por último, utiliza un renderizador de PDF basado en Chrome para convertir el contenido HTML en un archivo PDF denominado "stock.pdf". El PDF resultante contendrá una tabla con los símbolos, nombres y precios de las acciones.

La salida es como

Sqlite C# .NET (Cómo funciona para desarrolladores): Figura 2 - Salida de la Tabla de Stock

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 explora la integración de SQLite en aplicaciones .NET, mostrando sus principales características y ventajas. El código proporcionado demuestra los 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 eficaz de los datos. La incorporación de IronPDF ilustró la manera de generar un informe en PDF de la base de datos SQLite, mejorando las capacidades de la aplicación para la elaboración de informes y la distribución de datos.

IronPDF ofrece varios licencias en función del número de promotores, ubicaciones, proyectos y necesidades de redistribución. Las licencias son perpetuas e incluyen un año de asistencia y actualizaciones gratuitas.

< ANTERIOR
Doble signo de interrogación en C# (Cómo funciona para el desarrollador)
SIGUIENTE >
Datatables .NET (Cómo funciona para desarrolladores)

¿Listo para empezar? Versión: 2024.6 recién publicada

Comenzar prueba gratuita Descargas totales: 9,602,420
Ver licencias >