.NET Software-Entwicklung (Wie es für Entwickler funktioniert)

.NET-Framework Software-Entwicklung ist ein leistungsfähiges, vielseitiges, von Microsoft unterstütztes Framework, das es .NET-Entwicklern ermöglicht, robuste, hochwertige Anwendungen für verschiedene Plattformen, Betriebssysteme und Geräte zu erstellen. Dieses Softwareentwicklungs-Framework ist umfassend angelegt und bietet Tools, Bibliotheken und APIs, mit denen Softwareentwickler Web-, Desktop- und mobile Anwendungen effizient auf der .NET-Plattform erstellen können.

Durch die Unterstützung mehrerer Programmiersprachen, darunter C#, Visual Basic und F#, bietet die .NET-Entwicklung den Entwicklern mehr Flexibilität, so dass sie in ihrer bevorzugten Sprache arbeiten und gleichzeitig von den umfangreichen Funktionen des .NET Core-Ökosystems profitieren können. In diesem Lernprogramm sehen wir IronPDF in Aktion, um die .NET-Entwicklung für die Lösung eines realen Problems zu demonstrieren.

Das Ökosystem der .NET-Softwareentwicklung verstehen

Das .NET-Ökosystem, eine wichtige .NET-Implementierung, ist eine breit angelegte, umfassende Plattform, die verschiedene Komponenten und Technologien umfasst, die die Anwendungsentwicklung auf unterschiedlichen Betriebssystemen erleichtern sollen. Im Kern dienen das .NET-Framework und .NET Core als primäre Motoren für die Ausführung von .NET-Anwendungen und bieten eine gemeinsame Sprachlaufzeit (CLR) die die Ausführung von Code verwaltet und Dienste wie Speicherverwaltung, Typsicherheit, Ausnahmebehandlung und mehr bietet.

Die Common Language Runtime (CLR)

Die CLR ist ein entscheidendes Element der .NET-Architektur und ermöglicht die Ausführung von .NET-Code auf verschiedenen Betriebssystemen. Es kompiliert die Common Intermediate Language (CIL) in nativen Maschinencode umwandeln, den der Host-Rechner direkt ausführen kann. Dieser Prozess stellt sicher, dass .NET-Anwendungen nahtlos auf verschiedenen Plattformen ausgeführt werden können, von den wichtigsten mobilen Betriebssystemen bis hin zu Windows-Webservern.

Plattformübergreifendes Framework

.NET Core entwickelt sich zu einem plattformübergreifenden Framework, mit dem .NET-Anwendungen unter Linux, macOS und Windows ausgeführt werden können. Diese Anpassungsfähigkeit macht .NET zu einer attraktiven Wahl für Entwickler, die ein größeres Publikum auf verschiedenen Geräten und Plattformen erreichen wollen. Mit .NET Core können Anwendungen auf jedem unterstützten Betriebssystem entwickelt und bereitgestellt werden, was die Reichweite und Flexibilität der .NET-Softwareentwicklung erhöht, unterstützt durch die umfangreiche .NET Community.

Integrierte Entwicklungsumgebung (IDE)

Visual Studio ist die führende integrierte Entwicklungsumgebung (IDE) für die .NET-Entwicklung. Es bietet Entwicklern leistungsstarke Tools für das Schreiben von Code, das Debugging und die Bereitstellung von .NET-Anwendungen. Visual Studio unterstützt verschiedene Programmiersprachen und bietet eine breite Palette von Funktionen für die Erstellung von Web-, Desktop- und mobilen Anwendungen, was es zu einem unverzichtbaren Werkzeug für .NET-Entwickler macht.

Erstellen von Anwendungen mit .NET

Die Erstellung von Anwendungen auf der .NET-Plattform beinhaltet die Nutzung einer breiten Palette von Tools, Bibliotheken und Programmiersprachen, die das Framework bietet, wie z. B. Visual Basic, was sein umfassendes Ökosystem verdeutlicht. Diese Vielseitigkeit ermöglicht es Softwareentwicklern, verschiedene Arten von .NET Apps zu erstellen, von Web- und Desktop-Anwendungen bis hin zu Cloud-basierten und mobilen Lösungen.

Webentwicklung mit ASP.NET

ASP.NET, ein Hauptbestandteil des .NET-Frameworks, ist speziell für die Erstellung dynamischer Webseiten und Anwendungen konzipiert. Es ermöglicht Entwicklern die Erstellung reaktionsschneller und skalierbarer Webanwendungen, die große Mengen an Datenverkehr bewältigen können. ASP.NET Core, die Open-Source-Version von ASP.NET, bietet zusätzliche Funktionen für die Erstellung plattformübergreifender Webanwendungen und ermöglicht die Entwicklung und Bereitstellung von Webanwendungen unter Windows, Linux und macOS.

Entwicklung von Desktop-Anwendungen

.NET bietet zwei primäre Ansätze für die Erstellung von Desktop-Anwendungen: Windows Forms und Windows Presentation Foundation (WPF). Windows Forms bietet eine unkomplizierte Möglichkeit zur Erstellung von Desktop-Anwendungen mit einer umfangreichen grafischen Benutzeroberfläche, während WPF XAML verwendet (Extensible Application Markup Language) um die Entwicklung visuell ansprechender Benutzeroberflächen mit fortschrittlichen Grafiken und Animationen zu ermöglichen.

Entwicklung mobiler Anwendungen

Für die mobile Entwicklung erweitert .NET seine Reichweite auf die wichtigsten mobilen Betriebssysteme durch das Xamarin-Framework, das jetzt als .NET MAUI in .NET integriert ist (Multiplattform-App UI). Dieser Ansatz ermöglicht Entwicklern die Wiederverwendung von Code für iOS, Android und Windows und vereinfacht so die Erstellung mobiler Anwendungen, die eine native Leistung und Benutzerfreundlichkeit bieten.

Cloud und Microservices

.NET eignet sich auch gut für die Entwicklung von Anwendungen, die in der Cloud laufen. Dank der Unterstützung für Azure und andere Cloud-Plattformen können Entwickler skalierbare, verteilte Anwendungen erstellen, die die Vorteile von Cloud-Computing-Ressourcen nutzen. ASP.NET Core spielt eine wichtige Rolle bei der Entwicklung von Microservices und bietet leichtgewichtige, modulare und unabhängig einsetzbare Dienste, die in Cloud-Umgebungen skaliert werden können.

Maschinelles Lernen und KI

Das .NET-Ökosystem umfasst ML.NET, ein Framework für maschinelles Lernen, das es Entwicklern ermöglicht, benutzerdefinierte Modelle für maschinelles Lernen in ihre .NET-Anwendungen einzubinden. Diese Integration eröffnet Möglichkeiten für die Erstellung intelligenter Anwendungen, die in der Lage sind, prädiktive Analysen, die Verarbeitung natürlicher Sprache und vieles mehr durchzuführen und dabei die Leistungsfähigkeit der KI innerhalb des .NET-Frameworks zu nutzen.

Verbessern der .NET-Softwareentwicklung mit IronPDF

Innerhalb des dynamischen Ökosystems der .NET-Softwareentwicklung stellt die Möglichkeit, PDF-Dokumente direkt in Anwendungen zu erzeugen, zu bearbeiten und zu verwalten, einen erheblichen Vorteil dar. IronPDF, eine robuste Bibliothek für .NET-Entwickler, fügt sich nahtlos in diese Umgebung ein und bietet eine effiziente Möglichkeit zur Erstellung von PDFs aus .NET-Anwendungen, einschließlich solcher, die mit Windows Forms erstellt wurden.

Die Rolle von IronPDF in .NET-Anwendungen

IronPDF ist ein Beweis für die Flexibilität und Leistungsfähigkeit des .NET-Ökosystems und bietet Entwicklern eine intuitive API für pDF-Dokumente aus HTM generieren L, Bilder, Text und sogar ASP.NET-Webseiten. Diese Fähigkeit ist besonders nützlich in Szenarien, die eine dynamische Dokumentenerstellung erfordern, wie z. B. die Erstellung von Rechnungen, Berichten oder personalisierten Dokumenten in Desktop-Anwendungen.

Erstellung eines Windows-Formular-Rechnungsgenerators mit IronPDF

Eine Windows-Form-Anwendung zum Erstellen von Rechnungen ist ein Beispiel für die praktische Anwendung von .NET-Softwareentwicklung in Kombination mit IronPDF. Mit dieser Anwendung können Benutzer Details wie Kundeninformationen, Kaufartikel und Preise eingeben und dann mit einem einzigen Klick eine professionelle PDF-Rechnung erstellen.

Einrichten Ihres Windows Forms-Projekts und Entwerfen der Benutzeroberfläche

Beginnen Sie mit der Erstellung eines neuen Windows Forms-Projekts in Visual Studio. Dies ist die Grundlage, auf der Sie die Benutzeroberfläche für Ihren Rechnungsgenerator gestalten werden. Gestalten Sie Ihr Formular so, dass es die notwendigen Eingabefelder für Kunden- und Artikeldetails sowie eine Schaltfläche für die Erstellung der PDF-Datei enthält. Es ist unser Rechnungsgenerator UI:

Die Benutzeroberfläche der Windows Forms-Anwendung wurde sorgfältig entworfen, um Benutzerfreundlichkeit und Funktionalität zu gewährleisten. Das Hauptfenster mit dem Titel "Invoice Generator" ist in verschiedene Abschnitte unterteilt, um eine nahtlose Nutzung zu ermöglichen.

Abschnitt Kundeninformationen

Im oberen Bereich des Formulars befinden sich Felder für "Kundenname", "Kundenadresse", "Kunden-E-Mail" und "Kunden-Telefonnummer" In diesem Bereich werden die wichtigsten Kundendaten erfasst, die auf der erstellten Rechnung an prominenter Stelle erscheinen werden.

Hinzufügen von Rechnungspositionen

Direkt unter den Kundeninformationen befindet sich ein Bereich mit der Bezeichnung "Rechnungsposten hinzufügen" Hier können die Benutzer Details zu den einzelnen Artikeln eingeben, z. B. "Artikel-ID", "Beschreibung", "Menge" und "Stückpreis" Neben diesen Feldern befindet sich eine Schaltfläche "Artikel hinzufügen", mit der der eingegebene Artikel an die darunter liegende Rechnungsliste angehängt werden kann.

Liste der Rechnungspositionen

Der zentrale Teil des Formulars besteht aus dem Abschnitt "Rechnungsinformationen", in dem eine Tabelle angezeigt wird, in der die Eingaben nach und nach eingefügt werden. Die Tabellenspalten umfassen "Artikel-ID", "Beschreibung", "Menge", "Stückpreis" und "Gesamtpreis", wobei die letzte Spalte automatisch auf der Grundlage von Menge und Stückpreis berechnet wird. Eine Datumsauswahl mit dem Titel "Select Date" (Datum auswählen) ermöglicht dem Benutzer die Angabe des Rechnungsdatums, wodurch das Dokument noch spezifischer wird.

Vorgänge bei der Rechnungsstellung

Am unteren Rand des Formulars zeigt ein Etikett den "Gesamtbetrag" an, der dynamisch aktualisiert wird, wenn Artikel hinzugefügt oder entfernt werden. Auf diese Weise haben die Nutzer in Echtzeit einen Überblick über den Gesamtwert der Rechnung. Zusätzlich fordert eine Schaltfläche "Rechnung generieren" die Anwendung auf, die IronPDF-Bibliothek zu verwenden, um eine PDF-Version der Rechnung auf der Grundlage der eingegebenen Daten zu erstellen.

Diese Benutzeroberfläche ist nicht nur funktional, sondern auch intuitiv, so dass die Benutzer ohne große Lernkurve mit der Anwendung arbeiten können. Es ist so konzipiert, dass es alle notwendigen Informationen für die Rechnungserstellung enthält und einen klaren und einfachen Weg von der Dateneingabe bis zur PDF-Erstellung bietet.

Hinzufügen von IronPDF zu Ihrem Projekt

Nachdem Sie Ihr Projekt eingerichtet haben, müssen Sie als Nächstes IronPDF ins Spiel bringen. Dies geschieht über NuGet, den integrierten NuGet-Paketmanager von Visual Studio, mit dem Sie IronPDF mühelos zu Ihrem Projekt hinzufügen können. Schreiben Sie den folgenden Befehl und führen Sie ihn aus:

Install-Package IronPdf

Mit diesem Befehl wird IronPDF installiert und steht für die Verwendung in unserem Projekt zur Verfügung.

Implementierung der Rechnungserstellung

Der Kern der Windows Forms-Anwendung ist die Fähigkeit, Benutzereingaben zu verarbeiten, die Daten in einem strukturierten Format zu organisieren und ein greifbares Dokument - in diesem Fall eine Rechnung im PDF-Format - zu erstellen. Die Funktionalität basiert auf einer Reihe von methodischen Schritten innerhalb der Codebasis der Anwendung.

Einrichten der Datenrasteransicht

Bei der Initialisierung des Formulars ruft die Anwendung SetupDataGridViewColumns auf, um die Datenstruktur einzurichten, in der die Rechnungsposten angezeigt werden sollen. Es werden Spalten für Artikel-ID, Beschreibung, Menge, Einzelpreis und Gesamtpreis erstellt, wobei der Gesamtpreis ein schreibgeschütztes Feld ist, da er automatisch berechnet wird. Darüber hinaus wurde eine Spalte mit Schaltflächen zum Löschen von Elementen hinzugefügt, die dem Benutzer eine bessere Kontrolle über den Rechnungsinhalt ermöglicht.

private void SetupDataGridViewColumns()
{
    invoiceDataGridView.Columns.Clear(); // Clear existing columns if any
    // Now add the rest of your columns
    invoiceDataGridView.Columns.Add("itemIdColumn", "Item ID");
    invoiceDataGridView.Columns.Add("descriptionColumn", "Description");
    invoiceDataGridView.Columns.Add("quantityColumn", "Quantity");
    invoiceDataGridView.Columns.Add("unitPriceColumn", "Unit Price");
    invoiceDataGridView.Columns.Add("totalPriceColumn", "Total Price");
    // Set the Total Price column to read-only as it will be calculated automatically
    invoiceDataGridView.Columns ["totalPriceColumn"].ReadOnly = true;
    // Add a button column for delete action
    DataGridViewButtonColumn deleteButtonColumn = new DataGridViewButtonColumn();
    deleteButtonColumn.HeaderText = "";
    deleteButtonColumn.Name = "deleteButtonColumn";
    deleteButtonColumn.Text = "Delete";
    deleteButtonColumn.UseColumnTextForButtonValue = true; // This will set the button text to "Delete"
    // Add the delete button column to the DataGridView
    invoiceDataGridView.Columns.Add(deleteButtonColumn);
}
public Form1()
{
    InitializeComponent();
    SetupDataGridViewColumns();
    // Wire up the CellClick event to a handler
    invoiceDataGridView.CellClick += invoiceDataGridView_CellClick;
}
private void invoiceDataGridView_CellClick(object sender, DataGridViewCellEventArgs e)
{
    // If the clicked cell is part of the button column and not the header row
    if (e.ColumnIndex == invoiceDataGridView.Columns ["deleteButtonColumn"].Index && e.RowIndex >= 0)
    {
        // Confirm delete operation
        if (MessageBox.Show("Are you sure you want to delete this item?", "Confirm Delete", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
        {
            // Remove the row from the DataGridView
            invoiceDataGridView.Rows.RemoveAt(e.RowIndex);
        }
    }
}

private void SetupDataGridViewColumns()
{
    invoiceDataGridView.Columns.Clear(); // Clear existing columns if any
    // Now add the rest of your columns
    invoiceDataGridView.Columns.Add("itemIdColumn", "Item ID");
    invoiceDataGridView.Columns.Add("descriptionColumn", "Description");
    invoiceDataGridView.Columns.Add("quantityColumn", "Quantity");
    invoiceDataGridView.Columns.Add("unitPriceColumn", "Unit Price");
    invoiceDataGridView.Columns.Add("totalPriceColumn", "Total Price");
    // Set the Total Price column to read-only as it will be calculated automatically
    invoiceDataGridView.Columns ["totalPriceColumn"].ReadOnly = true;
    // Add a button column for delete action
    DataGridViewButtonColumn deleteButtonColumn = new DataGridViewButtonColumn();
    deleteButtonColumn.HeaderText = "";
    deleteButtonColumn.Name = "deleteButtonColumn";
    deleteButtonColumn.Text = "Delete";
    deleteButtonColumn.UseColumnTextForButtonValue = true; // This will set the button text to "Delete"
    // Add the delete button column to the DataGridView
    invoiceDataGridView.Columns.Add(deleteButtonColumn);
}
public Form1()
{
    InitializeComponent();
    SetupDataGridViewColumns();
    // Wire up the CellClick event to a handler
    invoiceDataGridView.CellClick += invoiceDataGridView_CellClick;
}
private void invoiceDataGridView_CellClick(object sender, DataGridViewCellEventArgs e)
{
    // If the clicked cell is part of the button column and not the header row
    if (e.ColumnIndex == invoiceDataGridView.Columns ["deleteButtonColumn"].Index && e.RowIndex >= 0)
    {
        // Confirm delete operation
        if (MessageBox.Show("Are you sure you want to delete this item?", "Confirm Delete", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
        {
            // Remove the row from the DataGridView
            invoiceDataGridView.Rows.RemoveAt(e.RowIndex);
        }
    }
}

Private Sub SetupDataGridViewColumns()
	invoiceDataGridView.Columns.Clear() ' Clear existing columns if any
	' Now add the rest of your columns
	invoiceDataGridView.Columns.Add("itemIdColumn", "Item ID")
	invoiceDataGridView.Columns.Add("descriptionColumn", "Description")
	invoiceDataGridView.Columns.Add("quantityColumn", "Quantity")
	invoiceDataGridView.Columns.Add("unitPriceColumn", "Unit Price")
	invoiceDataGridView.Columns.Add("totalPriceColumn", "Total Price")
	' Set the Total Price column to read-only as it will be calculated automatically
	invoiceDataGridView.Columns ("totalPriceColumn").ReadOnly = True
	' Add a button column for delete action
	Dim deleteButtonColumn As New DataGridViewButtonColumn()
	deleteButtonColumn.HeaderText = ""
	deleteButtonColumn.Name = "deleteButtonColumn"
	deleteButtonColumn.Text = "Delete"
	deleteButtonColumn.UseColumnTextForButtonValue = True ' This will set the button text to "Delete"
	' Add the delete button column to the DataGridView
	invoiceDataGridView.Columns.Add(deleteButtonColumn)
End Sub
'INSTANT VB WARNING: The following constructor is declared outside of its associated class:
'ORIGINAL LINE: public Form1()
Public Sub New()
	InitializeComponent()
	SetupDataGridViewColumns()
	' Wire up the CellClick event to a handler
	AddHandler invoiceDataGridView.CellClick, AddressOf invoiceDataGridView_CellClick
End Sub
Private Sub invoiceDataGridView_CellClick(ByVal sender As Object, ByVal e As DataGridViewCellEventArgs)
	' If the clicked cell is part of the button column and not the header row
	If e.ColumnIndex = invoiceDataGridView.Columns ("deleteButtonColumn").Index AndAlso e.RowIndex >= 0 Then
		' Confirm delete operation
		If MessageBox.Show("Are you sure you want to delete this item?", "Confirm Delete", MessageBoxButtons.YesNo, MessageBoxIcon.Question) = DialogResult.Yes Then
			' Remove the row from the DataGridView
			invoiceDataGridView.Rows.RemoveAt(e.RowIndex)
		End If
	End If
End Sub

Hinzufügen von Rechnungspositionen

Wenn ein Benutzer Details für einen Artikel eingibt und auf "Artikel hinzufügen" klickt, sammelt das Ereignis btnAddItem_Click die Eingabedaten, validiert sie und ruft dann AddItemToInvoice auf. Diese Methode fügt dem DataGridView eine neue Zeile mit den eingegebenen Werten hinzu, berechnet den Gesamtpreis für den Artikel und aktualisiert den am unteren Rand des Formulars angezeigten Rechnungsgesamtbetrag.

public void AddItemToInvoice(string itemId, string description, int quantity, decimal unitPrice)
{
    decimal totalPrice = quantity * unitPrice;
    invoiceDataGridView.Rows.Add(itemId, description, quantity, unitPrice, totalPrice);
}
 private void CalculateTotalAmount()
 {
     decimal totalAmount = 0m;
     foreach (DataGridViewRow row in invoiceDataGridView.Rows)
     {
         totalAmount += Convert.ToDecimal(row.Cells ["totalPriceColumn"].Value ?? 0);
     }
     lblTotalAmount.Text = $"{totalAmount:C2}"; // Assuming 'lblTotalAmount' is the name of your Label control
 }
private void btnAddItem_Click(object sender, EventArgs e)
{
    // Assuming your text boxes and numeric up/down controls have the following names:
    // txtItemID, txtDescription, txtUnitPrice, and numericUpDownQuantity
    // Collect data from input controls
    string itemId = txtItemID.Text;
    string description = txtDescription.Text;
    int quantity = (int)numericUpDownQuantity.Value;
    decimal unitPrice;
    // Validate the collected data
    // Check if the unit price is a valid decimal
    bool isUnitPriceValid = decimal.TryParse(txtUnitPrice.Text, out unitPrice);
    // Additional validation can be implemented as needed
    if (string.IsNullOrEmpty(itemId) 
 string.IsNullOrEmpty(description) 
 quantity <= 0 
 !isUnitPriceValid 
 unitPrice <= 0)
    {
        MessageBox.Show("Please enter valid data for all fields.", "Invalid Data", MessageBoxButtons.OK, MessageBoxIcon.Warning);
        return;
    }
    // Add data to the DataGridView
    AddItemToInvoice(itemId, description, quantity, unitPrice);
    // Optionally, clear the input fields after adding the item to the grid
    txtItemID.Clear();
    txtDescription.Clear();
    txtUnitPrice.Clear();
    numericUpDownQuantity.Value = 0; // or numericUpDownQuantity.Minimum if 0 is not allowed
    CalculateTotalAmount();
}

public void AddItemToInvoice(string itemId, string description, int quantity, decimal unitPrice)
{
    decimal totalPrice = quantity * unitPrice;
    invoiceDataGridView.Rows.Add(itemId, description, quantity, unitPrice, totalPrice);
}
 private void CalculateTotalAmount()
 {
     decimal totalAmount = 0m;
     foreach (DataGridViewRow row in invoiceDataGridView.Rows)
     {
         totalAmount += Convert.ToDecimal(row.Cells ["totalPriceColumn"].Value ?? 0);
     }
     lblTotalAmount.Text = $"{totalAmount:C2}"; // Assuming 'lblTotalAmount' is the name of your Label control
 }
private void btnAddItem_Click(object sender, EventArgs e)
{
    // Assuming your text boxes and numeric up/down controls have the following names:
    // txtItemID, txtDescription, txtUnitPrice, and numericUpDownQuantity
    // Collect data from input controls
    string itemId = txtItemID.Text;
    string description = txtDescription.Text;
    int quantity = (int)numericUpDownQuantity.Value;
    decimal unitPrice;
    // Validate the collected data
    // Check if the unit price is a valid decimal
    bool isUnitPriceValid = decimal.TryParse(txtUnitPrice.Text, out unitPrice);
    // Additional validation can be implemented as needed
    if (string.IsNullOrEmpty(itemId) 
 string.IsNullOrEmpty(description) 
 quantity <= 0 
 !isUnitPriceValid 
 unitPrice <= 0)
    {
        MessageBox.Show("Please enter valid data for all fields.", "Invalid Data", MessageBoxButtons.OK, MessageBoxIcon.Warning);
        return;
    }
    // Add data to the DataGridView
    AddItemToInvoice(itemId, description, quantity, unitPrice);
    // Optionally, clear the input fields after adding the item to the grid
    txtItemID.Clear();
    txtDescription.Clear();
    txtUnitPrice.Clear();
    numericUpDownQuantity.Value = 0; // or numericUpDownQuantity.Minimum if 0 is not allowed
    CalculateTotalAmount();
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Generierung der PDF-Rechnung

Wenn Sie auf "Rechnung erstellen" klicken, führt die Anwendung den Ereignishandler btnInvoice_Click aus, der mithilfe eines StringBuilders eine HTML-Zeichenkette erstellt. Diese Zeichenfolge enthält die Kundendaten und eine gestylte HTML-Tabelle, die mit den Rechnungsposten aus dem DataGridView gefüllt ist. Der Renderer von IronPDF wandelt dann dieses HTML in ein PDF-Dokument um, das unter einem bestimmten Pfad gespeichert wird. Die Anwendung bestätigt die erfolgreiche Erstellung der Rechnung mit einer Meldung an den Benutzer.

private void btnInvoice_Click(object sender, EventArgs e)
        {
            IronPdf.License.LicenseKey = "License-Key";
            // Collect customer information
            var customerName = txtName.Text; // Adjusted to your actual TextBox names
            var customerEmail = txtEmail.Text;
            var customerAddress = txtAddress.Text;
            var customerPhone = txtPhone.Text;
            // Start building the HTML content for the invoice
            var htmlStringBuilder = new StringBuilder();
            htmlStringBuilder.Append("<html>");
            htmlStringBuilder.Append("<head>");
            htmlStringBuilder.Append("<title>Invoice</title>");
            // Add some basic CSS styles for the invoice
            htmlStringBuilder.Append(@"
    <style>
        body {
            font-family: 'Arial', sans-serif;
        }
        h1 {
            color: #333;
            text-align: center;
        }
        table {
            width: 100%;
            border-collapse: collapse;
            margin-top: 20px;
        }
        th, td {
            border: 1px solid #999;
            padding: 8px;
            text-align: left;
        }
        th {
            background-color: #f2f2f2;
        }
        tr:nth-child(even) {
            background-color: #f9f9f9;
        }
        h2 {
            text-align: right;
            margin-top: 20px;
        }
.customer-info {
        font-family: 'Helvetica', 'Arial', sans-serif;
        line-height: 1.6;
        margin-bottom: 20px;
    }
    .customer-info p {
        margin: 0 0 10px 0;
        color: #333;
    }
    .customer-info label {
        font-weight: bold;
    }
    </style>");
            // You can add style tags here for styling your PDF content
            htmlStringBuilder.Append("</head>");
            htmlStringBuilder.Append("<body>");
            htmlStringBuilder.Append("<h1>Invoice</h1>");
            htmlStringBuilder.Append("<div class='customer-info'>");
            htmlStringBuilder.Append($"<p><strong>Customer Name:</strong> {customerName}</p>");
            htmlStringBuilder.Append($"<p><strong>Customer Email:</strong> {customerEmail}</p>");
            htmlStringBuilder.Append($"<p><strong>Customer Address:</strong> {customerAddress}</p>");
            htmlStringBuilder.Append($"<p><strong>Customer Phone:</strong> {customerPhone}</p>");
            htmlStringBuilder.Append("</div>");
            // Add the invoice items
            htmlStringBuilder.Append("<table border='1'><tr><th>Item ID</th><th>Description</th><th>Quantity</th><th>Unit Price</th><th>Total Price</th></tr>");
            foreach (DataGridViewRow row in invoiceDataGridView.Rows)
            {
                if (row.IsNewRow) continue; // Skip the new row placeholder
                htmlStringBuilder.Append("<tr>");
                htmlStringBuilder.Append($"<td>{row.Cells ["itemIdColumn"].Value}</td>");
                htmlStringBuilder.Append($"<td>{row.Cells ["descriptionColumn"].Value}</td>");
                htmlStringBuilder.Append($"<td>{row.Cells ["quantityColumn"].Value}</td>");
                htmlStringBuilder.Append($"<td>{row.Cells ["unitPriceColumn"].Value:C2}</td>");
                htmlStringBuilder.Append($"<td>{row.Cells ["totalPriceColumn"].Value:C2}</td>");
                htmlStringBuilder.Append("</tr>");
            }
            htmlStringBuilder.Append("</table>");
            // Add the total amount
            htmlStringBuilder.Append($"<h2>Total Amount: {lblTotalAmount.Text}</h2>");
            // Close the HTML string
            htmlStringBuilder.Append("</body></html>");
            // Use IronPDF to convert the HTML string to a PDF document
            var renderer = new IronPdf.ChromePdfRenderer();
            var pdfDocument = renderer.RenderHtmlAsPdf(htmlStringBuilder.ToString());
            // Save the PDF to a file
            string savePath = Path.Combine($"F:\\Invoice_{DateTime.Now:yyyyMMddHHmmss}.pdf"); // to avoid file name conflicts and save to desktop
            pdfDocument.SaveAs(savePath);
            // Show a success dialog
            MessageBox.Show("The invoice has been successfully saved to your desktop.", "Invoice Saved", MessageBoxButtons.OK, MessageBoxIcon.Information);
        }

private void btnInvoice_Click(object sender, EventArgs e)
        {
            IronPdf.License.LicenseKey = "License-Key";
            // Collect customer information
            var customerName = txtName.Text; // Adjusted to your actual TextBox names
            var customerEmail = txtEmail.Text;
            var customerAddress = txtAddress.Text;
            var customerPhone = txtPhone.Text;
            // Start building the HTML content for the invoice
            var htmlStringBuilder = new StringBuilder();
            htmlStringBuilder.Append("<html>");
            htmlStringBuilder.Append("<head>");
            htmlStringBuilder.Append("<title>Invoice</title>");
            // Add some basic CSS styles for the invoice
            htmlStringBuilder.Append(@"
    <style>
        body {
            font-family: 'Arial', sans-serif;
        }
        h1 {
            color: #333;
            text-align: center;
        }
        table {
            width: 100%;
            border-collapse: collapse;
            margin-top: 20px;
        }
        th, td {
            border: 1px solid #999;
            padding: 8px;
            text-align: left;
        }
        th {
            background-color: #f2f2f2;
        }
        tr:nth-child(even) {
            background-color: #f9f9f9;
        }
        h2 {
            text-align: right;
            margin-top: 20px;
        }
.customer-info {
        font-family: 'Helvetica', 'Arial', sans-serif;
        line-height: 1.6;
        margin-bottom: 20px;
    }
    .customer-info p {
        margin: 0 0 10px 0;
        color: #333;
    }
    .customer-info label {
        font-weight: bold;
    }
    </style>");
            // You can add style tags here for styling your PDF content
            htmlStringBuilder.Append("</head>");
            htmlStringBuilder.Append("<body>");
            htmlStringBuilder.Append("<h1>Invoice</h1>");
            htmlStringBuilder.Append("<div class='customer-info'>");
            htmlStringBuilder.Append($"<p><strong>Customer Name:</strong> {customerName}</p>");
            htmlStringBuilder.Append($"<p><strong>Customer Email:</strong> {customerEmail}</p>");
            htmlStringBuilder.Append($"<p><strong>Customer Address:</strong> {customerAddress}</p>");
            htmlStringBuilder.Append($"<p><strong>Customer Phone:</strong> {customerPhone}</p>");
            htmlStringBuilder.Append("</div>");
            // Add the invoice items
            htmlStringBuilder.Append("<table border='1'><tr><th>Item ID</th><th>Description</th><th>Quantity</th><th>Unit Price</th><th>Total Price</th></tr>");
            foreach (DataGridViewRow row in invoiceDataGridView.Rows)
            {
                if (row.IsNewRow) continue; // Skip the new row placeholder
                htmlStringBuilder.Append("<tr>");
                htmlStringBuilder.Append($"<td>{row.Cells ["itemIdColumn"].Value}</td>");
                htmlStringBuilder.Append($"<td>{row.Cells ["descriptionColumn"].Value}</td>");
                htmlStringBuilder.Append($"<td>{row.Cells ["quantityColumn"].Value}</td>");
                htmlStringBuilder.Append($"<td>{row.Cells ["unitPriceColumn"].Value:C2}</td>");
                htmlStringBuilder.Append($"<td>{row.Cells ["totalPriceColumn"].Value:C2}</td>");
                htmlStringBuilder.Append("</tr>");
            }
            htmlStringBuilder.Append("</table>");
            // Add the total amount
            htmlStringBuilder.Append($"<h2>Total Amount: {lblTotalAmount.Text}</h2>");
            // Close the HTML string
            htmlStringBuilder.Append("</body></html>");
            // Use IronPDF to convert the HTML string to a PDF document
            var renderer = new IronPdf.ChromePdfRenderer();
            var pdfDocument = renderer.RenderHtmlAsPdf(htmlStringBuilder.ToString());
            // Save the PDF to a file
            string savePath = Path.Combine($"F:\\Invoice_{DateTime.Now:yyyyMMddHHmmss}.pdf"); // to avoid file name conflicts and save to desktop
            pdfDocument.SaveAs(savePath);
            // Show a success dialog
            MessageBox.Show("The invoice has been successfully saved to your desktop.", "Invoice Saved", MessageBoxButtons.OK, MessageBoxIcon.Information);
        }

Private Sub btnInvoice_Click(ByVal sender As Object, ByVal e As EventArgs)
			IronPdf.License.LicenseKey = "License-Key"
			' Collect customer information
			Dim customerName = txtName.Text ' Adjusted to your actual TextBox names
			Dim customerEmail = txtEmail.Text
			Dim customerAddress = txtAddress.Text
			Dim customerPhone = txtPhone.Text
			' Start building the HTML content for the invoice
			Dim htmlStringBuilder = New StringBuilder()
			htmlStringBuilder.Append("<html>")
			htmlStringBuilder.Append("<head>")
			htmlStringBuilder.Append("<title>Invoice</title>")
			' Add some basic CSS styles for the invoice
			htmlStringBuilder.Append("
    <style>
        body {
            font-family: 'Arial', sans-serif;
        }
        h1 {
            color: #333;
            text-align: center;
        }
        table {
            width: 100%;
            border-collapse: collapse;
            margin-top: 20px;
        }
        th, td {
            border: 1px solid #999;
            padding: 8px;
            text-align: left;
        }
        th {
            background-color: #f2f2f2;
        }
        tr:nth-child(even) {
            background-color: #f9f9f9;
        }
        h2 {
            text-align: right;
            margin-top: 20px;
        }
.customer-info {
        font-family: 'Helvetica', 'Arial', sans-serif;
        line-height: 1.6;
        margin-bottom: 20px;
    }
    .customer-info p {
        margin: 0 0 10px 0;
        color: #333;
    }
    .customer-info label {
        font-weight: bold;
    }
    </style>")
			' You can add style tags here for styling your PDF content
			htmlStringBuilder.Append("</head>")
			htmlStringBuilder.Append("<body>")
			htmlStringBuilder.Append("<h1>Invoice</h1>")
			htmlStringBuilder.Append("<div class='customer-info'>")
			htmlStringBuilder.Append($"<p><strong>Customer Name:</strong> {customerName}</p>")
			htmlStringBuilder.Append($"<p><strong>Customer Email:</strong> {customerEmail}</p>")
			htmlStringBuilder.Append($"<p><strong>Customer Address:</strong> {customerAddress}</p>")
			htmlStringBuilder.Append($"<p><strong>Customer Phone:</strong> {customerPhone}</p>")
			htmlStringBuilder.Append("</div>")
			' Add the invoice items
			htmlStringBuilder.Append("<table border='1'><tr><th>Item ID</th><th>Description</th><th>Quantity</th><th>Unit Price</th><th>Total Price</th></tr>")
			For Each row As DataGridViewRow In invoiceDataGridView.Rows
				If row.IsNewRow Then
					Continue For ' Skip the new row placeholder
				End If
				htmlStringBuilder.Append("<tr>")
				htmlStringBuilder.Append($"<td>{row.Cells ("itemIdColumn").Value}</td>")
				htmlStringBuilder.Append($"<td>{row.Cells ("descriptionColumn").Value}</td>")
				htmlStringBuilder.Append($"<td>{row.Cells ("quantityColumn").Value}</td>")
				htmlStringBuilder.Append($"<td>{row.Cells ("unitPriceColumn").Value:C2}</td>")
				htmlStringBuilder.Append($"<td>{row.Cells ("totalPriceColumn").Value:C2}</td>")
				htmlStringBuilder.Append("</tr>")
			Next row
			htmlStringBuilder.Append("</table>")
			' Add the total amount
			htmlStringBuilder.Append($"<h2>Total Amount: {lblTotalAmount.Text}</h2>")
			' Close the HTML string
			htmlStringBuilder.Append("</body></html>")
			' Use IronPDF to convert the HTML string to a PDF document
			Dim renderer = New IronPdf.ChromePdfRenderer()
			Dim pdfDocument = renderer.RenderHtmlAsPdf(htmlStringBuilder.ToString())
			' Save the PDF to a file
			Dim savePath As String = Path.Combine($"F:\Invoice_{DateTime.Now:yyyyMMddHHmmss}.pdf") ' to avoid file name conflicts and save to desktop
			pdfDocument.SaveAs(savePath)
			' Show a success dialog
			MessageBox.Show("The invoice has been successfully saved to your desktop.", "Invoice Saved", MessageBoxButtons.OK, MessageBoxIcon.Information)
End Sub

Ausführen der Anwendung und Erstellen von Rechnungen

Sobald die Windows Forms-Anwendung entwickelt und die IronPDF-Bibliothek integriert ist, ist die Ausführung der Anwendung und die Erstellung von PDF-Rechnungen ein unkomplizierter Prozess. Der Benutzer interagiert mit der Benutzeroberfläche der Anwendung, um Daten einzugeben und die gewünschte Ausgabe zu erzeugen. In der Regel läuft der Prozess folgendermaßen ab:

Starten der Anwendung

Starten Sie die Anwendung, indem Sie sie in Visual Studio ausführen oder indem Sie die kompilierte ausführbare Datei ausführen (.exe) direkt aus der Windows-Umgebung. Die Formularanzeige der Anwendung, bereit für die Benutzerinteraktion.

Eingabe von Rechnungsdaten

Geben Sie die Kundendaten in die dafür vorgesehenen Textfelder am oberen Rand des Formulars ein, einschließlich Name, Adresse, E-Mail-Adresse und Telefonnummer des Kunden. Fügen Sie Rechnungspositionen hinzu, indem Sie die Felder "Artikel-ID", "Beschreibung", "Menge" und "Stückpreis" ausfüllen, die sich im Abschnitt "Rechnungsposition hinzufügen" des Formulars befinden.

Klicken Sie auf "Artikel hinzufügen ", um den Artikel in die Rechnungsliste aufzunehmen. Das DataGridView wird aktualisiert und zeigt den neuen Artikel, seine Details und den berechneten Gesamtpreis an. Wiederholen Sie den Vorgang, um alle erforderlichen Artikel zur Rechnung hinzuzufügen. Die Beschriftung "Gesamtbetrag" wird dynamisch aktualisiert, um die kumulierte Summe der aufgelisteten Artikel anzuzeigen.

Generierung der PDF-Rechnung

Klicken Sie auf "Rechnung generieren ", sobald alle Artikel hinzugefügt und die Kundeninformationen vollständig sind. Die Anwendung kompiliert die Daten in ein HTML-Format, das mit CSS gestylt wird. IronPDF übernimmt die Umwandlung des HTML-Strings in ein PDF-Dokument. Sie wird mit der Chrome-Engine gerendert, was eine hohe Wiedergabetreue nach modernen Webstandards gewährleistet.

Anzeigen der erstellten Rechnung

Nach der PDF-Erzeugung speichert die Anwendung die PDF-Datei an einem bestimmten Ort, häufig im gleichen Verzeichnis wie die Anwendung oder in einem benutzerdefinierten Pfad. Es erscheint eine Erfolgsmeldung, die den Benutzer darüber informiert, dass die PDF-Rechnung erfolgreich gespeichert wurde. Die Benutzer können dann zu dem gespeicherten Ort navigieren, um die Rechnung anzuzeigen oder zu verteilen.

Ausgabe PDF

Die Ausgabe-PDF zeigt oben die Daten des Kunden an, gefolgt von einer detaillierten Tabelle der gekauften Artikel, einschließlich Beschreibungen, Mengen und Preisen. Der Gesamtbetrag der Rechnung wird am Ende des Dokuments aufgeführt, so dass der vom Kunden zu zahlende Betrag klar ersichtlich ist. Die PDF-Datei ist sauber und professionell gestaltet, wobei die im Code definierten CSS verwendet werden, um sicherzustellen, dass die Rechnung nicht nur funktional, sondern auch ästhetisch ansprechend ist.

Umwandlung des Windows Forms-Projekts in eine ausführbare Datei

Nachdem Sie Ihre Windows Forms-Anwendung gründlich getestet und sichergestellt haben, dass alle Funktionen wie Dateneingabe, PDF-Generierung und Ausgabe einwandfrei funktionieren, besteht die nächste Phase darin, Ihr Projekt in eine ausführbare Datei zu packen (.exe) datei. Dieser Konvertierungsprozess wird innerhalb des .NET-Frameworks gestrafft, so dass Ihre Anwendung für die Installation und Verwendung auf Windows-Rechnern bereit ist.

Im Folgenden wird die Erstellung der ausführbaren Datei Schritt für Schritt erläutert:

1. Build the Application: Gehen Sie zum Menü 'Build' und wählen Sie 'Build Solution' Dies kompiliert den Code in Baugruppen und führt die notwendigen Optimierungen durch.

   

2. Locate the Executable: Sobald der Build abgeschlossen ist, navigieren Sie zum Ordner 'bin\Debug\net8.0' im Verzeichnis Ihres Projekts. Hier finden Sie die .exe-Datei zusammen mit allen anderen Abhängigkeiten, die für die Ausführung Ihrer Anwendung erforderlich sind.

   

3. Testen der ausführbaren Datei: Es empfiehlt sich, die .exe-Datei auf einem anderen Rechner auszuführen, um sicherzustellen, dass sie außerhalb Ihrer Entwicklungsumgebung korrekt funktioniert.

4. Vorbereitung für die Verteilung: Für die Verteilung können Sie die .exe-Datei direkt weitergeben, wenn keine zusätzlichen Abhängigkeiten erforderlich sind. Für eine professionellere Herangehensweise sollten Sie jedoch in Erwägung ziehen, ein Installationsprogramm mithilfe eines Installationsprojekts in Visual Studio oder eines Installationspakets eines Drittanbieters wie Inno Setup oder WiX Toolset zu erstellen. Ein Installationsprogramm kann den Installationsvorgang verwalten, Verknüpfungen erstellen und andere komplexe Vorgänge, wie die Registrierung in der Windows-Registrierung, übernehmen.

   Wenn Sie diese Schritte befolgen, wird Ihre Windows Forms-Anwendung in eine einzige ausführbare Datei kondensiert, die dann gemeinsam genutzt werden kann. Diese Konvertierung stellt den Höhepunkt des Entwicklungsprozesses dar und führt von einem Projekt auf Ihrem Entwicklungsrechner zu einer einsatzfähigen Software, die effizient verteilt und in einer Vielzahl von Windows-Umgebungen installiert werden kann.

Schlussfolgerung

Zusammenfassend lässt sich sagen, dass die Entwicklung einer Windows Forms-Anwendung zur Erstellung von PDF-Rechnungen mit IronPDF und dem .NET-Framework ein Beispiel für die praktische Anwendung von Softwareentwicklungsprinzipien ist. Dieses Projekt veranschaulicht nicht nur die Vielseitigkeit und Leistungsfähigkeit des .NET-Ökosystems, sondern zeigt auch, wie Entwickler Bibliotheken von Drittanbietern wie IronPDF integrieren können, um die Funktionalität zu erweitern und spezifische Geschäftsanforderungen zu erfüllen.

Anhand der beschriebenen Schritte - von der Einrichtung der Benutzeroberfläche über die Implementierung der PDF-Generierung bis hin zur Verpackung der Anwendung in eine ausführbare Datei - können Entwickler eine funktionale, benutzerfreundliche Anwendung erstellen. Dieser Prozess verdeutlicht, wie wichtig es ist, robuste Programmier-Frameworks mit innovativen Bibliotheken zu kombinieren, um reale Probleme zu lösen und letztendlich ein effektives und effizientes Produkt zu liefern.

IronPDF stellt großzügig eine kostenloser Test für Entwickler, um die Funktionen zu erkunden und festzustellen, wie sie am besten auf ihre Bedürfnisse zugeschnitten sind. Sobald Sie sich von den Vorteilen überzeugt haben und bereit sind, IronPDF in Ihre Produktionsumgebung zu integrieren, beginnen die Lizenzen bei $749.