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, das Ausführen von SQL-Abfrageanweisungen und die Datenhandhabung. Wir verwenden Werkzeuge wie Visual Studio, NuGet Package Manager und den Npgsql-Datenanbieter, um ein einfaches Projekt zu erstellen, das mit einem PostgreSQL-Server kommuniziert. Wir werden auch mehr über die IronPDF-Bibliothek mit der Integration von PostgreSQL lernen.
Bevor Sie mit dem Codieren beginnen, stellen Sie sicher, 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 das Datenbankmanagement installieren Sie PostgreSQL auf Ihrem lokalen Rechner oder richten Sie eine PostgreSQL-Datenbank in einer Cloud-Umgebung wie Azure-Datenbank ein.
Nach der Einrichtung von Visual Studio und Ihrem PostgreSQL-Server erstellen Sie ein neues C#-Projekt. Sie können dies tun, indem Sie Visual Studio öffnen, zum Menü Datei gehen, Neu auswählen und dann Projekt. Wählen Sie eine Konsolenanwendung (.NET Core) als Projekttyp, um die Dinge einfach zu halten.
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, sodass Ihr Code SQL-Befehle ausführen und Daten verwalten kann.
Ö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.
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";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.
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 Property Id() As Integer ' - Automatically becomes the primary key
Public Property LastName() As String
End ClassDieses 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.
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
Inherits DbContext
Public Property Employees As DbSet(Of Employee) ' Represents the Employees table
Protected Overrides Sub OnConfiguring(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(modelBuilder As ModelBuilder)
modelBuilder.Entity(Of Employee)().ToTable("Employees")
End Sub
End ClassDbSet-Eigenschaft:** public DbSet<Employee> 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.
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}");
}
}
}
}Friend Class Program
Shared Sub Main(ByVal args() As String)
Using context = New AppDbContext()
context.Database.EnsureCreated() ' Ensure the database and schema are created
If Not context.Employees.Any() Then ' Check if the Employees table is empty
context.Employees.Add(New Employee With {.LastName = "Software"})
context.SaveChanges() ' Save changes to the database
End If
Dim employees = context.Employees.Where(Function(e) e.LastName = "Software").ToList()
For Each employee In employees
Console.WriteLine($"Employee ID: {employee.Id}, Last Name: {employee.LastName}")
Next employee
End Using
End Sub
End ClassDer 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 überprüft, ob die Employees-Tabelle 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 nach Einträgen in der Employees-Tabelle mit dem Nachnamen "Software" und druckt deren Details auf die Konsole.
Hier ist die Konsolenausgabe, wenn Sie das Programm ausführen:
Und es ist die Tabellendaten in PgAdmin:
Erkunden Sie die Fähigkeiten 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 editieren und zu manipulieren. Dieses leistungsstarke Tool vereinfacht die Erstellung von PDFs aus HTML, URLs und Bildern. Es bietet auch wesentliche PDF-Operationen wie das Bearbeiten von Text und Bildern sowie das Hinzufügen von Sicherheitsfunktionen wie Verschlüsselung und digitalen Signaturen. IronPDF zeichnet sich durch seine Benutzerfreundlichkeit aus, die Entwicklern ermöglicht, 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 eignet sich hervorragend zum Erstellen von PDFs aus webbasierten Inhalten wie Berichten, Rechnungen und Dokumentationen. Es konvertiert HTML-Dateien, URLs und HTML-Zeichenfolgen 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");
}
}Imports IronPdf
Module Program
Sub Main(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 ModuleDie Integration von IronPDF mit einer PostgreSQL-Datenbank kann in Szenarien äußerst nützlich sein, in denen Sie PDF-Berichte oder Dokumente basierend auf dynamischen Daten generieren müssen, die in Ihrer Datenbank gespeichert sind. Dies könnte von der Erstellung von Rechnungen, Berichten, Kundenabrechnungen und mehr direkt aus den in einer PostgreSQL-Datenbank gespeicherten Daten reichen.
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:
PM > Install-Package IronPdf
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}");
}
}
}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 ClassWenn Sie den Code ausführen, zeigt diese Konsolenausgabe:
Dieses PDF wird generiert:
Sie haben gerade einen bedeutenden ersten Schritt in die Welt des Datenbankmanagements mit C# und PostgreSQL gemacht. Indem Sie den Anweisungen in diesem Tutorial folgen, haben Sie gelernt, wie man ein Projekt in Visual Studio einrichtet, die erforderlichen Pakete installiert und grundlegende Datenbankoperationen ausführt. Wenn Sie mit diesen Konzepten vertrauter werden, werden Sie die Macht 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 dafür zu vertiefen, wie C# mit PostgreSQL interagiert.
IronPDF bietet eine kostenlose Testversion der IronPDF-Features, die es Entwicklern ermöglicht, ihre Funktionen und Fähigkeiten ohne anfängliche Investition zu erkunden. Diese Testversion ist besonders nützlich zur Bewertung, 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 den Produktionseinsatz ist der Erwerb einer Lizenz erforderlich. Die Lizenzierung für IronPDF beginnt bei $999 und bietet eine Vielzahl von Funktionen und Support-Optionen, die für verschiedene Entwicklungsbedürfnisse geeignet sind.
Jacob Mellor is Chief Technology Officer at Iron Software and a visionary engineer pioneering C# PDF technology. As the original developer behind Iron Software's core codebase, he has shaped the company's product architecture since its inception, transforming it alongside CEO Cameron Rimington into a 50+ person company serving NASA, Tesla, and global government agencies.
10 .NET-API-Produkte für Ihre Bürodokumente
Wenn Ihr PDF wie HTML aussehen soll, schnell.
