1. IronPDF
  2. IronPDF-Blog
  3. .NET-Hilfe
  4. C# MySQL-Verbindung
.NET-HILFE

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

Veröffentlicht 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. Dieses Handbuch bietet eine schrittweise Anleitung zur IntegrationMySQLmit C#-Anwendungen und demonstriert, wie PDFs aus den Daten Ihrer MySQL-Datenbank generiert werden können, indem derIronPDF-Bibliothek.

Voraussetzungen

Um diesem Leitfaden zu folgen, benötigen Sie:

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

Einrichten einer MySQL-Datenbank

Installation und Konfiguration von MySQL

  1. Laden Sie die neueste Version von MySQL herunter von mysql.com.

  2. Führen Sie das Installationsprogramm aus und folgen Sie den Einrichtungshinweisen. Wählen Sie "Entwicklerstandard", um MySQL Server und MySQL Workbench einzuschließen.

  3. 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

  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)
);
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. 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);

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;

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.(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.

    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.

    C# MySQL-Verbindung (Wie es für Entwickler funktioniert): Abbildung 2 - Installation von MySql.Data aus dem NuGet-Paket-Manager

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

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.,localhostfür lokale Server oder eine IP-Adresse für Remoteverbindungen).
  • private string database: Stellt den Datenbanknamen dar(SampleDB in diesem Fall).
  • 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 zur 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;";

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

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 zum Einfügen, Lesen, Aktualisieren und Löschen von Daten enthalten.(CRUD) operationen.

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

Erläuterung

  • Parametrisierung: Die Verwendung von @Parameter verringert das Risiko von SQL-Injektionen.
  • connection.Open(): Öffnet die MySQL-Verbindung.
  • cmd.ExecuteNonQuery(): Führt die Einfügeabfrage 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);

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

Erläuterung

  • ExecuteReader(): Führt die SELECT-Abfrage aus und gibt ein MySqlDataReader-Objekt zurück.
  • reader.Read(): Durchläuft das Ergebnis-Set 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!");
    }
}

Aktualisierungskommando: 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

IronPDFist eine robuste Bibliothek, die es Entwicklern ermöglicht, PDF-Dokumente innerhalb von 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 konvertierenInhalt in vollständig formatierte PDF-Dokumente. 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.
  • Bearbeiten von PDFs: 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ühren und -Aufteilen: Mit IronPDF können Sie ganz einfachmehrere PDFs zusammenführenin ein einzelnes Dokument oder geteilteine große PDF-Datei in kleinere Dateien. Diese Funktion ist nützlich für die 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 bietet Ihnen die volle Kontrolle über das Erscheinungsbild Ihrer PDFs, sodass sie Ihren spezifischen Anforderungen entsprechen.

Einrichten von IronPDF in Ihrem C#-Projekt

Zu verwendenIronPDF, installieren Sie es über den NuGet-Paket-Manager in Visual Studio:

Install-Package IronPdf
Install-Package IronPdf

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

Konsolenausgabe:

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

PDF-Ausgabe

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

Aufschlüsselung des Codes

  1. 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.

  2. Einfügeoperation(InsertEmployee):

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

  3. 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.

  4. Aktualisierungsvorgang(UpdateEmployeeSalary):

    • Die Methode akzeptiert eine employeeId und ein newSalary, um das Gehalt des Mitarbeiters zu aktualisieren.
    • Es verwendet eine parametrisierte UPDATE-SQL-Abfrage.

  5. PDF-Erstellung(GeneriereMitarbeiterberichtPDF):

    • 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 mit der MySql.Data-Bibliothek eine Verbindung zu einer MySQL-Datenbank herstellt, Datenbankverbindungen verwaltet und CRUD-Operationen mit parametrierten 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 PDF-Erstellung: IronPDF vereinfacht die Erstellung von professionell aussehenden 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 PDF-Erstellung in ihre C#-Anwendungen integrieren möchten,IronPDFdamit Sie die komplette Funktionssuite testen können. 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.

Jordi Bardia

Jordi Bardia

Software-Ingenieur

 LinkedIn |  Website

Jordi beherrscht vor allem Python, C# und C++. Wenn er seine Fähigkeiten bei Iron Software nicht einsetzt, programmiert er Spiele. Durch seine Mitverantwortung für Produkttests, Produktentwicklung und Forschung trägt Jordi wesentlich zur kontinuierlichen Produktverbesserung bei. Die vielseitigen Erfahrungen, die er sammelt, bieten ihm immer wieder neue Herausforderungen, und er sagt, dass dies einer seiner Lieblingsaspekte bei Iron Software ist. Jordi wuchs in Miami, Florida, auf und studierte Informatik und Statistik an der University of Florida.
< PREVIOUS
Parseint C# (Wie es für Entwickler funktioniert)
NÄCHSTES >
C# Benannte Tupel (Wie es für Entwickler funktioniert)

Ein Problem melden

Sind Sie bereit, loszulegen? Version: 2025.3 gerade veröffentlicht

Gratis NuGet-Download Downloads insgesamt: 12,982,631
Kostenloser Start
NuGet herunterladen DLL herunterladen Windows-Installationsprogramm Kostenlos testen
Lizenzen anzeigen >
Textlogo Iron Suite related to C# MySQL-Verbindung (So funktioniert es für Entwickler)

IronPDF ist ein Teil von IRONSUITE

10 .NET API-Produkte für Ihre Bürodokumente

Erhalten Sie 10 Produkte zum Preis von 2   Kostenlos testen