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

Willkommen zu diesem Tutorial, das sich an Anfänger richtet, die sich für die Integration von C#-Anwendungen mit PostgreSQL. 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 neben anderen Programmiersprachen auch 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 eine Konsolenanwendung (.NET Core) als Projekttyp, 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 Daten Ihres PostgreSQL-Servers.

Definition des Mitarbeitermodells

Wir definieren ein Entitätsmodell Mitarbeiter, das unsere Daten in der PostgreSQL-Datenbank darstellt. 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 Codeschnipsel definiert eine einfache Klasse Employee mit zwei Eigenschaften: Id und LastName. Entity Framework Core verwendet Konventionen, um abzuleiten, dass die serielle Primärschlüssel-Eigenschaft Id als Primärschlüssel behandelt werden sollte.

Konfigurieren des DbContext der Anwendung

Die Klasse AppDbContext erweitert DbContext von Entity Framework Core und dient als Brücke zwischen Ihrer C# Anwendung und der PostgreSQL Datenbank. Sie 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 DbSet Mitarbeiter { bekommen; gesetzt; } deklariert einen Satz von Mitarbeiter-Entitäten, die auf die Mitarbeitertabelle in der PostgreSQL-Datenbank abgebildet werden.

methode OnConfiguring: Diese Methode konfiguriert den DbContext mit der erforderlichen Datenbankverbindungszeichenfolge. Ersetzen Sie Ihr_Passwort und Ihre_Datenbank** durch Ihre tatsächlichen PostgreSQL-Serverdaten.

methode OnModelCreating: Hier können Sie die Fluent-API verwenden, um das Verhalten von Entitäten weiter zu konfigurieren. In diesem Beispiel wird der Tabellenname explizit angegeben, obwohl dies optional ist, wenn der Tabellenname mit dem Eigenschaftsnamen DbSet** ü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 Mitarbeiter leer ist, fügt einen neuen Mitarbeiter mit dem Nachnamen "Software" hinzu und speichert die Änderungen in der Datenbank. Das Programm sucht in der Tabelle Employees nach Einträgen mit dem Nachnamen "Software" 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

IronPDF ist eine umfassende Bibliothek für C#, mit der Entwickler PDF-Dokumente in .NET-Anwendungen erstellen, bearbeiten und manipulieren können. Dieses leistungsstarke Tool vereinfacht erzeugung von PDFs aus HTML, URLs und Bilder. 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 zur Umwandlung HTML zu PDF, 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

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 gehen davon aus, dass Sie das AppDbContext- und 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 kostenloser Test die es Entwicklern ermöglicht, die Funktionen und Möglichkeiten der Software ohne Anfangsinvestitionen zu testen. 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 von IronPDF beginnt bei $749 und bietet eine Reihe von Funktionen und Support-Optionen, die für unterschiedliche Entwicklungsanforderungen geeignet sind.