Ícone de mensagem
Ir para o conteúdo do rodapé
  1. IronPDF
  2. Blog do IronPDF
  3. Ajuda do .NET
  4. SQLite C# .NET
AJUDA DO .NET

SQLite em C# .NET (Como funciona para desenvolvedores)

Curtis Chau
Curtis Chau
Atualizado:

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 .

Como usar o SQLite em C

  1. Baixe a biblioteca SQLite.
  2. Crie um banco de dados e insira os dados.
  3. Leia usando o leitor
  4. Utilize o SQLite com o Entity Framework e o método de consulta LINQ.
  5. Gere um relatório em PDF usando o IronPDF.

O que é SQLite?

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 um aplicativo de console .NET . Você aprenderá como:

  • Instale o pacote NuGet Microsoft.Data.Sqlite
  • Crie uma conexão SQLite e execute comandos SQL
  • Criar e preencher tabelas usando leitores de dados e parâmetros
  • Consultar dados usando leitores de dados
  • Implementar o Entity Framework Core
  • Consultar dados usando LINQ
  • Gerar relatório em PDF

Instalando a biblioteca SQLite

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:

Install-Package Microsoft.Data.Sqlite

O comando acima instalará o pacote conforme mostrado abaixo.

Criando um banco de dados SQLite

Para trabalhar com um banco de dados SQLite, você precisa criar um objeto SqliteConnection que representa a conexão com o arquivo de 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 (var connection = new SqliteConnection("Data Source=employee.db"))
{
    connection.Open();
    // ...
}
Using connection = New SqliteConnection("Data Source=employee.db")
	connection.Open()
	' ...
End Using
$vbLabelText   $csharpLabel

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

Criar tabela no SQLite

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

Inserir dados na tabela

Para 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 (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

Ler dados do SQLite

Para 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 pelo índice. Você pode usar o método Read para ir para a próxima linha e os métodos GetXXX para obter os valores no tipo de dados 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 (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

Saída

O resultado deste código é:

Sqlite C# .NET (Como funciona para o desenvolvedor): Figura 1 - Saída

Consultando dados

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 herde de DbContext e represente o contexto do banco de dados. Esta classe deve ter um construtor que aceite um parâmetro DbContextOptions e o passe para o construtor da classe base. Também deve haver 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; }
}
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 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, caso eles não existam. Por exemplo, o código a seguir cria o contexto 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();
}
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 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();
    }
}
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 dados, você pode usar os métodos ou expressões LINQ 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 (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

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

Apresentando 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");
    }
}
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

Instale o IronPDF

Para instalar o IronPDF em nosso projeto, digite o seguinte comando no Console do Gerenciador de Pacotes.

Install-Package IronPdf

Este comando instalará o IronPDF juntamente com todas as suas dependências.

Adicionar chave de licença

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

Criar arquivo PDF contendo a lista de estoque

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

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.

A saída é a seguinte:

Sqlite C# .NET (Como funciona para o desenvolvedor): Figura 2 - Saída da tabela de ações

Conclusão

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.

Perguntas frequentes

O que é SQLite e por que é popular no desenvolvimento .NET?

O SQLite é um mecanismo de banco de dados relacional leve e independente, amplamente utilizado no desenvolvimento .NET devido à sua velocidade, confiabilidade e capacidade de ser multiplataforma. Ele pode ser incorporado em aplicativos sem a necessidade de um componente de servidor separado.

Como posso integrar o SQLite em minha aplicação .NET?

Você pode integrar o SQLite ao seu aplicativo .NET instalando o pacote NuGet Microsoft.Data.Sqlite. Este pacote fornece interfaces ADO.NET, permitindo que você crie, conecte e manipule bancos de dados SQLite em aplicativos de console, desktop, web ou móveis.

Como faço para criar e conectar a um banco de dados SQLite em C#?

Para criar e conectar-se a um banco de dados SQLite em C#, utilize a classe SqliteConnection para estabelecer a conexão. Em seguida, você pode executar comandos SQL para criar tabelas e manipular dados usando o objeto SqlCommand .

Posso usar consultas LINQ com SQLite no .NET?

Sim, você pode usar consultas LINQ com SQLite no .NET utilizando o Entity Framework Core. Isso permite o mapeamento objeto-relacional, possibilitando a execução de consultas LINQ em propriedades de DbSet dentro de uma classe DbContext.

Como posso gerar relatórios em PDF a partir de dados de um banco de dados SQLite?

Você pode gerar relatórios em PDF a partir de dados de banco de dados SQLite usando o IronPDF. Convertendo representações HTML dos seus dados ou usando diretamente o conteúdo do banco de dados, você pode criar relatórios em PDF detalhados e exportá-los usando os recursos de renderização do IronPDF.

Como posso solucionar problemas comuns do SQLite em aplicações .NET?

Problemas comuns com o SQLite em aplicações .NET podem ser solucionados garantindo a instalação correta do pacote Microsoft.Data.Sqlite, verificando a sintaxe SQL e as strings de conexão. Ferramentas de depuração e logs também podem ajudar a identificar e resolver erros.

Como faço para instalar e usar uma biblioteca PDF em um projeto .NET?

Para instalar uma biblioteca PDF como o IronPDF em um projeto .NET, execute o Install-Package IronPDF no Console do Gerenciador de Pacotes. Após a instalação, o IronPDF permite criar, editar e ler arquivos PDF utilizando sua extensa API.

Quais são as vantagens de usar o SQLite com o .NET?

Utilizar o SQLite com o .NET oferece vantagens como simplicidade, dispensa de um servidor dedicado, suporte multiplataforma e desempenho confiável. É ideal para aplicações leves e pode ser facilmente integrado usando bibliotecas como o Microsoft.Data.Sqlite.

Curtis Chau
Curtis Chau
  Converse agora mesmo com a equipe de engenharia.
Redator Técnico

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

Leia mais

Artigos relacionados

Teste grátis por 30 dias → Produto completo. Sem limites. Sem cartão. Teste gratuito

Equipe de suporte de ferro

Estamos online 24 horas por dia, 5 dias por semana.
Bater papo
E-mail
Liga para mim