C# PostgreSQL (Cómo Funciona para Desarrolladores)

Instalación de Npgsql

Abra su proyecto recién creado en Visual Studio. Haga clic derecho sobre 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 junto al nombre del paquete. Esta acción agrega el proveedor de datos Npgsql a su proyecto, permitiendo que su aplicación se comunique con PostgreSQL. También puede instalarlo usando la consola del administrador 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, puerto, nombre de usuario y contraseña. Aquí hay 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";

Reemplace localhost, yourpassword, y mydatabase con los detalles de su servidor PostgreSQL.

Definición del 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 en la tabla de la base de datos.

public class Employee
{
    public int Id { get; set; } // Automatically becomes the primary key
    public string LastName { get; set; }
}

public class Employee
{
    public int Id { get; set; } // Automatically becomes the primary key
    public string LastName { get; set; }
}

Este fragmento de código define una clase Empleado sencilla con dos propiedades: Id y Apellido. Entity Framework Core usa convenciones para inferir que la propiedad de clave principal serial Id debe tratarse como la clave principal.

Configuración del DbContext de la aplicación

La clase AppDbContext extiende DbContext de Entity Framework Core, actuando como un 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; } // Represents the Employees table

    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; } // Represents the Employees table

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

• Propiedad DbSet:** DbSet públicoEmpleados { obtener; set; } declara un conjunto de Employee** entidades que están mapeadas a la tabla de empleados en la base de datos PostgreSQL.

• Método OnConfiguring: este método configura DbContext con la cadena de conexión de base de datos necesaria. Reemplace your_password y your_database con los detalles reales de su servidor PostgreSQL.

• Método OnModelCreating: aquí, puede utilizar la API 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 principal del programa

En el método Main de la clase Program, aseguramos que la base de datos se cree, la rellenamos con datos iniciales si está vacía, y luego realizamos una consulta para recuperar y mostrar datos de empleados.

class Program
{
    static void Main(string[] args)
    {
        using (var context = new AppDbContext())
        {
            context.Database.EnsureCreated();  // Ensure the database and schema are created
            if (!context.Employees.Any())  // Check if the Employees table is empty
            {
                context.Employees.Add(new Employee { LastName = "Software" });
                context.SaveChanges();  // Save changes to the database
            }
            var employees = context.Employees.Where(e => e.LastName == "Software").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();  // Ensure the database and schema are created
            if (!context.Employees.Any())  // Check if the Employees table is empty
            {
                context.Employees.Add(new Employee { LastName = "Software" });
                context.SaveChanges();  // Save changes to the database
            }
            var employees = context.Employees.Where(e => e.LastName == "Software").ToList();
            foreach (var employee in employees)
            {
                Console.WriteLine($"Employee ID: {employee.Id}, Last Name: {employee.LastName}");
            }
        }
    }
}

El código anterior verifica si la base de datos existe y la crea junto con el esquema si no existe. Es una forma sencilla de iniciar una nueva base de datos durante el desarrollo. Esta declaración SQL verifica que, si la tabla Employees está vacía, el programa agrega un nuevo Empleado con el apellido "Software" y guarda los cambios en la base de datos. El programa consulta la tabla Employees para las entradas con el apellido "Software" y imprime sus detalles en la consola.

Resultado

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

Y estos son los datos de la tabla en PgAdmin:

Instalación de IronPDF

Antes de poder usar IronPDF, debe agregarlo a su proyecto. Esto se hace fácilmente a través del Administrador de Paquetes NuGet:

Install-Package IronPdf

Generación de un PDF a partir de datos PostgreSQL

En este ejemplo, generaremos un informe PDF sencillo que enumera a los empleados de nuestra base de datos PostgreSQL. Asumiremos que tiene configurados el AppDbContext y el modelo Employee como se describe en las secciones anteriores.

Primero, asegúrese de tener instalada la biblioteca IronPDF en su proyecto. Luego, puede usar 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";
        // Initialize the database context
        using (var context = new AppDbContext())
        {
            // Fetch employees from the database
            var employees = context.Employees.ToList();
            // Generate HTML content for the 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>";
            // Instantiate the IronPDF HtmlToPdf converter
            var renderer = new ChromePdfRenderer();
            // Generate the PDF document from the HTML content
            var pdf = renderer.RenderHtmlAsPdf(htmlContent);
            // Save the generated PDF to a file
            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";
        // Initialize the database context
        using (var context = new AppDbContext())
        {
            // Fetch employees from the database
            var employees = context.Employees.ToList();
            // Generate HTML content for the 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>";
            // Instantiate the IronPDF HtmlToPdf converter
            var renderer = new ChromePdfRenderer();
            // Generate the PDF document from the HTML content
            var pdf = renderer.RenderHtmlAsPdf(htmlContent);
            // Save the generated PDF to a file
            var outputPath = "f:\\EmployeeReport.pdf";
            pdf.SaveAs(outputPath);
            Console.WriteLine($"PDF report generated: {outputPath}");
        }
    }
}

Resultado

Cuando ejecute el código, esta salida de consola mostrará:

Este PDF se genera: