O SQLite é um mecanismo de banco de dados relacional popular, leve e independente, amplamente utilizado em diversas aplicações de acesso a dados e plataformas de ambiente. No contexto do desenvolvimento .NET , o código-fonte do SQLite é uma excelente opção para integrar um sistema de banco de dados confiável às suas aplicações. Este artigo irá explorar o mundo das transações SQLite, abordando seus recursos, vantagens e como utilizá-las de forma eficaz em seus projetos .NET .
O SQLite é um mecanismo de banco de dados de código aberto popular que pode ser incorporado em aplicativos sem a necessidade de um componente de servidor separado. É rápido, confiável e multiplataforma. O SQLite pode ser usado com aplicações de projetos .NET através de diversas bibliotecas que fornecem interfaces .NET . Uma dessas bibliotecas é a Microsoft.Data.SQLite . Isso permite que você use o SQLite como fonte de dados para seus aplicativos .NET , sejam eles de console, desktop, web ou mobile. Você também pode usar o Entity Framework Core para realizar mapeamento objeto-relacional e consultar seu banco de dados SQLite usando LINQ.
Este artigo mostra como usar Microsoft.Data.Sqlite para desenvolver, conectar e manipular um banco de dados SQLite em uma Aplicação de Console .NET. Você aprenderá como:
Para usar o Microsoft.Data.Sqlite, você precisa instalar o pacote NuGet que contém a biblioteca e suas dependências. Você pode fazer isso usando o Gerenciador de Pacotes do Visual Studio, a CLI do .NET Core ou qualquer outra ferramenta que suporte o NuGet. Este artigo usará o Gerenciador de Pacotes para criar um Aplicativo de Console e instalar o Microsoft.Data.Sqlite. Para isso, abra um Console do Gerenciador de Pacotes e execute os seguintes comandos:
O comando acima instalará o pacote conforme mostrado abaixo.
Para trabalhar com um banco de dados SQLite, você precisa criar um objeto SqliteConnection que representa a conexão com o arquivo do banco de dados. Você pode especificar o nome do arquivo e outras opções na string de conexão. Se o arquivo não existir, ele será criado automaticamente. Por exemplo, o programa abaixo cria uma conexão com um arquivo de banco de dados chamado employee.db no diretório atual:
using (var connection = new SqliteConnection("Data Source=employee.db"))
{
connection.Open();
// ...
}Using connection = New SqliteConnection("Data Source=employee.db")
connection.Open()
' ...
End UsingA instrução using garante que a conexão seja fechada e descartada quando sair do escopo. Para executar comandos SQL, você precisa criar um objeto SqlCommand e associá-lo à conexão. Você pode definir a propriedade CommandText para a instrução SQL que deseja executar e, opcionalmente, adicionar parâmetros à coleção Parameters. Você pode então chamar um dos métodos do objeto SqlCommand para executar o comando, como ExecuteNonQuery, ExecuteScalar, ou ExecuteReader.
O código a seguir cria uma tabela chamada Employee usando o 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 inserir dados em uma tabela, você pode usar o mesmo objeto SqlCommand e definir a propriedade CommandText para uma instrução INSERT. Por exemplo, o código a seguir insere três linhas na tabela Funcionário.
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 ler dados de uma tabela, você pode usar o método ExecuteReader do objeto SqlCommand e definir a propriedade CommandText para uma instrução SELECT. Isso retornará um objeto SqliteDataReader que permite iterar sobre as linhas e acessar os valores pelo nome da coluna ou índice. Você pode usar o método Read para mover para a próxima linha e os métodos GetXXX para obter os valores como o tipo de dado apropriado. Por exemplo, o código a seguir lê todas as linhas da tabela Employee e as imprime no console:
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 UsingO resultado deste código é:
Se você preferir usar LINQ para consultar seu banco de dados SQLite, pode usar o Entity Framework Core para mapear suas tabelas para classes e executar consultas usando expressões LINQ. Para isso, você precisa instalar o pacote Microsoft.EntityFrameworkCore.Sqlite, que depende do pacote Microsoft.Data.Sqlite. Você também precisa criar uma classe que herda de DbContext e representa o contexto do banco de dados. Esta classe deve ter um construtor que aceita um parâmetro DbContextOptions e o passa para o construtor base. Também deve ter uma propriedade DbSet para cada tabela que você deseja mapear para uma classe. Por exemplo, o código a seguir define uma classe Stock e uma classe 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 criar o contexto do banco de dados, você precisa usar a classe DbContextOptionsBuilder e especificar a string de conexão e o provedor de banco de dados. Você também pode usar o método Database.EnsureCreated para criar o banco de dados e as tabelas se eles não existirem. Por exemplo, o código a seguir cria o contexto do banco de dados e o banco de dados:
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 inserir dados no banco de dados, você pode usar os métodos Add ou AddRange da propriedade DbSet e passar os objetos que deseja inserir. Você também pode usar o método SaveChanges para confirmar as alterações no banco de dados. Por exemplo, o código a seguir insere três ações no banco de dados:
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 dados, você pode usar os métodos LINQ ou expressões na propriedade DbSet e aplicar filtros, projeções, agregações e outras operações. As consultas serão traduzidas em instruções SQL e executadas no banco de dados. Por exemplo, o código a seguir consulta as ações cujo preço é inferior a seis dólares e imprime seus nomes:
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 UsingVamos supor que temos um cenário em que precisamos criar um arquivo PDF contendo a lista de ações. Podemos fazer isso facilmente usando o IronPDF.
IronPDF é uma biblioteca que ajuda você a criar, editar e ler arquivos PDF em seus aplicativos .NET sem a necessidade de vários pacotes. Ele pode gerar PDFs a partir de HTML, URL, JavaScript, CSS e diversos formatos de imagem, além de adicionar cabeçalhos, rodapés, assinaturas, anexos e senhas. Ele também oferece suporte à compatibilidade entre plataformas, multithreading e processamento assíncrono.
O principal destaque do IronPDF é seu recurso de conversão de HTML para PDF , que preserva todos os layouts e estilos. Ele gera PDFs a partir de conteúdo da web, ideal para relatórios, faturas e documentação. Você pode converter arquivos HTML, URLs e strings HTML em PDFs sem problemas.
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 o IronPDF em nosso projeto, digite o seguinte comando no Console do Gerenciador de Pacotes.
Este comando instalará o IronPDF juntamente com todas as suas dependências.
O IronPDF requer uma chave de licença para ser utilizado. Podemos obter facilmente uma chave de licença de avaliação na página de licenças de avaliação do IronPDF .
Adicione este código à inicialização da sua aplicação antes de usar o IronPDF . Essa abordagem é universalmente eficaz e simples, funcionando tanto para aplicações .NET Core quanto para aplicações .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 C# gera um relatório em PDF a partir de dados de ações armazenados em um banco de dados SQLite. Ele cria dinamicamente uma tabela HTML, preenche-a com informações sobre ações e usa um renderizador de PDF baseado no Chrome para converter a tabela em um arquivo "stock.pdf" para download, facilitando a geração de relatórios e a distribuição eficiente de detalhes sobre as ações.
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")O trecho de código C# acima foi projetado para criar uma tabela HTML exibindo informações de ações de um banco de dados SQLite e, posteriormente, convertê-la em um arquivo PDF. Ele utiliza a biblioteca Entity Framework Core para interagir com o banco de dados. Inicialmente, ele configura um DbContextOptionsBuilder para usar o SQLite com uma string de conexão específica. O código então constrói uma string HTML com estilos CSS incorporados para a aparência da tabela, cria uma estrutura de tabela com cabeçalhos, consulta o banco de dados SQLite para obter informações sobre ações, preenche a tabela HTML com os dados recuperados e, finalmente, utiliza um renderizador de PDF baseado no Chrome para converter o conteúdo HTML em um arquivo PDF chamado "stock.pdf". O PDF resultante conterá uma tabela apresentando os símbolos, nomes e preços das ações.
Em conclusão, o uso do SQLite no .NET para gerenciamento de banco de dados oferece uma solução leve e versátil. Este artigo explorou a integração do SQLite em aplicações .NET , apresentando seus principais recursos e vantagens. O código fornecido demonstra os passos práticos para criar, conectar e manipular um banco de dados SQLite em uma aplicação de console .NET . Além disso, destacou o uso do Microsoft.Data.Sqlite e do Entity Framework Core para o gerenciamento eficiente de dados. A incorporação do IronPDF ilustrou como gerar facilmente um relatório em PDF a partir do banco de dados SQLite, aprimorando os recursos do aplicativo para geração de relatórios e distribuição de dados.
A IronPDF oferece diversas opções de licenciamento , dependendo do número de desenvolvedores, locais, projetos e necessidades de redistribuição. As licenças são perpétuas e incluem um ano de suporte e atualizações gratuitas.
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.
IronPDF faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
Quando você precisa que seu PDF tenha a aparência de HTML, rapidamente.
