C# PostgreSQL (Wie es für Entwickler funktioniert)

Willkommen zu diesem Tutorial, das für Anfänger konzipiert ist, die daran interessiert sind, C#-Anwendungen mit PostgreSQL zu integrieren. PostgreSQL gehört zu den weltweit am häufigsten verwendeten relationalen Datenbanken und ist bekannt für seine Zuverlässigkeit und Kompatibilität mit einer Vielzahl von Programmierumgebungen, einschließlich C#. Dieser Leitfaden führt Sie durch die Grundlagen der Verbindung einer C#-Anwendung mit einer PostgreSQL-Datenbank, der Ausführung von SQL-Anweisungen und der Datenverarbeitung. Wir werden Tools wie Visual Studio, NuGet Package Manager und den Npgsql Data Provider verwenden, um ein einfaches Projekt zu erstellen, das mit einem PostgreSQL-Server kommuniziert. Wir werden auch die IronPDF-Bibliothek mit der Integration von PostgreSQL kennenlernen.

Einrichten Ihrer Umgebung

Bevor Sie mit dem Programmieren beginnen, sollten Sie sicherstellen, dass Visual Studio auf Ihrem Computer installiert ist. Visual Studio ist eine beliebte integrierte Entwicklungsumgebung (IDE), die unter anderem C# unterstützt. Für die Datenbankverwaltung können Sie PostgreSQL auf Ihrem lokalen Rechner installieren oder eine PostgreSQL-Datenbank in einer Cloud-Umgebung wie Azure Database einrichten.

Nachdem Sie Visual Studio und Ihren PostgreSQL-Server eingerichtet haben, erstellen Sie ein neues C#-Projekt. Dazu öffnen Sie Visual Studio, gehen in das Menü Datei, wählen Neu und dann Projekt. Wählen Sie als Projekttyp eine Konsolenanwendung (.NET Core), um die Dinge einfach zu halten.

Integration von PostgreSQL mit C#

Um Ihre C#-Anwendung mit einer PostgreSQL-Datenbank zu verbinden, benötigen Sie den Npgsql-Datenanbieter. Npgsql fungiert als Brücke zwischen C#-Anwendungen und PostgreSQL-Datenbanken und ermöglicht es Ihrem Code, SQL-Befehle auszuführen und Daten zu verwalten.

Installieren von Npgsql

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

Konfigurieren der Datenbankverbindung

Der erste Schritt bei der Interaktion mit einer PostgreSQL-Datenbank von C# aus besteht darin, eine Verbindung herzustellen. Dazu ist ein Verbindungsstring erforderlich, der Angaben wie Servername, Port, Benutzername und Passwort enthält. Hier ist eine einfache Vorlage für einen PostgreSQL-Verbindungsstring:

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"

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äsentieren wird. Dieses Modell enthält Eigenschaften, die den Spalten 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; }
}

Public Class Employee
	Public Property Id() As Integer ' -  Automatically becomes the primary key
	Public Property LastName() As String
End Class

Dieser Codeausschnitt definiert eine einfache Employee-Klasse mit zwei Eigenschaften: Id und LastName. Entity Framework Core verwendet Konventionen, um daraus zu schließen, dass die Id-eigenschaft der seriellen Primärschlüssel als Primärschlüssel behandelt werden sollte.

Konfigurieren des DbContext der Anwendung

Die AppDbContext-Klasse erweitert DbContext aus Entity Framework Core und fungiert als Brücke zwischen Ihrer C#-Anwendung und der PostgreSQL-Datenbank. Es enthält Konfigurationsdetails wie die Verbindungszeichenfolge und die DbSet-Eigenschaften, die Tabellen in der Datenbank darstellen.

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

Public Class AppDbContext
	Inherits DbContext

	Public Property Employees() As DbSet(Of Employee) ' -  Represents the Employees table
	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

DbSet-Eigenschaft: public DbSetEmployees { get; gesetzt; }deklariert eine Menge von Employee-Entitäten, die der Mitarbeitertabelle in der PostgreSQL-Datenbank zugeordnet sind.

OnConfiguring-Methode: Diese Methode konfiguriert den DbContext mit dem erforderlichen Datenbank-Verbindungszeichenfolge. Ersetzen Sie your_password und your_database durch Ihre tatsächlichen PostgreSQL-Serverdetails.

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 ausdrücklich an, obwohl es optional ist, wenn der Tabellenname mit dem DbSet-Eigenschaftsnamen übereinstimmt.

Hauptprogramm Logik

In der Methode Main der Klasse Program stellen wir sicher, dass die Datenbank erstellt wird, füllen sie mit Anfangsdaten, falls 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();
            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

Der obige Code prüft, ob die Datenbank existiert und erstellt sie zusammen mit dem Schema, falls dies nicht der Fall ist. Es ist eine unkomplizierte Möglichkeit, eine neue Datenbank während der Entwicklung zu booten. Diese SQL-Anweisung überprüft, ob die Tabelle Employees leer ist. Falls ja, fügt das Programm einen neuen Employee mit dem Nachnamen "Software" hinzu und speichert die Änderungen in der Datenbank. Das Programm fragt die Employees-Tabelle nach Einträgen mit dem Nachnamen "Software" ab und gibt deren Details auf der Konsole aus. Wir können eine SQL-Abfrage hinzufügen, um die Tabelle in der Postgres-Datenbank zu löschen. Wir können auch einen .NET-Datenanbieter für unsere Datenbank hinzufügen.

Ausgabe

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

Und das sind die Tabellendaten in PgAdmin:

Einführung in IronPDF

Entdecken Sie die Möglichkeiten der IronPDF-Bibliothek, um zu verstehen, wie diese umfassende Bibliothek für C# Entwicklern ermöglicht, PDF-Dokumente innerhalb von .NET-Anwendungen zu erstellen, zu bearbeiten und zu manipulieren. Dieses leistungsstarke Tool vereinfacht das Erstellen von PDFs aus HTML, URLs und Bildern. Darüber hinaus bietet es grundlegende PDF-Funktionen wie die Bearbeitung von Text und Bildern und das Hinzufügen von Sicherheitsfunktionen wie Verschlüsselung und digitale Signaturen. IronPDF zeichnet sich durch seine Benutzerfreundlichkeit aus und ermöglicht es Entwicklern, komplexe PDF-Funktionen mit minimalem Code zu implementieren.

IronPDF bietet die Möglichkeit, HTML mühelos in PDF zu konvertieren, während Layouts und Stile unverändert bleiben. Diese Funktion ist ideal zur Erstellung von PDFs aus webbasierenden Inhalten wie Berichten, Rechnungen und Dokumentation. Es konvertiert HTML-Dateien, URLs und HTML-Strings in PDF-Dateien.

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

Die Integration von IronPDF mit einer PostgreSQL-Datenbank kann in Szenarien, in denen Sie PDF-Berichte oder -Dokumente auf der Grundlage dynamischer, in Ihrer Datenbank gespeicherter Daten generieren müssen, von großem Nutzen sein. Dies kann von der Erstellung von Rechnungen, Berichten, Kundenabrechnungen usw. direkt aus den in einer PostgreSQL-Datenbank gespeicherten Daten reichen.

Installation von IronPDF

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

Install-Package IronPdf

Install-Package IronPdf

Erzeugen einer PDF-Datei aus PostgreSQL-Daten

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

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

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

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		IronPdf.License.LicenseKey = "Key"
		' Initialize the database context
		Using context = New AppDbContext()
			' Fetch employees from the database
			Dim employees = context.Employees.ToList()
			' Generate HTML content for the 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>"
			' Instantiate the IronPDF HtmlToPdf converter
			Dim renderer = New ChromePdfRenderer()
			' Generate the PDF document from the HTML content
			Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
			' Save the generated PDF to a file
			Dim outputPath = "f:\EmployeeReport.pdf"
			pdf.SaveAs(outputPath)
			Console.WriteLine($"PDF report generated: {outputPath}")
		End Using
	End Sub
End Class

Ausgabe

Wenn Sie den Code ausführen, wird diese Konsolenausgabe angezeigt:

Dieses PDF wird generiert:

Schlussfolgerung

Sie haben soeben einen wichtigen ersten Schritt in die Welt der Datenbankverwaltung mit C# und PostgreSQL gemacht. Anhand der Anweisungen in diesem Lernprogramm haben Sie gelernt, wie man ein Projekt in Visual Studio einrichtet, die erforderlichen Pakete installiert und grundlegende Datenbankoperationen ausführt. Je mehr Sie sich mit diesen Konzepten vertraut machen, desto mehr werden Sie die Leistungsfähigkeit und Flexibilität der Kombination von C# mit einem der wichtigsten relationalen Datenbanksysteme entdecken. Experimentieren Sie weiter mit verschiedenen Abfragen und Entitätskonfigurationen, um Ihr Verständnis für die Interaktion von C# mit PostgreSQL zu vertiefen.

IronPDF bietet eine kostenlose Testversion der IronPDF-Funktionen, die es Entwicklern ermöglicht, die Funktionen und Möglichkeiten zu erkunden, ohne eine Anfangsinvestition tätigen zu müssen. Diese Testversion ist besonders nützlich, um zu beurteilen, wie gut IronPDF die Anforderungen Ihres Projekts für die Erstellung, Bearbeitung und Konvertierung von PDF-Dokumenten in .NET-Anwendungen erfüllt. Nach der Testphase oder für die produktive Nutzung ist der Erwerb einer Lizenz erforderlich. Die Lizenzierung für IronPDF beginnt bei $749 und bietet eine Reihe von Funktionen und Support-Optionen, die für unterschiedliche Entwicklungsanforderungen geeignet sind.