.NET AYUDA

C# SQLite (Cómo funciona para desarrolladores)

Q: ¿Cómo puedo realizar operaciones CRUD en una base de datos SQLite usando C#?

Usando comandos SQL como INSERT , SELECT , UPDATE y DELETE , puede realizar operaciones CRUD en una base de datos SQLite en C#. Estos comandos pueden ejecutarse utilizando un objeto SQLiteCommand .

Jacob Mellor

Actualizado:julio 28, 2025

Introducción a SQLite

SQLite es un motor de base de datos autónomo, sin servidor y sin configuración que se utiliza en varias aplicaciones, incluidas aplicaciones de escritorio, web y móviles. En este tutorial, profundizaremos en el uso de SQLite con C#. Con ejemplos simples y fáciles de entender, aprenderás a crear, gestionar e interactuar con una base de datos SQLite.

¿Qué es SQLite?

SQLite es una base de datos ligera y eficiente que almacena datos en un solo archivo. A diferencia de las bases de datos tradicionales, no requiere un servidor separado. Esto lo hace una gran opción para aplicaciones que necesitan una base de datos sin la complejidad de un sistema de base de datos completo.

Cómo configurar SQLite en C#;

Uso del Administrador de paquetes NuGet

Para trabajar con SQLite en un proyecto C#, necesitarás instalar la librería necesaria para SQLite. Esto se puede hacer a través del Administrador de Paquetes de NuGet.

Abre Visual Studio y crea una nueva aplicación de consola.
Haz clic derecho en el proyecto y selecciona "Administrar paquetes NuGet".
Busca "SQLite" e instala el paquete.

Establecimiento de una conexión

Cadena de conexión

Una cadena de conexión es una cadena que especifica información sobre una fuente de datos y cómo conectarse a ella. En SQLite, la cadena de conexión a menudo se verá así:

string connectionString = "Data Source=mydatabase.db;";

string connectionString = "Data Source=mydatabase.db;";

Dim connectionString As String = "Data Source=mydatabase.db;"

$vbLabelText $csharpLabel

Objeto de conexión

Puedes crear un objeto de conexión utilizando la clase SQLiteConnection del espacio de nombres System.Data.SQLite.

using System.Data.SQLite;

// Initialize a connection to the SQLite database
var connection = new SQLiteConnection(connectionString);

// Open the connection
connection.Open();

using System.Data.SQLite;

// Initialize a connection to the SQLite database
var connection = new SQLiteConnection(connectionString);

// Open the connection
connection.Open();

Imports System.Data.SQLite

' Initialize a connection to the SQLite database
Private connection = New SQLiteConnection(connectionString)

' Open the connection
connection.Open()

$vbLabelText $csharpLabel

Creación de una tabla

Crear tabla

Crear una tabla es fundamental al trabajar con cualquier base de datos. Aquí está cómo crear una tabla utilizando código de SQLite.

// SQL command to create a new table "person"
string query = "CREATE TABLE IF NOT EXISTS person (id INTEGER PRIMARY KEY, name TEXT)";

// Create a command object with the SQL query and connection
var command = new SQLiteCommand(query, connection);

// Execute the command to create the table
command.ExecuteNonQuery();

// SQL command to create a new table "person"
string query = "CREATE TABLE IF NOT EXISTS person (id INTEGER PRIMARY KEY, name TEXT)";

// Create a command object with the SQL query and connection
var command = new SQLiteCommand(query, connection);

// Execute the command to create the table
command.ExecuteNonQuery();

' SQL command to create a new table "person"
Dim query As String = "CREATE TABLE IF NOT EXISTS person (id INTEGER PRIMARY KEY, name TEXT)"

' Create a command object with the SQL query and connection
Dim command = New SQLiteCommand(query, connection)

' Execute the command to create the table
command.ExecuteNonQuery()

$vbLabelText $csharpLabel

Id Entero Clave Primaria: Establece la columna 'id' como clave primaria.
Nombre de la Tabla: El nombre que quieres dar a tu tabla de base de datos.

Inserción de datos

Insertar filas

Para insertar datos en una tabla, necesitarás usar un comando INSERT.

// SQL command to insert a new row into the "person" table
string query = "INSERT INTO person (name) VALUES ('John')";
var command = new SQLiteCommand(query, connection);
command.ExecuteNonQuery();

// SQL command to insert a new row into the "person" table
string query = "INSERT INTO person (name) VALUES ('John')";
var command = new SQLiteCommand(query, connection);
command.ExecuteNonQuery();

' SQL command to insert a new row into the "person" table
Dim query As String = "INSERT INTO person (name) VALUES ('John')"
Dim command = New SQLiteCommand(query, connection)
command.ExecuteNonQuery()

$vbLabelText $csharpLabel

Comando parametrizado

Los comandos parametrizados pueden proteger tu aplicación de ataques de Inyección SQL. Este enfoque usa parámetros en lugar de insertar valores directamente en la consulta.

// SQL command with a parameter to insert data safely
string query = "INSERT INTO person (name) VALUES (@name)";
var command = new SQLiteCommand(query, connection);
command.Parameters.AddWithValue("@name", "Iron Developer");
command.ExecuteNonQuery();

// SQL command with a parameter to insert data safely
string query = "INSERT INTO person (name) VALUES (@name)";
var command = new SQLiteCommand(query, connection);
command.Parameters.AddWithValue("@name", "Iron Developer");
command.ExecuteNonQuery();

' SQL command with a parameter to insert data safely
Dim query As String = "INSERT INTO person (name) VALUES (@name)"
Dim command = New SQLiteCommand(query, connection)
command.Parameters.AddWithValue("@name", "Iron Developer")
command.ExecuteNonQuery()

$vbLabelText $csharpLabel

Recuperación de datos

Declaración de selección

Para recuperar datos de la tabla de la base de datos, usa una declaración SELECT.

// SQL command to select all rows from the "person" table
string query = "SELECT * FROM person";

var command = new SQLiteCommand(query, connection);
var reader = command.ExecuteReader();

// Loop through the result set and read data
while (reader.Read())
{
    Console.WriteLine(reader["name"]);
}

// SQL command to select all rows from the "person" table
string query = "SELECT * FROM person";

var command = new SQLiteCommand(query, connection);
var reader = command.ExecuteReader();

// Loop through the result set and read data
while (reader.Read())
{
    Console.WriteLine(reader["name"]);
}

' SQL command to select all rows from the "person" table
Dim query As String = "SELECT * FROM person"

Dim command = New SQLiteCommand(query, connection)
Dim reader = command.ExecuteReader()

' Loop through the result set and read data
Do While reader.Read()
	Console.WriteLine(reader("name"))
Loop

$vbLabelText $csharpLabel

Características avanzadas

Transacciones SQLite

Las transacciones te permiten ejecutar múltiples operaciones en una sola acción atómica. Aquí se explica cómo usar transacciones:

var transaction = connection.BeginTransaction();
try
{
    // Example of multiple operations in a transaction
    var insertCommand = new SQLiteCommand("INSERT INTO person (name) VALUES ('Alice')", connection, transaction);
    insertCommand.ExecuteNonQuery();

    var updateCommand = new SQLiteCommand("UPDATE person SET name = 'Bob' WHERE name = 'Alice'", connection, transaction);
    updateCommand.ExecuteNonQuery();

    transaction.Commit(); // Commit the transaction if all operations succeed
}
catch
{
    transaction.Rollback(); // Rollback the transaction if any operation fails
}

var transaction = connection.BeginTransaction();
try
{
    // Example of multiple operations in a transaction
    var insertCommand = new SQLiteCommand("INSERT INTO person (name) VALUES ('Alice')", connection, transaction);
    insertCommand.ExecuteNonQuery();

    var updateCommand = new SQLiteCommand("UPDATE person SET name = 'Bob' WHERE name = 'Alice'", connection, transaction);
    updateCommand.ExecuteNonQuery();

    transaction.Commit(); // Commit the transaction if all operations succeed
}
catch
{
    transaction.Rollback(); // Rollback the transaction if any operation fails
}

Dim transaction = connection.BeginTransaction()
Try
	' Example of multiple operations in a transaction
	Dim insertCommand = New SQLiteCommand("INSERT INTO person (name) VALUES ('Alice')", connection, transaction)
	insertCommand.ExecuteNonQuery()

	Dim updateCommand = New SQLiteCommand("UPDATE person SET name = 'Bob' WHERE name = 'Alice'", connection, transaction)
	updateCommand.ExecuteNonQuery()

	transaction.Commit() ' Commit the transaction if all operations succeed
Catch
	transaction.Rollback() ' Rollback the transaction if any operation fails
End Try

$vbLabelText $csharpLabel

Mapeo Objeto-Relacional (ORM) con Entity Framework

Entity Framework (EF) es una herramienta ORM ampliamente utilizada dentro del ecosistema .NET. Simplifica la programación de bases de datos permitiendo a los desarrolladores trabajar con datos relacionales utilizando objetos específicos del dominio. Aquí se explica cómo puedes usar Entity Framework con SQLite.

1. Instalación de Entity Framework

Primero, asegúrate de haber instalado el paquete NuGet de Entity Framework específico para SQLite:

Abre el Administrador de Paquetes NuGet en Visual Studio.
Busca "Entity Framework SQLite" e instálalo.

2. Creación de clases de entidad

Las clases de entidad son representaciones de las tablas de la base de datos. Puedes crear una clase para cada tabla con la que pretendes interactuar.

public class Person
{
    public int Id { get; set; } // Primary Key
    public string Name { get; set; }
}

public class Person
{
    public int Id { get; set; } // Primary Key
    public string Name { get; set; }
}

Public Class Person
	Public Property Id() As Integer ' -  Primary Key
	Public Property Name() As String
End Class

$vbLabelText $csharpLabel

3. DbContext

Deberás crear una clase que herede de DbContext. Esta clase representa la sesión con la base de datos y te permite consultar y guardar instancias de las entidades.

using Microsoft.EntityFrameworkCore;

public class MyDbContext : DbContext
{
    public DbSet<Person> Persons { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlite("Data Source=mydatabase.db;");
    }
}

using Microsoft.EntityFrameworkCore;

public class MyDbContext : DbContext
{
    public DbSet<Person> Persons { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlite("Data Source=mydatabase.db;");
    }
}

Imports Microsoft.EntityFrameworkCore

Public Class MyDbContext
	Inherits DbContext

	Public Property Persons() As DbSet(Of Person)

	Protected Overrides Sub OnConfiguring(ByVal optionsBuilder As DbContextOptionsBuilder)
		optionsBuilder.UseSqlite("Data Source=mydatabase.db;")
	End Sub
End Class

$vbLabelText $csharpLabel

4. Operaciones CRUD

Entity Framework simplifica las operaciones de Crear, Leer, Actualizar y Eliminar (CRUD). Aquí se explica cómo puedes insertar un nuevo registro:

using (var db = new MyDbContext())
{
    db.Persons.Add(new Person { Name = "John" });
    db.SaveChanges();
}

using (var db = new MyDbContext())
{
    db.Persons.Add(new Person { Name = "John" });
    db.SaveChanges();
}

Using db = New MyDbContext()
	db.Persons.Add(New Person With {.Name = "John"})
	db.SaveChanges()
End Using

$vbLabelText $csharpLabel

Leer, actualizar y eliminar registros son igualmente simplificados y directos con Entity Framework, permitiendo un código conciso y fácil de mantener.

Trabajar con archivos XML y otros proveedores de datos

SQLite no se limita a datos relacionales; también permite flexibilidad en el manejo de otros tipos de datos, incluidos archivos XML.

1. Almacenamiento de datos XML

Puedes almacenar datos XML dentro de una base de datos SQLite. Esto podría ser útil si trabajas con datos de configuración u otras estructuras jerárquicas.

string xmlData = "<person><name>John</name></person>";
string query = "INSERT INTO xmltable (data) VALUES (@data)";
var command = new SQLiteCommand(query, connection);
command.Parameters.AddWithValue("@data", xmlData);
command.ExecuteNonQuery();

string xmlData = "<person><name>John</name></person>";
string query = "INSERT INTO xmltable (data) VALUES (@data)";
var command = new SQLiteCommand(query, connection);
command.Parameters.AddWithValue("@data", xmlData);
command.ExecuteNonQuery();

Dim xmlData As String = "<person><name>John</name></person>"
Dim query As String = "INSERT INTO xmltable (data) VALUES (@data)"
Dim command = New SQLiteCommand(query, connection)
command.Parameters.AddWithValue("@data", xmlData)
command.ExecuteNonQuery()

$vbLabelText $csharpLabel

Recuperación de datos XML

Puedes recuperar y trabajar con datos XML utilizando técnicas estándar de análisis de XML en C#.

string query = "SELECT data FROM xmltable WHERE id = 1";
var command = new SQLiteCommand(query, connection);
var reader = command.ExecuteReader();

string xmlData;

// Read the XML data from the query result
if (reader.Read())
{
    xmlData = reader["data"].ToString();
}

// Parse the XML data as needed using an XML parser

string query = "SELECT data FROM xmltable WHERE id = 1";
var command = new SQLiteCommand(query, connection);
var reader = command.ExecuteReader();

string xmlData;

// Read the XML data from the query result
if (reader.Read())
{
    xmlData = reader["data"].ToString();
}

// Parse the XML data as needed using an XML parser

Dim query As String = "SELECT data FROM xmltable WHERE id = 1"
Dim command = New SQLiteCommand(query, connection)
Dim reader = command.ExecuteReader()

Dim xmlData As String

' Read the XML data from the query result
If reader.Read() Then
	xmlData = reader("data").ToString()
End If

' Parse the XML data as needed using an XML parser

$vbLabelText $csharpLabel

Trabajar con otros proveedores de datos

SQLite también se integra bien con varios proveedores de datos, permitiendo interoperabilidad y flexibilidad. Esto significa que puedes cambiar sin problemas entre diferentes bases de datos o incluso combinar diferentes fuentes de datos dentro de una sola aplicación.

Presentación de Iron Suite: Un potente conjunto de bibliotecas

Después de explorar los ámbitos de SQLite y operadores lógicos en C#, es momento de presentar una colección notable de herramientas que complementan y mejoran la experiencia de desarrollo en el entorno .NET. El Iron Suite es un conjunto de bibliotecas potentes que comprende IronPDF, IronXL, IronOCR e IronBarcode, cada una con propósitos distintos.

IronPDF: Biblioteca PDF de C

Guía Completa sobre IronPDF es una biblioteca completa diseñada para crear, leer y manipular archivos PDF en C#. Ya sea que necesites generar informes, facturas o cualquier documento en formato PDF, IronPDF está cubierto. Una característica única de IronPDF es la capacidad de convertir HTML a PDF. Puedes renderizar HTML como un documento PDF, incluyendo CSS, JavaScript e imágenes, lo que lo convierte en una herramienta potente. Consulta este tutorial sobre Convirtiendo HTML a PDF con IronPDF para una guía paso a paso.

La Funcionalidad de HTML a PDF de IronPDF es su principal destaque, 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

IronPDF puede ser una herramienta esencial al trabajar con bases de datos SQLite. Puedes generar informes en PDF a partir de los datos de tu base de datos SQLite, permitiendo una presentación y compartición de datos sin problemas.

IronXL: Excel File Management Made Easy

Explora IronXL para Integración con Excel que permite a los desarrolladores leer, escribir y manipular archivos de Excel sin esfuerzo. Es compatible con XLS, XLSX y más, lo que lo convierte en una herramienta ideal para manejar datos de hoja de cálculo. Puedes leer archivos de Excel, manipularlos e incluso crear nuevos archivos desde cero. La funcionalidad de IronXL se integra bien con la gestión de bases de datos, incluido SQLite, para exportar e importar datos.

IronOCR: Reconocimiento óptico de caracteres en C#

Con IronOCR para Reconocimiento de Textos, escanear texto de imágenes y archivos PDF es muy sencillo. Es una biblioteca OCR (Reconocimiento Óptico de Caracteres) versátil que reconoce texto de diversas fuentes.

Imagina almacenar documentos escaneados en una base de datos SQLite y utilizar IronOCR para recuperar y reconocer el texto dentro de esos documentos. Las posibilidades son infinitas, proporcionando una funcionalidad poderosa de recuperación y búsqueda de texto.

IronBarcode: La biblioteca definitiva de generación y lectura de códigos de barras

La generación y lectura de códigos de barras se simplifican con Integración Poderosa de Código de Barras via IronBarcode. Soporta múltiples formatos de códigos de barras y ofrece una API robusta. IronBarcode puede desempeñar un papel esencial en aplicaciones que utilizan SQLite, donde los códigos de barras pueden representar productos u otras entidades de datos. Almacenar y recuperar códigos de barras de la base de datos SQLite mejora la integridad de los datos y facilita el acceso rápido.

Conclusión

SQLite es un motor de base de datos poderoso pero ligero que es excelente tanto para principiantes como para profesionales. Desde la creación de tablas e inserción de filas hasta la gestión de transacciones y prevención de ataques de Inyección SQL, SQLite ofrece muchas características. Ya sea que estés construyendo una aplicación de consola o móvil o necesites trabajar con claves externas y conjuntos de datos, SQLite es una excelente elección.

El Iron Suite, que comprende IronPDF, IronXL, IronOCR e IronBarcode, es un tesoro de herramientas que amplían las capacidades de tus proyectos de desarrollo en C#, ya sea que estés trabajando con bases de datos SQLite o cualquier otro dominio.

Lo que es aún más atractivo es que cada uno de estos productos ofrece una prueba gratuita para productos Iron Software, brindándote tiempo más que suficiente para explorar y comprender la amplia gama de funcionalidades que ofrecen. Una vez que decidas continuar con estas herramientas, la licencia comienza desde $799 por producto. También puedes comprar el paquete completo de Iron Suite al precio de solo dos productos individuales.

Preguntas Frecuentes

¿Cómo puedo configurar SQLite en un proyecto C# usando NuGet?

Para configurar SQLite en un proyecto C# usando NuGet, abra Visual Studio y cree una nueva aplicación de consola. Acceda al Administrador de paquetes NuGet, busque 'SQLite' e instale el paquete. Esto integrará las bibliotecas de SQLite en su proyecto para operaciones de base de datos.

¿Cuáles son los beneficios de usar SQLite para aplicaciones C#?

SQLite es un motor de base de datos ligero y sin servidor que almacena datos en un solo archivo, lo que lo hace ideal para aplicaciones que necesitan una solución de base de datos simple y eficiente sin la complejidad de un sistema de base de datos tradicional.

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

Puede conectarse a una base de datos SQLite en C# creando una cadena de conexión como Data Source=mydatabase.db; y usando la clase SQLiteConnection del espacio de nombres System.Data.SQLite para establecer y abrir una conexión.

¿Cómo puedo realizar operaciones CRUD en una base de datos SQLite usando C#?

Usando comandos SQL como INSERT, SELECT, UPDATE y DELETE, puede realizar operaciones CRUD en una base de datos SQLite en C#. Estos comandos pueden ejecutarse utilizando un objeto SQLiteCommand.

¿Qué papel juegan las transacciones en SQLite?

Las transacciones en SQLite permiten ejecutar múltiples operaciones como una sola acción atómica. Puede comenzar una transacción utilizando connection.BeginTransaction(), realizar las operaciones necesarias y luego confirmar o deshacer la transacción según el resultado.

¿Cómo puedo usar Entity Framework con SQLite en un proyecto C#?

Para usar Entity Framework con SQLite, instale el paquete necesario de Entity Framework a través de NuGet, defina sus clases de entidad y cree una clase de DbContext. Esta configuración permite el mapeo objeto-relacional, simplificando las interacciones con bases de datos dentro de su proyecto C#.

¿Cómo puedo generar documentos PDF a partir de datos de base de datos usando C#?

Con IronPDF, puede generar documentos PDF a partir de datos de base de datos en C# convirtiendo HTML en PDF. Esto le permite crear informes PDF bien formateados a partir de los datos almacenados en su base de datos SQLite.

¿Qué herramientas pueden mejorar el desarrollo en C# para aplicaciones de bases de datos?

El Iron Suite, que incluye herramientas como IronPDF, IronXL, IronOCR e IronBarcode, mejora el desarrollo en C# para aplicaciones de bases de datos al proporcionar funcionalidades como la creación de PDF, manipulación de archivos Excel, reconocimiento de texto y generación de códigos de barras.

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 ...