C# PostgreSQL (Cómo funciona para desarrolladores)

Bienvenido a este tutorial diseñado para principiantes interesados en integrar aplicaciones C# con PostgreSQL. PostgreSQL es una de las bases de datos relacionales más utilizadas en todo el mundo, conocida por su fiabilidad y compatibilidad con una amplia gama de entornos de programación, incluido C#. Esta guía le guiará a través de los fundamentos de la conexión de una aplicación C# a una base de datos PostgreSQL, la ejecución de consultas de sentencias SQL y el manejo de datos. Utilizaremos herramientas como Visual Studio, NuGet Package Manager y el proveedor de datos Npgsql para crear un proyecto sencillo que se comunique con un servidor PostgreSQL. También aprenderemos sobre la biblioteca IronPDF con la integración de PostgreSQL.

Configuración del entorno

Antes de sumergirte en la codificación, asegúrate de tener Visual Studio instalado en tu ordenador. Visual Studio es un conocido entorno de desarrollo integrado (IDE) que soporta C# entre otros lenguajes de programación. Para la gestión de bases de datos, instala PostgreSQL en tu máquina local o configura una base de datos PostgreSQL en un entorno en la nube como Azure Database.

Después de configurar Visual Studio y su servidor PostgreSQL, cree un nuevo proyecto C#. Para ello, abra Visual Studio, vaya al menú Archivo, seleccione Nuevo y, a continuación, Proyecto. Elija una aplicación de consola (.NET Core) como tipo de proyecto para simplificar las cosas.

Integración de PostgreSQL con C#

Para conectar su aplicación C# a una base de datos PostgreSQL, necesita el proveedor de datos Npgsql. Npgsql actúa como puente entre las aplicaciones C# y las bases de datos PostgreSQL, permitiendo a su código ejecutar comandos SQL y gestionar datos.

Instalación de Npgsql

Abra el proyecto recién creado en Visual Studio. Haga clic con el botón derecho en su proyecto en el Explorador de soluciones, seleccione "Administrar paquetes NuGet" y busque el paquete Npgsql. Instálelo haciendo clic en el botón de instalación situado junto al nombre del paquete. Esta acción añade el proveedor de datos Npgsql a tu proyecto, permitiendo que tu aplicación se comunique con PostgreSQL. También puede instalarlo mediante la consola del gestor de paquetes.

Configuración de la conexión a la base de datos

El primer paso para interactuar con una base de datos PostgreSQL desde C# es establecer una conexión. Esto requiere una cadena de conexión, que incluye detalles como el nombre del servidor, el puerto, el nombre de usuario y la contraseña. He aquí una plantilla básica para una cadena de conexión PostgreSQL:

string connectionString = "Host=localhost; Port=5432; Username=postgres; Password=yourpassword; Database=mydatabase";

string connectionString = "Host=localhost; Port=5432; Username=postgres; Password=yourpassword; Database=mydatabase";

Dim connectionString As String = "Host=localhost; Port=5432; Username=postgres; Password=yourpassword; Database=mydatabase"

Sustituye localhost, yourpassword y mydatabase por los datos de tu servidor PostgreSQL.

Definir el modelo de empleado

Definimos un modelo de entidad Empleado que representará nuestros datos en la base de datos PostgreSQL. Este modelo incluye propiedades que corresponden a las columnas de la tabla de la base de datos.

public class Employee
{
    public int Id { get; set; } //  Se convierte automáticamente en la clave primaria
    public string LastName { get; set; }
}

public class Employee
{
    public int Id { get; set; } //  Se convierte automáticamente en la clave primaria
    public string LastName { get; set; }
}

Public Class Employee
	Public Property Id() As Integer ' -   Se convierte automáticamente en la clave primaria
	Public Property LastName() As String
End Class

Este fragmento de código define una clase simple Employee con dos propiedades: Id y LastName. Entity Framework Core utiliza convenciones para inferir que la propiedad de clave primaria serial Id debe ser tratada como la clave primaria.

Configuración del DbContext de la aplicación

La clase AppDbContext extiende DbContext de Entity Framework Core, actuando como puente entre su aplicación C# y la base de datos PostgreSQL. Incluye detalles de configuración como la cadena de conexión y las propiedades DbSet que representan tablas en la base de datos.

public class AppDbContext : DbContext
{
    public DbSet<Employee> Employees { get; set; } //  Representa la tabla de Empleados
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        string connectionString = "Host=localhost; Port=5432; Username=postgres; Password=your_password; Database=your_database";
        optionsBuilder.UseNpgsql(connectionString);
    }
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Employee>().ToTable("Employees");
    }
}

public class AppDbContext : DbContext
{
    public DbSet<Employee> Employees { get; set; } //  Representa la tabla de Empleados
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        string connectionString = "Host=localhost; Port=5432; Username=postgres; Password=your_password; Database=your_database";
        optionsBuilder.UseNpgsql(connectionString);
    }
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Employee>().ToTable("Employees");
    }
}

Public Class AppDbContext
	Inherits DbContext

	Public Property Employees() As DbSet(Of Employee) ' -   Representa la tabla de Empleados
	Protected Overrides Sub OnConfiguring(ByVal optionsBuilder As DbContextOptionsBuilder)
		Dim connectionString As String = "Host=localhost; Port=5432; Username=postgres; Password=your_password; Database=your_database"
		optionsBuilder.UseNpgsql(connectionString)
	End Sub
	Protected Overrides Sub OnModelCreating(ByVal modelBuilder As ModelBuilder)
		modelBuilder.Entity(Of Employee)().ToTable("Employees")
	End Sub
End Class

Propiedad DbSet: public DbSetEmpleados { conseguir; set; }declara un conjunto de entidades Employee que son mapeadas a la tabla de empleados en la base de datos PostgreSQL.

Método OnConfiguring: Este método configura el DbContext con la cadena de conexión a la base de datos necesaria. Sustituye tu_contraseña y tu_base_de_datos por los datos reales de tu servidor PostgreSQL.

MétodoOnModelCreating: Aquí puede utilizar la API de Fluent para configurar aún más los comportamientos de las entidades. En este ejemplo, especificamos el nombre de la tabla explícitamente, aunque es opcional si el nombre de la tabla coincide con el nombre de la propiedad DbSet.

Lógica del programa principal

En el método Main de la clase Program, nos aseguramos de que se crea la base de datos, la sembramos con datos iniciales si está vacía y, a continuación, realizamos una consulta para recuperar y mostrar los datos de los empleados.

class Program
{
    static void Main(string [] args)
    {
        using (var context = new AppDbContext())
        {
            context.Database.EnsureCreated();
            if (!context.Employees.Any())
            {
                context.Employees.Add(new Employee { LastName = "Software" });
                context.SaveChanges();
            }
            var employees = context.Employees.Where(e => e.LastName == "Doe").ToList();
            foreach (var employee in employees)
            {
                Console.WriteLine($"Employee ID: {employee.Id}, Last Name: {employee.LastName}");
            }
        }
    }
}

class Program
{
    static void Main(string [] args)
    {
        using (var context = new AppDbContext())
        {
            context.Database.EnsureCreated();
            if (!context.Employees.Any())
            {
                context.Employees.Add(new Employee { LastName = "Software" });
                context.SaveChanges();
            }
            var employees = context.Employees.Where(e => e.LastName == "Doe").ToList();
            foreach (var employee in employees)
            {
                Console.WriteLine($"Employee ID: {employee.Id}, Last Name: {employee.LastName}");
            }
        }
    }
}

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Using context = New AppDbContext()
			context.Database.EnsureCreated()
			If Not context.Employees.Any() Then
				context.Employees.Add(New Employee With {.LastName = "Software"})
				context.SaveChanges()
			End If
			Dim employees = context.Employees.Where(Function(e) e.LastName = "Doe").ToList()
			For Each employee In employees
				Console.WriteLine($"Employee ID: {employee.Id}, Last Name: {employee.LastName}")
			Next employee
		End Using
	End Sub
End Class

El código anterior comprueba si la base de datos existe y la crea junto con el esquema en caso contrario. Es una forma sencilla de arrancar una nueva base de datos durante el desarrollo. Esta sentencia SQL comprueba, que si la tabla Empleados está vacía, el programa añade un nuevo Empleado con el apellido "Software" y guarda los cambios en la base de datos. El programa consulta la tabla Empleados en busca de entradas con el apellido "Software" e imprime sus detalles en la consola. Podemos añadir una consulta SQL para eliminar la tabla en la base de datos Postgres. También podemos añadir un proveedor de datos .NET para nuestra base de datos.

Salida

Aquí está la salida de la consola cuando se ejecuta el programa:

Y son los datos de la tabla en PgAdmin:

Introducción a IronPDF

IronPDF es una completa biblioteca para C# que permite a los desarrolladores crear, editar y manipular documentos PDF dentro de aplicaciones .NET. Esta potente herramienta simplifica generar PDF a partir de HTML URL e imágenes. También permite realizar operaciones esenciales en PDF, como editar texto e imágenes, y añadir funciones de seguridad como el cifrado y las firmas digitales. IronPDF destaca por su facilidad de uso, que permite a los desarrolladores implementar complejas funcionalidades PDF con un código mínimo.

La integración de IronPDF con una base de datos PostgreSQL puede ser increíblemente útil en situaciones en las que necesite generar informes o documentos PDF basados en datos dinámicos almacenados en su base de datos. Esto puede ir desde la generación de facturas, informes, extractos de clientes, etc., directamente a partir de los datos almacenados en una base de datos PostgreSQL.

Instalación de IronPDF

Antes de poder utilizar IronPDF, debe añadirlo a su proyecto. Esto se hace fácilmente a través del gestor de paquetes NuGet:

Install-Package IronPdf

Generar un PDF a partir de datos PostgreSQL

En este ejemplo, vamos a generar un simple informe PDF que enumera los empleados de nuestra base de datos PostgreSQL. Asumiremos que tienes el modelo AppDbContext y Employee configurados como se describe en secciones anteriores.

En primer lugar, asegúrese de que tiene la biblioteca IronPDF instalada en su proyecto. A continuación, puede utilizar el siguiente código para obtener datos de la base de datos PostgreSQL y generar un informe PDF:

class Program
{
    static void Main(string [] args)
    {
        IronPdf.License.LicenseKey = "Key";
        //  Inicializar el contexto de la base de datos
        using (var context = new AppDbContext())
        {
            //  Obtener empleados de la base de datos
            var employees = context.Employees.ToList();
            //  Generar contenido HTML para el PDF
            var htmlContent = "<h1>Employee Report</h1>";
            htmlContent += "<table><tr><th>ID</th><th>Last Name</th></tr>";
            foreach (var employee in employees)
            {
                htmlContent += $"<tr><td>{employee.Id}</td><td>{employee.LastName}</td></tr>";
            }
            htmlContent += "</table>";
            //  Instanciar el convertidor IronPDF HtmlToPdf
            var renderer = new ChromePdfRenderer();
            //  Generar el documento PDF a partir del contenido HTML
            var pdf = renderer.RenderHtmlAsPdf(htmlContent);
            //  Guardar el PDF generado en un archivo
            var outputPath = "f:\\EmployeeReport.pdf";
            pdf.SaveAs(outputPath);
            Console.WriteLine($"PDF report generated: {outputPath}");
        }
    }
}

class Program
{
    static void Main(string [] args)
    {
        IronPdf.License.LicenseKey = "Key";
        //  Inicializar el contexto de la base de datos
        using (var context = new AppDbContext())
        {
            //  Obtener empleados de la base de datos
            var employees = context.Employees.ToList();
            //  Generar contenido HTML para el PDF
            var htmlContent = "<h1>Employee Report</h1>";
            htmlContent += "<table><tr><th>ID</th><th>Last Name</th></tr>";
            foreach (var employee in employees)
            {
                htmlContent += $"<tr><td>{employee.Id}</td><td>{employee.LastName}</td></tr>";
            }
            htmlContent += "</table>";
            //  Instanciar el convertidor IronPDF HtmlToPdf
            var renderer = new ChromePdfRenderer();
            //  Generar el documento PDF a partir del contenido HTML
            var pdf = renderer.RenderHtmlAsPdf(htmlContent);
            //  Guardar el PDF generado en un archivo
            var outputPath = "f:\\EmployeeReport.pdf";
            pdf.SaveAs(outputPath);
            Console.WriteLine($"PDF report generated: {outputPath}");
        }
    }
}

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		IronPdf.License.LicenseKey = "Key"
		'  Inicializar el contexto de la base de datos
		Using context = New AppDbContext()
			'  Obtener empleados de la base de datos
			Dim employees = context.Employees.ToList()
			'  Generar contenido HTML para el PDF
			Dim htmlContent = "<h1>Employee Report</h1>"
			htmlContent &= "<table><tr><th>ID</th><th>Last Name</th></tr>"
			For Each employee In employees
				htmlContent &= $"<tr><td>{employee.Id}</td><td>{employee.LastName}</td></tr>"
			Next employee
			htmlContent &= "</table>"
			'  Instanciar el convertidor IronPDF HtmlToPdf
			Dim renderer = New ChromePdfRenderer()
			'  Generar el documento PDF a partir del contenido HTML
			Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
			'  Guardar el PDF generado en un archivo
			Dim outputPath = "f:\EmployeeReport.pdf"
			pdf.SaveAs(outputPath)
			Console.WriteLine($"PDF report generated: {outputPath}")
		End Using
	End Sub
End Class

Salida

Cuando ejecutes el código, aparecerá esta salida de consola:

Se genera este PDF:

Conclusión

Acaba de dar un importante primer paso en el mundo de la gestión de bases de datos con C# y PostgreSQL. Siguiendo las instrucciones de este tutorial, habrás aprendido a configurar un proyecto en Visual Studio, instalar los paquetes necesarios y ejecutar operaciones básicas con bases de datos. A medida que se familiarice con estos conceptos, descubrirá la potencia y flexibilidad de combinar C# con uno de los sistemas de bases de datos relacionales más importantes. Siga experimentando con diferentes consultas y configuraciones de entidades para profundizar su comprensión de cómo C# interactúa con PostgreSQL.

IronPDF proporciona un prueba gratuita que permite a los desarrolladores explorar sus características y capacidades sin ninguna inversión inicial. Esta versión de prueba es especialmente útil para evaluar si IronPDF cumple los requisitos de su proyecto para generar, editar y convertir documentos PDF en aplicaciones .NET. Después del periodo de prueba o para uso en producción, es necesario adquirir una licencia. La licencia de IronPDF comienza en $749 y ofrece una gama de funciones y opciones de soporte adecuadas para las distintas necesidades de desarrollo.