.NET-HILFE

C# MySQL-Verbindung (So funktioniert es für Entwickler)

Name: IronPDF
Brand: Iron Software
Availability: InStock
Rating: 4.87 (307 reviews)

Chipego Kalinda

16. Dezember 2024

Teilen Sie:

Einführung in die C# MySQL-Integration

Die Verbindung von C#-Anwendungen mit MySQL-Datenbanken ermöglicht es Entwicklern, die Leistungsfähigkeit einer relationalen Datenbank für das effiziente Speichern, Abrufen und Verwalten von Daten zu nutzen. Diese Anleitung bietet einen schrittweisen Prozess zur Integration von IronPDF-Bibliothek erstellen können.

Voraussetzungen

Um diesem Leitfaden zu folgen, benötigen Sie:

Visual Studio oder eine beliebige C#-IDE
Eine MySQL-Datenbank (installiert und läuft)
Die IronPDF-Bibliothek (für die PDF-Erstellung)

Einrichten einer MySQL-Datenbank

Installation und Konfiguration von MySQL

Laden Sie die neueste Version von MySQL von mysql.com herunter.
Führen Sie das Installationsprogramm aus und folgen Sie den Einrichtungshinweisen. Wählen Sie "Entwicklerstandard", um MySQL Server und MySQL Workbench einzuschließen.
Konfigurieren Sie die MySQL-Root-Benutzeranmeldeinformationen während der Einrichtung und stellen Sie sicher, dass der MySQL-Dienst läuft.

Erstellen einer Beispieldatenbank und Tabellen

Öffnen Sie MySQL Workbench und verbinden Sie sich mit dem Server.
Erstellen Sie eine neue Datenbank und eine Beispieltabelle mit SQL-Befehlen:

CREATE DATABASE SampleDB;
USE SampleDB;
CREATE TABLE Employees (
    EmployeeID INT PRIMARY KEY AUTO_INCREMENT,
    FirstName VARCHAR(50),
    LastName VARCHAR(50),
    Position VARCHAR(50),
    Salary DECIMAL(10, 2)
);

CREATE DATABASE SampleDB;
USE SampleDB;
CREATE TABLE Employees (
    EmployeeID INT PRIMARY KEY AUTO_INCREMENT,
    FirstName VARCHAR(50),
    LastName VARCHAR(50),
    Position VARCHAR(50),
    Salary DECIMAL(10, 2)
);

CREATE DATABASE SampleDB
Dim SampleDB As USE
CREATE TABLE Employees(EmployeeID INT PRIMARY KEY AUTO_INCREMENT, FirstName VARCHAR(50), LastName VARCHAR(50), Position VARCHAR(50), Salary [DECIMAL](10, 2))

$vbLabelText $csharpLabel

Beispieldaten einfügen:

INSERT INTO Employees (FirstName, LastName, Position, Salary) 
VALUES ('John', 'Doe', 'Software Developer', 80000),
       ('Jane', 'Smith', 'Data Analyst', 75000);

INSERT INTO Employees (FirstName, LastName, Position, Salary) 
VALUES ('John', 'Doe', 'Software Developer', 80000),
       ('Jane', 'Smith', 'Data Analyst', 75000);

INSERT INTO Employees(FirstName, LastName, Position, Salary) VALUES( 'John', 'Doe', 'Software Developer', 80000), ('Jane', 'Smith', 'Data Analyst', 75000);

$vbLabelText $csharpLabel

Einrichten eines MySQL-Benutzers für Remotezugriff (Optional)

Für den Fernzugriff erstellen Sie einen MySQL-Benutzer mit den erforderlichen Berechtigungen:

CREATE USER 'remoteUser'@'%' IDENTIFIED BY 'password';
GRANT ALL PRIVILEGES ON SampleDB.* TO 'remoteUser'@'%';
FLUSH PRIVILEGES;

CREATE USER 'remoteUser'@'%' IDENTIFIED BY 'password';
GRANT ALL PRIVILEGES ON SampleDB.* TO 'remoteUser'@'%';
FLUSH PRIVILEGES;

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'CREATE USER 'remoteUser"@"c%' IDENTIFIED BY 'password'; GRANT ALL PRIVILEGES @ON SampleDB.* @TO 'remoteUser"@"c%'; FLUSH PRIVILEGES;

$vbLabelText $csharpLabel

Führen Sie das Programm aus, und es sollte jetzt so aussehen:

C# MySQL-Verbindung (Wie es für Entwickler funktioniert): Abbildung 1

Anbindung von C# an MySQL-Datenbank

Installation der MySql.Data-Bibliothek in C

Um C#-Anwendungen mit MySQL zu verbinden, verwenden wir die MySQL Connector/NET-Bibliothek (oft als Connector/NET bezeichnet). Dies ist der offizielle .NET-Treiber für MySQL, der über NuGet installiert werden kann.

Öffnen Sie Visual Studio und erstellen Sie eine neue C#-Konsolenanwendung.
1. Fügen Sie die MySql.Data-Bibliothek über den NuGet-Paket-Manager hinzu:
  - Klicken Sie mit der rechten Maustaste auf das Projekt > NuGet-Pakete verwalten > Durchsuchen > suchen Sie nach MySql.Data und installieren Sie es.

Verbindungscode schreiben

Das folgende Codebeispiel zeigt, wie eine Verbindung zu MySQL hergestellt wird:

using MySql.Data.MySqlClient;
public class Program
{
    // Connection string containing the server, database, user credentials, etc.
    private string connectionString = "Server=localhost;Database=SampleDB;User ID=root;Password=yourpassword;";
    private void Initialize()
    {
        // Create a MySQL connection object
        MySqlConnection connection = new MySqlConnection(connectionString);
        try
        {
            connection.Open();
            Console.WriteLine("Connected to MySQL Database!");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
    }
}

using MySql.Data.MySqlClient;
public class Program
{
    // Connection string containing the server, database, user credentials, etc.
    private string connectionString = "Server=localhost;Database=SampleDB;User ID=root;Password=yourpassword;";
    private void Initialize()
    {
        // Create a MySQL connection object
        MySqlConnection connection = new MySqlConnection(connectionString);
        try
        {
            connection.Open();
            Console.WriteLine("Connected to MySQL Database!");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
    }
}

Imports MySql.Data.MySqlClient
Public Class Program
	' Connection string containing the server, database, user credentials, etc.
	Private connectionString As String = "Server=localhost;Database=SampleDB;User ID=root;Password=yourpassword;"
	Private Sub Initialize()
		' Create a MySQL connection object
		Dim connection As New MySqlConnection(connectionString)
		Try
			connection.Open()
			Console.WriteLine("Connected to MySQL Database!")
		Catch ex As Exception
			Console.WriteLine($"Error: {ex.Message}")
		End Try
	End Sub
End Class

$vbLabelText $csharpLabel

C# MySQL-Verbindung (Wie es für Entwickler funktioniert): Abbildung 3 - Konsolenausgabe: Erfolgreiche Verbindung

Erläuterung

private string server: Repräsentiert den Host (z. B. localhost für lokale Server oder eine IP-Adresse für Remoteverbindungen).
private string database: Repräsentiert den Datenbanknamen (in diesem Fall SampleDB).
private string password: Das Passwort zur Authentifizierung des MySQL-Benutzers.
private MySqlConnection connection: Ein MySQL-Verbindungsobjekt, das verwendet wird, um die Verbindung zu öffnen und zu verwalten.
Im obigen Code wird MySqlConnection verwendet, um die Verbindung mit der MySQL-Datenbank herzustellen.

Verwendung von DNS-SRV-Einträgen für die Verbindung (optional)

Wenn Ihre Anwendung in der Cloud gehostet wird oder eine Verbindung zu einer MySQL-Datenbank über DNS SRV-Einträge erfordert, können Sie den Servernamen durch den entsprechenden DNS-Eintrag ersetzen, der die IP der Datenbank auflöst.

string connectionString = "Server=mysql.example.com;Database=SampleDB;User ID=root;Password=yourpassword;";

string connectionString = "Server=mysql.example.com;Database=SampleDB;User ID=root;Password=yourpassword;";

Dim connectionString As String = "Server=mysql.example.com;Database=SampleDB;User ID=root;Password=yourpassword;"

$vbLabelText $csharpLabel

Verbindungspooling

Standardmäßig unterstützt MySQL Connector/NET das Connection Pooling, was hilft, Datenbankverbindungen effizienter zu verwalten. Connection-Pooling reduziert den Aufwand des wiederholten Öffnens und Schließens von Verbindungen, indem vorhandene Verbindungen aus einem Pool wiederverwendet werden.

Wenn Sie das Verhalten der Verbindungspoolsteuerung anpassen möchten, können Sie Ihre Verbindungszeichenfolge wie folgt ändern:

string connectionString = "Server=localhost;Database=SampleDB;User ID=root;Password=yourpassword;Pooling=true;";

string connectionString = "Server=localhost;Database=SampleDB;User ID=root;Password=yourpassword;Pooling=true;";

Dim connectionString As String = "Server=localhost;Database=SampleDB;User ID=root;Password=yourpassword;Pooling=true;"

$vbLabelText $csharpLabel

Umgang mit häufigen Fehlern

Häufige Probleme sind fehlerhafte Verbindungszeichenfolgen, Firewall-Einschränkungen oder nicht laufender MySQL-Dienst. Stellen Sie sicher, dass alle Konfigurationsdetails korrekt sind und dass der MySQL-Dienst aktiv ist.

Durchführen von CRUD-Operationen mit C# und MySQL

Erstellen einer C#-Klasse für Datenbankoperationen

Erstellen Sie zur Codeorganisation eine DatabaseHelper-Klasse, um alle Datenbankoperationen zu verwalten. Diese Klasse wird Methoden für Einfügen, Lesen, Aktualisieren und Löschen von Daten (CRUD)-Operationen enthalten.

public class DatabaseHelper
{
    private string connectionString = "Server=localhost;Database=SampleDB;User ID=root;Password=yourpassword;";
    public void InsertEmployee(string firstName, string lastName, string position, decimal salary)
    {
        using (var connection = new MySqlConnection(connectionString))
        {
            string query = "INSERT INTO Employees (FirstName, LastName, Position, Salary) VALUES (@FirstName, @LastName, @Position, @Salary)";
            MySqlCommand cmd = new MySqlCommand(query, connection);
            cmd.Parameters.AddWithValue("@FirstName", firstName);
            cmd.Parameters.AddWithValue("@LastName", lastName);
            cmd.Parameters.AddWithValue("@Position", position);
            cmd.Parameters.AddWithValue("@Salary", salary);
            connection.Open();
            cmd.ExecuteNonQuery();
        }
    }
}

public class DatabaseHelper
{
    private string connectionString = "Server=localhost;Database=SampleDB;User ID=root;Password=yourpassword;";
    public void InsertEmployee(string firstName, string lastName, string position, decimal salary)
    {
        using (var connection = new MySqlConnection(connectionString))
        {
            string query = "INSERT INTO Employees (FirstName, LastName, Position, Salary) VALUES (@FirstName, @LastName, @Position, @Salary)";
            MySqlCommand cmd = new MySqlCommand(query, connection);
            cmd.Parameters.AddWithValue("@FirstName", firstName);
            cmd.Parameters.AddWithValue("@LastName", lastName);
            cmd.Parameters.AddWithValue("@Position", position);
            cmd.Parameters.AddWithValue("@Salary", salary);
            connection.Open();
            cmd.ExecuteNonQuery();
        }
    }
}

Public Class DatabaseHelper
	Private connectionString As String = "Server=localhost;Database=SampleDB;User ID=root;Password=yourpassword;"
	Public Sub InsertEmployee(ByVal firstName As String, ByVal lastName As String, ByVal position As String, ByVal salary As Decimal)
		Using connection = New MySqlConnection(connectionString)
			Dim query As String = "INSERT INTO Employees (FirstName, LastName, Position, Salary) VALUES (@FirstName, @LastName, @Position, @Salary)"
			Dim cmd As New MySqlCommand(query, connection)
			cmd.Parameters.AddWithValue("@FirstName", firstName)
			cmd.Parameters.AddWithValue("@LastName", lastName)
			cmd.Parameters.AddWithValue("@Position", position)
			cmd.Parameters.AddWithValue("@Salary", salary)
			connection.Open()
			cmd.ExecuteNonQuery()
		End Using
	End Sub
End Class

$vbLabelText $csharpLabel

Erklärung

Parametrisierung: Die Verwendung von @Parameter verringert das Risiko von SQL-Injection.
connection.Open(): Öffnet die MySQL-Verbindung.
cmd.ExecuteNonQuery(): Führt die Einfüge-Abfrage aus.

Daten in MySQL-Datenbank einfügen

Um neue Mitarbeiterdaten hinzuzufügen, rufen Sie die InsertEmployee-Methode auf:

DatabaseHelper dbHelper = new DatabaseHelper();
dbHelper.InsertEmployee("Alice", "Brown", "Project Manager", 90000);

DatabaseHelper dbHelper = new DatabaseHelper();
dbHelper.InsertEmployee("Alice", "Brown", "Project Manager", 90000);

Dim dbHelper As New DatabaseHelper()
dbHelper.InsertEmployee("Alice", "Brown", "Project Manager", 90000)

$vbLabelText $csharpLabel

Abrufen und Anzeigen von Daten

Daten abrufen und in der Konsole anzeigen:

public void GetEmployees()
{
    using (var connection = new MySqlConnection(connectionString))
    {
        string query = "SELECT * FROM Employees";
        MySqlCommand cmd = new MySqlCommand(query, connection);
        connection.Open();
        using (MySqlDataReader reader = cmd.ExecuteReader())
        {
            while (reader.Read())
            {
                Console.WriteLine($"{reader["FirstName"]} {reader["LastName"]}, Position: {reader["Position"]}, Salary: {reader["Salary"]}");
            }
        }
    }
}

public void GetEmployees()
{
    using (var connection = new MySqlConnection(connectionString))
    {
        string query = "SELECT * FROM Employees";
        MySqlCommand cmd = new MySqlCommand(query, connection);
        connection.Open();
        using (MySqlDataReader reader = cmd.ExecuteReader())
        {
            while (reader.Read())
            {
                Console.WriteLine($"{reader["FirstName"]} {reader["LastName"]}, Position: {reader["Position"]}, Salary: {reader["Salary"]}");
            }
        }
    }
}

Public Sub GetEmployees()
	Using connection = New MySqlConnection(connectionString)
		Dim query As String = "SELECT * FROM Employees"
		Dim cmd As New MySqlCommand(query, connection)
		connection.Open()
		Using reader As MySqlDataReader = cmd.ExecuteReader()
			Do While reader.Read()
				Console.WriteLine($"{reader("FirstName")} {reader("LastName")}, Position: {reader("Position")}, Salary: {reader("Salary")}")
			Loop
		End Using
	End Using
End Sub

$vbLabelText $csharpLabel

Erklärung

ExecuteReader(): Führt die Abfrage aus und gibt ein MySqlDataReader-Objekt zurück.
reader.Read(): Durchläuft die Ergebnismenge und zeigt die Details jedes Mitarbeiters an.

Aktualisieren und Löschen von Datensätzen

Hier ist ein Beispiel, um das Gehalt eines Mitarbeiters zu aktualisieren:

public void UpdateEmployeeSalary(int employeeId, decimal newSalary)
{
    using (var connection = new MySqlConnection(connectionString))
    {
        string query = "UPDATE Employees SET Salary = @Salary WHERE EmployeeID = @EmployeeID";
        MySqlCommand cmd = new MySqlCommand(query, connection);
        cmd.Parameters.AddWithValue("@Salary", newSalary);
        cmd.Parameters.AddWithValue("@EmployeeID", employeeId);
        connection.Open();
        cmd.ExecuteNonQuery();
        Console.WriteLine("Employee salary updated successfully!");
    }
}

public void UpdateEmployeeSalary(int employeeId, decimal newSalary)
{
    using (var connection = new MySqlConnection(connectionString))
    {
        string query = "UPDATE Employees SET Salary = @Salary WHERE EmployeeID = @EmployeeID";
        MySqlCommand cmd = new MySqlCommand(query, connection);
        cmd.Parameters.AddWithValue("@Salary", newSalary);
        cmd.Parameters.AddWithValue("@EmployeeID", employeeId);
        connection.Open();
        cmd.ExecuteNonQuery();
        Console.WriteLine("Employee salary updated successfully!");
    }
}

Public Sub UpdateEmployeeSalary(ByVal employeeId As Integer, ByVal newSalary As Decimal)
	Using connection = New MySqlConnection(connectionString)
		Dim query As String = "UPDATE Employees SET Salary = @Salary WHERE EmployeeID = @EmployeeID"
		Dim cmd As New MySqlCommand(query, connection)
		cmd.Parameters.AddWithValue("@Salary", newSalary)
		cmd.Parameters.AddWithValue("@EmployeeID", employeeId)
		connection.Open()
		cmd.ExecuteNonQuery()
		Console.WriteLine("Employee salary updated successfully!")
	End Using
End Sub

$vbLabelText $csharpLabel

Update-Befehl: Verwendet eine parametrisierte Abfrage, um die Spalte Gehalt basierend auf der Mitarbeiter-ID zu aktualisieren

Erzeugen von PDFs aus MySQL-Daten mit IronPDF

Einführung in IronPDF

IronPDF ist eine leistungsstarke Bibliothek, die Entwicklern ermöglicht, PDF-Dokumente in C#-Anwendungen einfach zu erstellen, zu bearbeiten und zu manipulieren. Es unterstützt eine breite Palette von PDF-Funktionalitäten und ist somit ein perfektes Werkzeug für datengesteuerte Anwendungen, die eine automatisierte Berichtserstellung, Dokumentenmanipulation oder HTML-zu-PDF-Konvertierung erfordern. Egal, ob Sie dynamische Webseiten in PDF-Dateien umwandeln oder benutzerdefinierte PDFs von Grund auf erstellen müssen, IronPDF vereinfacht den Prozess mit nur wenigen Zeilen Code.

Hauptmerkmale von IronPDF

HTML-zu-PDF-Konvertierung: Eine der herausragenden Funktionen von IronPDF ist seine Fähigkeit, HTML-Inhalte in vollständig formatierte PDF-Dokumente umzuwandeln. Diese Funktion ist besonders nützlich für die Erstellung von Berichten aus dynamischen Webinhalten oder bei der Arbeit mit Daten, die in einem Webformat gespeichert sind.
PDFs bearbeiten: IronPDF ermöglicht das Bearbeiten vorhandener PDFs, einschließlich Hinzufügen, Entfernen und Ändern von Inhalten wie Text, Bildern, Tabellen und mehr. Dies ist ideal für Anwendungen, die vorhandene Dokumente verarbeiten oder aktualisieren müssen.
PDF-Zusammenfügen und -Aufteilen: Mit IronPDF können Sie einfach aufteilen. Diese Funktion ist nützlich für die Organisation und Verwaltung großer Dokumentensammlungen.
Styling und Anpassung: Beim Erstellen von PDFs aus HTML können Sie CSS verwenden, um das Dokument zu gestalten und ein individuelles Layout zu erzielen, das dem Design Ihrer Anwendung entspricht. IronPDF bietet Ihnen die volle Kontrolle über das Erscheinungsbild Ihrer PDFs, sodass sie Ihren spezifischen Anforderungen entsprechen.

Einrichten von IronPDF in Ihrem C#-Projekt

Um IronPDF zu verwenden, installieren Sie es über den NuGet-Paket-Manager in Visual Studio:

Install-Package IronPdf

Install-Package IronPdf

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'Install-Package IronPdf

$vbLabelText $csharpLabel

Konvertieren von MySQL-Daten in PDF-Format

Hier ist das vollständige Codebeispiel, das zeigt, wie ein PDF-Bericht mit Mitarbeiterdaten erstellt wird:

using IronPdf;
using System;
using MySql.Data.MySqlClient;
public class Program
{
    // MySQL connection string
    private static string connectionString = "Server=localhost;Database=SampleDB;User ID=root;Password=yourpassword;";
    public static void Main(string[] args)
    {
        // Perform CRUD operations
        DatabaseHelper dbHelper = new DatabaseHelper();
        // Insert a new employee
        dbHelper.InsertEmployee("Alice", "Brown", "Project Manager", 90000);
        // Display employees
        dbHelper.GetEmployees();
        // Update an employee's salary
        dbHelper.UpdateEmployeeSalary(1, 95000);
        // Generate a PDF report
        dbHelper.GenerateEmployeeReportPDF();
        Console.WriteLine("Operations completed.");
    }  
}
public class DatabaseHelper
{
    private string connectionString = "Server=localhost;Database=SampleDB;User ID=root;Password=yourpassword;";
    // Insert employee into database
    public void InsertEmployee(string firstName, string lastName, string position, decimal salary)
    {
        using (var connection = new MySqlConnection(connectionString))
        {
            string query = "INSERT INTO Employees (FirstName, LastName, Position, Salary) VALUES (@FirstName, @LastName, @Position, @Salary)";
            MySqlCommand cmd = new MySqlCommand(query, connection);
            cmd.Parameters.AddWithValue("@FirstName", firstName);
            cmd.Parameters.AddWithValue("@LastName", lastName);
            cmd.Parameters.AddWithValue("@Position", position);
            cmd.Parameters.AddWithValue("@Salary", salary);
            connection.Open();
            cmd.ExecuteNonQuery();
            Console.WriteLine($"Employee {firstName} {lastName} inserted successfully!");
        }
    }
    // Get employees from the database and display them
    public void GetEmployees()
    {
        using (var connection = new MySqlConnection(connectionString))
        {
            string query = "SELECT * FROM Employees";
            MySqlCommand cmd = new MySqlCommand(query, connection);
            connection.Open();
            using (MySqlDataReader reader = cmd.ExecuteReader())
            {
                Console.WriteLine("\nEmployee List:");
                while (reader.Read())
                {
                    Console.WriteLine($"{reader["EmployeeID"]} - {reader["FirstName"]} {reader["LastName"]}, Position: {reader["Position"]}, Salary: {reader["Salary"]}");
                }
            }
        }
    }
    // Update the salary of an employee
    public void UpdateEmployeeSalary(int employeeId, decimal newSalary)
    {
        using (var connection = new MySqlConnection(connectionString))
        {
            string query = "UPDATE Employees SET Salary = @Salary WHERE EmployeeID = @EmployeeID";
            MySqlCommand cmd = new MySqlCommand(query, connection);
            cmd.Parameters.AddWithValue("@Salary", newSalary);
            cmd.Parameters.AddWithValue("@EmployeeID", employeeId);
            connection.Open();
            cmd.ExecuteNonQuery();
            Console.WriteLine($"Employee ID {employeeId}'s salary updated to {newSalary}.");
        }
    }
    // Generate a PDF report of all employees
    public void GenerateEmployeeReportPDF()
    {
        string htmlContent = "<h1>Employee Report</h1><table border='1'><tr><th>EmployeeID</th><th>First Name</th><th>Last Name</th><th>Position</th><th>Salary</th></tr>";
        using (var connection = new MySqlConnection(connectionString))
        {
            string query = "SELECT * FROM Employees";
            MySqlCommand cmd = new MySqlCommand(query, connection);
            connection.Open();
            using (MySqlDataReader reader = cmd.ExecuteReader())
            {
                while (reader.Read())
                {
                    htmlContent += $"<tr><td>{reader["EmployeeID"]}</td><td>{reader["FirstName"]}</td><td>{reader["LastName"]}</td><td>{reader["Position"]}</td><td>{reader["Salary"]}</td></tr>";
                }
            }
        }
        htmlContent += "</table>";
        // Use IronPDF to convert HTML to PDF
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        PdfDocument pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs("EmployeeReport.pdf");
        Console.WriteLine("PDF Report generated successfully!");
    }
}

using IronPdf;
using System;
using MySql.Data.MySqlClient;
public class Program
{
    // MySQL connection string
    private static string connectionString = "Server=localhost;Database=SampleDB;User ID=root;Password=yourpassword;";
    public static void Main(string[] args)
    {
        // Perform CRUD operations
        DatabaseHelper dbHelper = new DatabaseHelper();
        // Insert a new employee
        dbHelper.InsertEmployee("Alice", "Brown", "Project Manager", 90000);
        // Display employees
        dbHelper.GetEmployees();
        // Update an employee's salary
        dbHelper.UpdateEmployeeSalary(1, 95000);
        // Generate a PDF report
        dbHelper.GenerateEmployeeReportPDF();
        Console.WriteLine("Operations completed.");
    }  
}
public class DatabaseHelper
{
    private string connectionString = "Server=localhost;Database=SampleDB;User ID=root;Password=yourpassword;";
    // Insert employee into database
    public void InsertEmployee(string firstName, string lastName, string position, decimal salary)
    {
        using (var connection = new MySqlConnection(connectionString))
        {
            string query = "INSERT INTO Employees (FirstName, LastName, Position, Salary) VALUES (@FirstName, @LastName, @Position, @Salary)";
            MySqlCommand cmd = new MySqlCommand(query, connection);
            cmd.Parameters.AddWithValue("@FirstName", firstName);
            cmd.Parameters.AddWithValue("@LastName", lastName);
            cmd.Parameters.AddWithValue("@Position", position);
            cmd.Parameters.AddWithValue("@Salary", salary);
            connection.Open();
            cmd.ExecuteNonQuery();
            Console.WriteLine($"Employee {firstName} {lastName} inserted successfully!");
        }
    }
    // Get employees from the database and display them
    public void GetEmployees()
    {
        using (var connection = new MySqlConnection(connectionString))
        {
            string query = "SELECT * FROM Employees";
            MySqlCommand cmd = new MySqlCommand(query, connection);
            connection.Open();
            using (MySqlDataReader reader = cmd.ExecuteReader())
            {
                Console.WriteLine("\nEmployee List:");
                while (reader.Read())
                {
                    Console.WriteLine($"{reader["EmployeeID"]} - {reader["FirstName"]} {reader["LastName"]}, Position: {reader["Position"]}, Salary: {reader["Salary"]}");
                }
            }
        }
    }
    // Update the salary of an employee
    public void UpdateEmployeeSalary(int employeeId, decimal newSalary)
    {
        using (var connection = new MySqlConnection(connectionString))
        {
            string query = "UPDATE Employees SET Salary = @Salary WHERE EmployeeID = @EmployeeID";
            MySqlCommand cmd = new MySqlCommand(query, connection);
            cmd.Parameters.AddWithValue("@Salary", newSalary);
            cmd.Parameters.AddWithValue("@EmployeeID", employeeId);
            connection.Open();
            cmd.ExecuteNonQuery();
            Console.WriteLine($"Employee ID {employeeId}'s salary updated to {newSalary}.");
        }
    }
    // Generate a PDF report of all employees
    public void GenerateEmployeeReportPDF()
    {
        string htmlContent = "<h1>Employee Report</h1><table border='1'><tr><th>EmployeeID</th><th>First Name</th><th>Last Name</th><th>Position</th><th>Salary</th></tr>";
        using (var connection = new MySqlConnection(connectionString))
        {
            string query = "SELECT * FROM Employees";
            MySqlCommand cmd = new MySqlCommand(query, connection);
            connection.Open();
            using (MySqlDataReader reader = cmd.ExecuteReader())
            {
                while (reader.Read())
                {
                    htmlContent += $"<tr><td>{reader["EmployeeID"]}</td><td>{reader["FirstName"]}</td><td>{reader["LastName"]}</td><td>{reader["Position"]}</td><td>{reader["Salary"]}</td></tr>";
                }
            }
        }
        htmlContent += "</table>";
        // Use IronPDF to convert HTML to PDF
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        PdfDocument pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs("EmployeeReport.pdf");
        Console.WriteLine("PDF Report generated successfully!");
    }
}

Imports Microsoft.VisualBasic
Imports IronPdf
Imports System
Imports MySql.Data.MySqlClient
Public Class Program
	' MySQL connection string
	Private Shared connectionString As String = "Server=localhost;Database=SampleDB;User ID=root;Password=yourpassword;"
	Public Shared Sub Main(ByVal args() As String)
		' Perform CRUD operations
		Dim dbHelper As New DatabaseHelper()
		' Insert a new employee
		dbHelper.InsertEmployee("Alice", "Brown", "Project Manager", 90000)
		' Display employees
		dbHelper.GetEmployees()
		' Update an employee's salary
		dbHelper.UpdateEmployeeSalary(1, 95000)
		' Generate a PDF report
		dbHelper.GenerateEmployeeReportPDF()
		Console.WriteLine("Operations completed.")
	End Sub
End Class
Public Class DatabaseHelper
	Private connectionString As String = "Server=localhost;Database=SampleDB;User ID=root;Password=yourpassword;"
	' Insert employee into database
	Public Sub InsertEmployee(ByVal firstName As String, ByVal lastName As String, ByVal position As String, ByVal salary As Decimal)
		Using connection = New MySqlConnection(connectionString)
			Dim query As String = "INSERT INTO Employees (FirstName, LastName, Position, Salary) VALUES (@FirstName, @LastName, @Position, @Salary)"
			Dim cmd As New MySqlCommand(query, connection)
			cmd.Parameters.AddWithValue("@FirstName", firstName)
			cmd.Parameters.AddWithValue("@LastName", lastName)
			cmd.Parameters.AddWithValue("@Position", position)
			cmd.Parameters.AddWithValue("@Salary", salary)
			connection.Open()
			cmd.ExecuteNonQuery()
			Console.WriteLine($"Employee {firstName} {lastName} inserted successfully!")
		End Using
	End Sub
	' Get employees from the database and display them
	Public Sub GetEmployees()
		Using connection = New MySqlConnection(connectionString)
			Dim query As String = "SELECT * FROM Employees"
			Dim cmd As New MySqlCommand(query, connection)
			connection.Open()
			Using reader As MySqlDataReader = cmd.ExecuteReader()
				Console.WriteLine(vbLf & "Employee List:")
				Do While reader.Read()
					Console.WriteLine($"{reader("EmployeeID")} - {reader("FirstName")} {reader("LastName")}, Position: {reader("Position")}, Salary: {reader("Salary")}")
				Loop
			End Using
		End Using
	End Sub
	' Update the salary of an employee
	Public Sub UpdateEmployeeSalary(ByVal employeeId As Integer, ByVal newSalary As Decimal)
		Using connection = New MySqlConnection(connectionString)
			Dim query As String = "UPDATE Employees SET Salary = @Salary WHERE EmployeeID = @EmployeeID"
			Dim cmd As New MySqlCommand(query, connection)
			cmd.Parameters.AddWithValue("@Salary", newSalary)
			cmd.Parameters.AddWithValue("@EmployeeID", employeeId)
			connection.Open()
			cmd.ExecuteNonQuery()
			Console.WriteLine($"Employee ID {employeeId}'s salary updated to {newSalary}.")
		End Using
	End Sub
	' Generate a PDF report of all employees
	Public Sub GenerateEmployeeReportPDF()
		Dim htmlContent As String = "<h1>Employee Report</h1><table border='1'><tr><th>EmployeeID</th><th>First Name</th><th>Last Name</th><th>Position</th><th>Salary</th></tr>"
		Using connection = New MySqlConnection(connectionString)
			Dim query As String = "SELECT * FROM Employees"
			Dim cmd As New MySqlCommand(query, connection)
			connection.Open()
			Using reader As MySqlDataReader = cmd.ExecuteReader()
				Do While reader.Read()
					htmlContent &= $"<tr><td>{reader("EmployeeID")}</td><td>{reader("FirstName")}</td><td>{reader("LastName")}</td><td>{reader("Position")}</td><td>{reader("Salary")}</td></tr>"
				Loop
			End Using
		End Using
		htmlContent &= "</table>"
		' Use IronPDF to convert HTML to PDF
		Dim renderer As New ChromePdfRenderer()
		Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(htmlContent)
		pdf.SaveAs("EmployeeReport.pdf")
		Console.WriteLine("PDF Report generated successfully!")
	End Sub
End Class

$vbLabelText $csharpLabel

Konsolenausgabe:

C# MySQL-Verbindung (Wie es für Entwickler funktioniert): Abbildung 4

PDF-Ausgabe

C# MySQL-Verbindung (Wie es für Entwickler funktioniert): Abbildung 5

Aufschlüsselung des Codes

Verbindung zur MySQL-Datenbank:
- Die connectionString definiert den MySQL-Server, die Datenbank, den Benutzer und das Passwort.
- Sie verbinden sich mit MySqlConnection und führen CRUD-Operationen mit MySqlCommand aus.
Einfügeoperation (InsertEmployee):
- Verwendet MySqlCommand mit parameterisierten Abfragen (@FirstName, @LastName, usw.), um SQL-Injection zu verhindern.
- Nachdem die Verbindung geöffnet wurde (connection.Open()), führt ExecuteNonQuery() die INSERT-SQL-Anweisung aus.
Leseoperation (GetEmployees):
- Führt eine SELECT * Abfrage aus, um alle Mitarbeiterdatensätze abzurufen.
- Verwendet einen MySqlDataReader, um über das Ergebnisset zu iterieren und jeden Datensatz in der Konsole anzuzeigen.
Aktualisierungsvorgang (UpdateEmployeeSalary):
- Die Methode akzeptiert eine employeeId und ein newSalary, um das Gehalt des Mitarbeiters zu aktualisieren.
- Es verwendet eine parametrisierte UPDATE-SQL-Abfrage.
PDF-Generierung (GenerateEmployeeReportPDF):
- Sammelt Mitarbeiterdaten in einem HTML-String mit einer einfachen Tabellenstruktur.
- Der HTML-Inhalt wird an die Methode HtmlToPdf.StaticRenderHtmlAsPdf von IronPDF übergeben, um einen PDF-Bericht zu erstellen.
- Die resultierende PDF wird als EmployeeReport.pdf gespeichert.

Schlussfolgerung

In diesem Artikel haben wir die grundlegenden Schritte zur Integration von MySQL in eine C#-Anwendung durchlaufen. Von der Einrichtung der Datenbank und der Durchführung von CRUD-Operationen bis hin zur Erstellung von PDFs mit IronPDF haben wir ein breites Spektrum an grundlegenden Themen abgedeckt, die entscheidend für den Aufbau datengetriebener Anwendungen sind. Hier ist eine Zusammenfassung der Hauptkonzepte:

MySQL und C# Integration: Wir haben gezeigt, wie man sich mit der MySQL-Datenbank über die MySql.Data-Bibliothek verbindet, Datenbankverbindungen verwaltet und CRUD-Operationen mit parametrisierten Abfragen durchführt. Dies sorgt dafür, dass Daten effizient gespeichert, aktualisiert und auf sichere und organisierte Weise abgerufen werden können.
Durchführen von CRUD-Operationen: Mit den Beispielmethoden zum Einfügen, Aktualisieren und Lesen von Mitarbeiterdaten können Sie diese Logik erweitern, um andere Arten von Datensätzen in einer realen Datenbank zu verwalten. Die Verwendung von parametrisierten Abfragen hilft auch, SQL-Injection-Angriffe zu mildern und die Sicherheit Ihrer Anwendung zu gewährleisten.
IronPDF für die PDF-Erstellung: IronPDF vereinfacht die Erstellung professionell aussehender PDFs aus dynamischen HTML-Inhalten. Indem wir Daten, die aus MySQL abgerufen wurden, in eine HTML-Tabelle umwandeln, können wir benutzerdefinierte Berichte erstellen und sie als PDFs speichern, was nützlich für die Erstellung von Rechnungen, Berichten, Zusammenfassungen und mehr sein kann. Die einfache API von IronPDF macht es zu einem hervorragenden Werkzeug für jeden C#-Entwickler, der PDF-Erstellung in seinen Anwendungen handhaben muss.
Durch die Kombination von C# und MySQL können Entwickler robuste Anwendungen erstellen, die Daten speichern und verwalten, während sie erweiterte Funktionen wie PDF-Berichterstattung bieten. Diese Funktionen sind in verschiedenen Branchen nützlich, von Finanzen bis hin zu Gesundheitswesen, wo eine genaue Datenverwaltung und Berichterstattung entscheidend sind.
Für Entwickler, die die PDF-Erstellung in ihre C#-Anwendungen einbinden möchten, bietet IronPDF die Möglichkeit, das vollständige Funktionsspektrum zu testen. Egal, ob Sie einfache Dokumente oder anspruchsvolle Berichte erstellen müssen, kann IronPDF ein wertvolles Werkzeug zur Automatisierung der PDF-Erstellung in Ihrem Arbeitsablauf sein.

Chipego Kalinda

Jetzt mit dem Ingenieurteam chatten

Software-Ingenieur

Chipego hat eine natürliche Fähigkeit zum Zuhören, die ihm hilft, Kundenprobleme zu verstehen und intelligente Lösungen anzubieten. Er trat dem Iron Software-Team 2023 bei, nachdem er einen Bachelor of Science in Informationstechnologie erworben hatte. IronPDF und IronOCR sind die beiden Produkte, auf die sich Chipego konzentriert hat, aber sein Wissen über alle Produkte wächst täglich, da er neue Wege findet, Kunden zu unterstützen. Er genießt die Zusammenarbeit bei Iron Software, da Teammitglieder aus dem gesamten Unternehmen ihre unterschiedlichen Erfahrungen einbringen und so zu effektiven, innovativen Lösungen beitragen. Wenn Chipego nicht an seinem Schreibtisch sitzt, kann man ihn oft bei einem guten Buch oder beim Fußballspielen antreffen.

< PREVIOUS
Parseint C# (Wie es für Entwickler funktioniert)

NÄCHSTES >
C# Benannte Tupel (Wie es für Entwickler funktioniert)