C# PostgreSQL (Funktionsweise für Entwickler)

Installation von Npgsql

Öffnen Sie Ihr neu erstelltes Projekt in Visual Studio. Klicken Sie mit der rechten Maustaste in der Projektmappen-Explorer auf Ihr Projekt, wählen Sie "NuGet-Pakete verwalten" und suchen Sie nach dem Npgsql-Paket. Installieren Sie es, indem Sie auf den Installationsknopf neben dem Paketnamen klicken. Diese Aktion fügt den Npgsql-Datenanbieter zu Ihrem Projekt hinzu, sodass Ihre Anwendung mit PostgreSQL kommunizieren kann. Sie können es auch mithilfe der Paketmanager-Konsole installieren.

Konfiguration der Datenbankverbindung

Der erste Schritt zur Interaktion mit einer PostgreSQL-Datenbank aus C# besteht darin, eine Verbindung herzustellen. Dies erfordert eine Verbindungszeichenfolge, die Details wie den Servernamen, Port, Benutzernamen und das Passwort enthält. Hier ist eine grundlegende Vorlage für eine PostgreSQL-Verbindungszeichenfolge:

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

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

Ersetzen Sie localhost, yourpassword und mydatabase durch die Details Ihres PostgreSQL-Servers.

Definition des Mitarbeitermodells

Wir definieren ein Employee-Entitätsmodell, das unsere Daten in der PostgreSQL-Datenbank repräsentiert. Dieses Modell umfasst Eigenschaften, die den Spalten in der Datenbanktabelle entsprechen.

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

Dieses Code-Beispiel definiert eine einfache Employee-Klasse mit zwei Eigenschaften: Id und LastName. Entity Framework Core verwendet Konventionen, um zu schlussfolgern, dass die Id Serial Primary Key-Eigenschaft als Primärschlüssel behandelt werden sollte.

Den DbContext der Anwendung konfigurieren

Die AppDbContext-Klasse erweitert DbContext von Entity Framework Core und fungiert als Brücke zwischen Ihrer C#-Anwendung und der PostgreSQL-Datenbank. Sie beinhaltet Konfigurationsdetails wie die Verbindungszeichenfolge und die DbSet-Eigenschaften, die Tabellen in der Datenbank repräsentieren.

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

• DbSet-Eigenschaft:** public DbSet Mitarbeiter { abrufen; set; } deklariert eine Menge von Employee**-Entitäten, die der Mitarbeitertabelle in der PostgreSQL-Datenbank zugeordnet sind.

• OnConfiguring-Methode: Diese Methode konfiguriert den DbContext mit der erforderlichen Datenbankverbindungszeichenfolge. Ersetzen Sie your_password und your_database durch die tatsächlichen Details Ihres PostgreSQL-Servers.

• OnModelCreating-Methode: Hier können Sie die Fluent API verwenden, um das Verhalten von Entitäten weiter zu konfigurieren. In diesem Beispiel geben wir den Tabellennamen explizit an, obwohl dies optional ist, wenn der Tabellenname mit dem DbSet-Eigenschaftsnamen übereinstimmt.

Hauptprogrammlogik

Im Program-Klassenmethode Main stellen wir sicher, dass die Datenbank erstellt wird, fügen sie mit Initialdaten hinzu, wenn sie leer ist, und führen dann eine Abfrage durch, um Mitarbeiterdaten abzurufen und anzuzeigen.

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

Der obige Code überprüft, ob die Datenbank existiert, und erstellt sie zusammen mit dem Schema, falls nicht. Es ist ein einfacher Weg, eine neue Datenbank während der Entwicklung zu bootstrappen. Diese SQL-Anweisung prüft, ob die Employees-Tabelle leer ist, und das Programm fügt einen neuen Employee mit dem Nachnamen "Software" hinzu und speichert die Änderungen in der Datenbank. Das Programm fragt nach Einträgen in der Employees-Tabelle mit dem Nachnamen "Software" und druckt deren Details auf die Konsole.

Ausgabe

Hier ist die Konsolenausgabe, wenn Sie das Programm ausführen:

Und es ist die Tabellendaten in PgAdmin:

Installation von IronPDF

Bevor Sie IronPDF verwenden können, müssen Sie es zu Ihrem Projekt hinzufügen. Dies ist einfach über den NuGet-Paket-Manager zu erledigen:

Install-Package IronPdf

Erzeugung einer PDF-Datei aus PostgreSQL-Daten

In diesem Beispiel generieren wir einen einfachen PDF-Bericht, der Mitarbeiter aus unserer PostgreSQL-Datenbank auflistet. Wir gehen davon aus, dass Sie das AppDbContext und Employee-Modell wie in den vorherigen Abschnitten beschrieben eingerichtet haben.

Stellen Sie zuerst sicher, dass die IronPDF-Bibliothek in Ihrem Projekt installiert ist. Dann können Sie den folgenden Code verwenden, um Daten aus der PostgreSQL-Datenbank abzurufen und einen PDF-Bericht zu generieren:

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

Ausgabe

Wenn Sie den Code ausführen, zeigt diese Konsolenausgabe:

Dieses PDF wird generiert: