Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. .NET Hilfe
  4. C# MySQL-Verbindung herstellen
.NET HILFE

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

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
Aktualisiert:

Einführung in die C#-MySQL-Integration

Das Verbinden von C#-Anwendungen mit MySQL-Datenbanken ermöglicht Entwicklern, die Leistungsfähigkeit einer relationalen Datenbank für das effiziente Speichern, Abrufen und Verwalten von Daten zu nutzen. Diese Anleitung bietet einen Schritt-für-Schritt-Prozess zur Integration von MySQL mit C#-Anwendungen und zeigt, wie PDFs aus den Daten innerhalb Ihrer MySQL-Datenbank mithilfe der IronPDF-Bibliothek generiert werden können.

Voraussetzungen

Um dieser Anleitung zu folgen, benötigen Sie:

  • Visual Studio oder eine beliebige C#-IDE
  • Eine MySQL-Datenbank (installiert und laufend)
  • Die IronPDF-Bibliothek (zur PDF-Erzeugung)

MySQL-Datenbank einrichten

Installieren und Konfigurieren von MySQL

  1. Laden Sie die neueste Version von MySQL von mysql.com herunter.
  2. Führen Sie das Installationsprogramm aus und folgen Sie den Setup-Anweisungen. Wählen Sie "Entwickler-Standard", um den MySQL-Server und MySQL Workbench einzuschließen.
  3. Konfigurieren Sie die Anmeldedaten für den MySQL-Root-Benutzer während der Einrichtung und stellen Sie sicher, dass der MySQL-Dienst läuft.

Erstellen einer Beispieldatenbank und von Tabellen

  1. Öffnen Sie MySQL Workbench und verbinden Sie sich mit dem Server.
  2. 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)
);
  1. Fügen Sie Beispiel-Daten ein:
INSERT INTO Employees (FirstName, LastName, Position, Salary) 
VALUES ('John', 'Doe', 'Software Developer', 80000),
       ('Jane', 'Smith', 'Data Analyst', 75000);

MySQL-Benutzer für Fernzugriff einrichten (optional)

Für den Remotezugriff erstellen Sie einen MySQL-Benutzer mit den notwendigen Berechtigungen:

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

Verbinden von C# mit der MySQL-Datenbank

Installation der MySql.Data-Bibliothek in C

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

  1. Öffnen Sie Visual Studio und erstellen Sie eine neue C# Konsolenanwendung.
  2. 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 und installieren Sie MySql.Data.

Schreiben des Verbindungscodes

Das folgende Codebeispiel zeigt, wie man eine Verbindung zu MySQL herstellt:

using System;
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}");
        }
        finally
        {
            connection.Close(); // Ensure the connection is closed after use
        }
    }
}
using System;
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}");
        }
        finally
        {
            connection.Close(); // Ensure the connection is closed after use
        }
    }
}
Imports System
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}")
		Finally
			connection.Close() ' Ensure the connection is closed after use
		End Try
	End Sub
End Class
$vbLabelText   $csharpLabel

Erklärung:

  • Verbindungs-String: Enthält Details wie Server, Datenbankname, Benutzer-ID und Passwort.
  • MySqlConnection: Wird zur Herstellung der Verbindung verwendet.
  • Open() Methode: Versucht, die Verbindung zu öffnen.
  • Fehlerbehandlung: Fängt Ausnahmen ab, um Verbindungsfehler elegant zu behandeln.

Verwendung von DNS SRV Records für Verbindungen (optional)

Wenn Ihre Anwendung in der Cloud gehostet wird oder eine Verbindung zu einer MySQL-Datenbank über DNS SRV Records erfordert, können Sie den Servernamen durch den entsprechenden DNS-Eintrag ersetzen, der zur 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 Verbindungspooling, das hilft, Datenbankverbindungen effizienter zu verwalten. Verbindungspooling reduziert den Aufwand, Verbindungen immer wieder zu öffnen und zu schließen, indem bestehende Verbindungen aus einem Pool wiederverwendet werden.

Wenn Sie das Verhalten des Verbindungspoolings anpassen möchten, können Sie Ihren Verbindungs-String wie folgt anpassen:

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

Handhabung von häufigen Fehlern

Häufige Probleme sind inkorrekte Verbindungs-Strings, Firewall-Beschrä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

Zur Codeorganisation erstellen Sie eine DatabaseHelper-Klasse, um alle Datenbankoperationen zu verwalten. Diese Klasse enthält Methoden für die Insert-, Read-, Update- und Delete-Datenoperationen (CRUD).

using System;
using MySql.Data.MySqlClient;

public class DatabaseHelper
{
    private string connectionString = "Server=localhost;Database=SampleDB;User ID=root;Password=yourpassword;";

    // Method to insert a new employee record
    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);

            // Add parameters to prevent SQL injection
            cmd.Parameters.AddWithValue("@FirstName", firstName);
            cmd.Parameters.AddWithValue("@LastName", lastName);
            cmd.Parameters.AddWithValue("@Position", position);
            cmd.Parameters.AddWithValue("@Salary", salary);

            connection.Open();
            cmd.ExecuteNonQuery(); // Execute the insert command
        }
    }
}
using System;
using MySql.Data.MySqlClient;

public class DatabaseHelper
{
    private string connectionString = "Server=localhost;Database=SampleDB;User ID=root;Password=yourpassword;";

    // Method to insert a new employee record
    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);

            // Add parameters to prevent SQL injection
            cmd.Parameters.AddWithValue("@FirstName", firstName);
            cmd.Parameters.AddWithValue("@LastName", lastName);
            cmd.Parameters.AddWithValue("@Position", position);
            cmd.Parameters.AddWithValue("@Salary", salary);

            connection.Open();
            cmd.ExecuteNonQuery(); // Execute the insert command
        }
    }
}
Imports System
Imports MySql.Data.MySqlClient

Public Class DatabaseHelper
	Private connectionString As String = "Server=localhost;Database=SampleDB;User ID=root;Password=yourpassword;"

	' Method to insert a new employee record
	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)

			' Add parameters to prevent SQL injection
			cmd.Parameters.AddWithValue("@FirstName", firstName)
			cmd.Parameters.AddWithValue("@LastName", lastName)
			cmd.Parameters.AddWithValue("@Position", position)
			cmd.Parameters.AddWithValue("@Salary", salary)

			connection.Open()
			cmd.ExecuteNonQuery() ' Execute the insert command
		End Using
	End Sub
End Class
$vbLabelText   $csharpLabel

Erklärung:

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

Einfügen von Daten in die MySQL-Datenbank

Um neue Mitarbeiterdaten hinzuzufügen, rufen Sie die Methode InsertEmployee 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

Rufen Sie Daten ab und zeigen Sie sie in der Konsole an:

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 Select-Abfrage aus und gibt ein MySqlDataReader-Objekt zurück.
  • reader.Read(): Iteriert durch die Ergebnismenge und zeigt die Details jedes Mitarbeiters an.

Aktualisierung und Löschung 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);

        // Parameterize the SQL command
        cmd.Parameters.AddWithValue("@Salary", newSalary);
        cmd.Parameters.AddWithValue("@EmployeeID", employeeId);

        connection.Open();
        cmd.ExecuteNonQuery(); // Execute the update command
        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);

        // Parameterize the SQL command
        cmd.Parameters.AddWithValue("@Salary", newSalary);
        cmd.Parameters.AddWithValue("@EmployeeID", employeeId);

        connection.Open();
        cmd.ExecuteNonQuery(); // Execute the update command
        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)

		' Parameterize the SQL command
		cmd.Parameters.AddWithValue("@Salary", newSalary)
		cmd.Parameters.AddWithValue("@EmployeeID", employeeId)

		connection.Open()
		cmd.ExecuteNonQuery() ' Execute the update command
		Console.WriteLine("Employee salary updated successfully!")
	End Using
End Sub
$vbLabelText   $csharpLabel

Aktualisierungsbefehl: Verwendet eine parametrisierte Abfrage, um die Gehaltsspalte basierend auf der EmployeeID zu aktualisieren.

Erzeugung von PDFs aus MySQL-Daten mit IronPDF

Einführung in IronPDF

IronPDF ist eine robuste Bibliothek, die es Entwicklern ermöglicht, PDF-Dokumente innerhalb von C#-Anwendungen einfach zu erstellen, zu bearbeiten und zu manipulieren. Sie unterstützt eine breite Palette von PDF-Funktionalitäten und ist ein perfektes Werkzeug für datengetriebene Anwendungen, die automatisierte Berichtsgenerierung, Dokumentenbearbeitung oder HTML-zu-PDF-Konvertierung erfordern. Ob Sie dynamische Webseiten in PDF-Dateien umwandeln oder benutzerdefinierte PDFs von Grund auf neu erstellen müssen, IronPDF vereinfacht den Prozess mit wenigen Codezeilen.

Hauptfunktionen von IronPDF

  • HTML zu PDF-Konvertierung: Eine der herausragenden Funktionen von IronPDF ist die 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 im Webformat gespeichert sind.
  • Bearbeiten von PDFs: IronPDF ermöglicht das Bearbeiten bestehender PDFs, einschließlich dem Hinzufügen, Entfernen und Ändern von Inhalten wie Text, Bildern, Tabellen und mehr. Dies ist ideal für Anwendungen, die bestehende Dokumente verarbeiten oder aktualisieren müssen.
  • PDF-Zusammenführen und -Aufteilen: Mit IronPDF können Sie problemlos mehrere PDFs zu einem einzigen Dokument zusammenführen oder ein großes PDF in kleinere Dateien aufteilen. Diese Funktion ist nützlich zur Organisation und Verwaltung großer Dokumentensammlungen.
  • Styling und Anpassung: Beim Generieren von PDFs aus HTML können Sie CSS verwenden, um das Dokument zu gestalten und ein benutzerdefiniertes Layout zu erreichen, das dem Design Ihrer Anwendung entspricht. IronPDF gibt Ihnen die volle Kontrolle über das Erscheinungsbild Ihrer PDFs und stellt sicher, dass sie Ihre spezifischen Anforderungen erfüllen.

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

Konvertierung von MySQL-Daten in das PDF-Format

Hier ist das vollständige Codebeispiel, das zeigt, wie man einen PDF-Bericht von Mitarbeiterdaten erstellt:

using System;
using MySql.Data.MySqlClient;
using IronPdf;

public class Program
{
    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 System;
using MySql.Data.MySqlClient;
using IronPdf;

public class Program
{
    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 System
Imports MySql.Data.MySqlClient
Imports IronPdf

Public Class Program
	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

Aufschlüsselung des Codes

  1. Verbindung zur MySQL-Datenbank:

    • Der connectionString definiert den MySQL-Server, die Datenbank, den Benutzer und das Passwort.
    • Sie verbinden sich mithilfe von MySqlConnection und verwalten CRUD-Operationen mit MySqlCommand.

  2. Einfügeoperation (InsertEmployee):

    • Verwendet MySqlCommand mit parametrierten Abfragen (@FirstName, @LastName usw.), um SQL-Injection zu verhindern.
    • Nach dem Öffnen der Verbindung (connection.Open()) wird die SQL INSERT-Anweisung mit ExecuteNonQuery() ausgeführt.

  3. Leseoperation (GetEmployees):

    • Führt eine SELECT *-Abfrage aus, um alle Mitarbeiterdatensätze abzurufen.
    • Verwendet einen MySqlDataReader, um die Ergebnismenge zu durchlaufen und jeden Datensatz in der Konsole anzuzeigen.

  4. Aktualisierungsoperation (UpdateEmployeeSalary):

    • Die Methode akzeptiert eine employeeId und ein newSalary, um das Gehalt des Mitarbeiters zu aktualisieren.
    • Es wird eine parametrisierte UPDATE-SQL-Abfrage verwendet.
  5. PDF-Erzeugung (GenerateEmployeeReportPDF):
    • Sammelt Mitarbeiterdaten in einem HTML-String mit einer einfachen Tabellenstruktur.
    • Der HTML-Inhalt wird IronPDFs Methode RenderHtmlAsPdf übergeben, um einen PDF-Bericht zu erstellen.
    • Das resultierende PDF wird als EmployeeReport.pdf gespeichert.

Abschluss

In diesem Artikel sind wir durch die wesentlichen Schritte zur Integration von MySQL mit einer C#-Anwendung gegangen. Vom Einrichten der Datenbank und der Durchführung von CRUD-Operationen bis hin zur PDF-Erstellung mit IronPDF haben wir eine breite Palette grundlegender Themen abgedeckt, die für den Aufbau datengetriebener Anwendungen entscheidend sind. Hier ist eine Zusammenfassung der wichtigsten Konzepte:

  • MySQL- und C#-Integration: Wir haben gezeigt, wie man eine Verbindung zu einer MySQL-Datenbank mit der MySql.Data-Bibliothek herstellt, Datenbankverbindungen verwaltet und mit parametrierten Abfragen CRUD-Operationen durchführt. Dies stellt sicher, dass Daten effizient gespeichert, aktualisiert und auf sichere und organisierte Weise abgerufen werden können.
  • Durchführung von CRUD-Operationen: Mit den Beispielen für Methoden 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 parametrierten Abfragen hilft auch, SQL-Injection-Angriffe zu mildern, wodurch die Sicherheit Ihrer Anwendung gewährleistet wird.
  • IronPDF für die PDF-Erstellung: IronPDF macht es einfach, professionelle PDFs aus dynamischen HTML-Inhalten zu erstellen. Durch die Umwandlung von Daten, die von MySQL abgerufen wurden, in eine HTML-Tabelle, können wir angepasste Berichte erstellen und als PDFs speichern, was nützlich sein kann, um Rechnungen, Berichte, Zusammenfassungen und mehr zu generieren. Die benutzerfreundliche API von IronPDF macht es zu einem ausgezeichneten Werkzeug für jeden C#-Entwickler, der PDF-Generierung innerhalb seiner Anwendungen handhaben muss.

Durch die Kombination von C# und MySQL können Entwickler robuste Anwendungen erstellen, die Daten speichern und verwalten, während sie fortschrittliche Funktionen wie die PDF-Berichterstellung bieten. Diese Fähigkeiten sind nützlich in verschiedenen Branchen, von Finanzen bis hin zu Gesundheit, wo genaue Datenverwaltung und Berichterstellung entscheidend sind.

Für Entwickler, die die PDF-Generierung in ihre C#-Anwendungen integrieren möchten, IronPDF bietet Ihnen die Möglichkeit, das vollständige Funktionsspektrum zu testen. Ob Sie einfache Dokumente oder anspruchsvolle Berichte erstellen müssen, IronPDF kann ein unschätzbares Werkzeug zur Automatisierung der PDF-Erstellung in Ihrem Arbeitsablauf sein.

Häufig gestellte Fragen

Was sind die Voraussetzungen für die Integration von MySQL in C#-Anwendungen?

Um MySQL mit C#-Anwendungen zu integrieren, benötigen Sie eine IDE wie Visual Studio, eine laufende MySQL-Datenbank und IronPDF zur PDF-Erstellung aus Datenbankinhalten.

Wie kann ich MySQL-Daten mit C# in ein PDF konvertieren?

Sie können MySQL-Daten in ein PDF konvertieren, indem Sie die Daten zuerst in einen HTML-String umwandeln und dann die RenderHtmlAsPdf-Methode von IronPDF verwenden, um ein PDF-Dokument zu erstellen.

Wie installiere und konfiguriere ich MySQL für die Verwendung mit C#?

Installieren Sie MySQL, indem Sie es von mysql.com herunterladen, den Installer ausführen und den Einrichtungshinweisen folgen. Wählen Sie 'Developer Default', um MySQL Server und Workbench einzuschließen und die Root-Benutzeranmeldedaten zu konfigurieren.

Welche Bibliothek wird für die Verbindung von C# und MySQL-Datenbanken empfohlen?

Die MySQL Connector/NET-Bibliothek wird empfohlen, um eine Verbindung zwischen C#-Anwendungen und einer MySQL-Datenbank herzustellen. Sie ermöglicht die Verwendung von Verbindungsstrings zur Erleichterung der Kommunikation.

Wie kann ich meine SQL-Abfragen absichern, wenn ich C# mit MySQL verwende?

Um SQL-Abfragen abzusichern, verwenden Sie parametrisierte Abfragen, die helfen, SQL-Injection-Angriffe zu verhindern, indem sie eine ordnungsgemäße Eingabevalidierung sicherstellen.

Was ist Connection Pooling im Zusammenhang mit MySQL und C#?

Connection Pooling bezieht sich auf die Praxis der Wiederverwendung von Datenbankverbindungen aus einem Pool, was die Effizienz steigert, indem es den Overhead beim wiederholten Öffnen und Schließen von Verbindungen reduziert.

Wie erstelle ich eine Beispieldatenbank und -tabelle in MySQL für die Integration in C#?

Öffnen Sie MySQL Workbench, verbinden Sie sich mit Ihrem Server und verwenden Sie SQL-Befehle wie CREATE DATABASE SampleDB; und CREATE TABLE Employees (...);, um eine Beispieldatenbank und -tabelle einzurichten.

Welche Funktionen sollte ich in einer PDF-Bibliothek für C#-Anwendungen suchen?

Eine robuste PDF-Bibliothek für C# sollte Funktionen wie HTML-zu-PDF-Konvertierung, PDF-Bearbeitung, Zusammenfügen und Aufteilen sowie die Möglichkeit bieten, benutzerdefinierte Stile mit CSS anzuwenden, wie sie IronPDF bietet.

Wie führe ich CRUD-Operationen auf einer MySQL-Datenbank mit C# durch?

Implementieren Sie CRUD-Operationen, indem Sie eine Hilfsklasse in C# erstellen, die parametrisierte SQL-Befehle in Methoden verwendet, um Daten in der MySQL-Datenbank einzufügen, zu lesen, zu aktualisieren und zu löschen.

Wie kann ich die Details eines Mitarbeiters in einer MySQL-Datenbank mit C# aktualisieren?

Aktualisieren Sie die Details eines Mitarbeiters, indem Sie eine Methode in C# schreiben, die einen parametrierten UPDATE-SQL-Befehl verwendet, um Änderungen wie Gehaltsaktualisierungen basierend auf der EmployeeID zu ermöglichen.

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
  Jetzt mit dem Ingenieurteam chatten
Chief Technology Officer

Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der führend in der C# PDF-Technologie ist. Als ursprünglicher Entwickler der Iron Software-Kerncodebasis hat er die Produktarchitektur des Unternehmens seit seiner Gründung gestaltet und zusammen mit CEO Cameron Rimington in ein Unternehmen ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen