Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. Développement de logiciels .NET
.NET AIDE

Développement de logiciels .NET (Comment ça fonctionne pour les développeurs)

Curtis Chau
Curtis Chau
Mis à jour:

Le développement de logiciels avec .NET Framework représente un framework puissant et polyvalent soutenu par Microsoft qui permet aux développeurs .NET de créer des applications robustes et de haute qualité couvrant diverses plates-formes, systèmes d'exploitation et appareils. Ce framework de développement logiciel est conçu pour être complet, fournissant des outils, des bibliothèques et des API que les développeurs peuvent utiliser pour créer des applications web, de bureau et mobiles efficacement sur la plateforme .NET.

Avec le support de plusieurs langages de programmation, y compris C#, Visual Basic et F#, le développement .NET étend sa flexibilité aux développeurs, garantissant qu'ils peuvent travailler dans leur langage préféré tout en bénéficiant des riches fonctionnalités de l'écosystème .NET Core. Dans ce tutoriel, nous verrons comment IronPDF améliore le développement .NET pour résoudre des problèmes du monde réel.

Comprendre l'écosystème du développement logiciel .NET

L'écosystème .NET, une mise en œuvre clé de .NET, est une plateforme vaste et englobante qui comprend divers composants et technologies conçus pour faciliter le développement d'applications sur différents systèmes d'exploitation. Au cœur, le .NET Framework et .NET Core servent de moteurs principaux pour exécuter des applications .NET, fournissant un common language runtime (CLR) qui gère l'exécution du code et offre des services tels que la gestion de la mémoire, la sécurité du type, la gestion des exceptions, etc.

Le Common Language Runtime (CLR)

Le CLR est un élément crucial de l'architecture .NET, permettant l'exécution du code .NET sur différents systèmes d'exploitation. Il compile le Common Intermediate Language (CIL) en code machine natif que la machine hôte peut exécuter directement. Ce processus assure que les applications .NET peuvent fonctionner harmonieusement sur diverses plateformes, des principaux systèmes d'exploitation mobiles aux serveurs web Windows.

Framework multiplateforme

.NET Core apparaît comme un framework multiplateforme, permettant aux applications .NET de fonctionner sur Linux, macOS et Windows. Cette adaptabilité fait de .NET un choix attrayant pour les développeurs cherchant à atteindre un public plus large sur différents appareils et plateformes. Avec .NET Core, les applications peuvent être développées et déployées sur n'importe quel système d'exploitation pris en charge, augmentant la portée et la flexibilité du développement logiciel .NET, renforcées par l'extensive communauté .NET.

Environnement de développement intégré (IDE)

Visual Studio se distingue comme l'environnement de développement intégré (IDE) de premier choix pour le développement .NET. Il fournit aux développeurs des outils puissants pour l'écriture de code, le débogage et le déploiement d'applications .NET. Visual Studio prend en charge divers langages de programmation et offre une large gamme de fonctionnalités pour créer des applications web, de bureau et mobiles, en faisant un outil indispensable pour les développeurs .NET.

Créer des applications avec .NET

Créer des applications sur la plateforme .NET implique de s'appuyer sur un large éventail d'outils, de bibliothèques et de langages de programmation qu'offre le framework, tels que Visual Basic, mettant en valeur son écosystème complet. Cette polyvalence permet aux développeurs de créer divers types d'applications .NET, des applications web et de bureau aux solutions basées sur le cloud et mobiles.

Développement web avec ASP.NET

ASP.NET, une partie clé du framework .NET, est spécialement conçu pour la création de pages web dynamiques et d'applications. Il permet aux développeurs de créer des applications web réactives et évolutives pouvant gérer de grandes quantités de trafic. ASP.NET Core, la version open-source d'ASP.NET, apporte des fonctionnalités supplémentaires pour créer des applications web multiplateformes, permettant de développer et de déployer des applications web sur Windows, Linux et macOS.

Développement d'applications de bureau

.NET propose deux approches principales pour créer des applications de bureau : Windows Forms et Windows Presentation Foundation (WPF). Windows Forms offre une manière simple de créer des applications de bureau avec une interface utilisateur graphique riche, tandis que WPF utilise XAML (Extensible Application Markup Language) pour permettre le développement d'interfaces utilisateur visuellement attrayantes avec des graphiques et des animations avancées.

Développement d'applications mobiles

Pour le développement mobile, .NET étend sa portée aux principaux systèmes d'exploitation mobiles grâce au framework Xamarin, maintenant intégré dans .NET en tant que .NET MAUI (Multi-platform App UI). Cette approche permet aux développeurs de réutiliser du code sur iOS, Android et Windows, simplifiant le processus de création d'applications mobiles offrant des performances et une expérience utilisateur natives.

Cloud et microservices

.NET est également bien adapté pour développer des applications qui s'exécutent dans le cloud. Avec le support d'Azure et d'autres plateformes cloud, les développeurs peuvent créer des applications distribuées et évolutives qui tirent parti des ressources de calcul en cloud. ASP.NET Core joue un rôle significatif dans le développement de microservices, offrant des services légers, modulaires et déployables indépendamment qui peuvent évoluer dans les environnements cloud.

Apprentissage machine et IA

L'écosystème .NET intègre ML.NET, un framework d'apprentissage machine qui permet aux développeurs d'incorporer des modèles d'apprentissage machine personnalisés dans leurs applications .NET. Cette intégration ouvre des possibilités pour créer des applications intelligentes capables d'analyses prédictives, de traitement du langage naturel, et plus encore, en s'appuyant sur la puissance de l'IA au sein du framework .NET.

Améliorer le développement logiciel .NET avec IronPDF

Développement logiciel .NET (Comment ça fonctionne pour les développeurs) : Figure 1 - IronPDF

Dans le cadre dynamique du développement logiciel .NET, la capacité à générer, manipuler et gérer des documents PDF directement dans les applications offre un avantage significatif. IronPDF, une bibliothèque robuste conçue pour les développeurs .NET, s'intègre parfaitement dans cet environnement, offrant un moyen efficace de créer des PDF à partir d'applications .NET, y compris celles construites avec Windows Forms.

Le rôle d'IronPDF dans les applications .NET

IronPDF est un témoignage de la flexibilité et de la puissance de l'écosystème .NET, fournissant aux développeurs une API intuitive pour générer des documents PDF à partir de HTML, d'images, de texte, et même de pages web ASP.NET. Cette capacité est particulièrement utile dans les scénarios nécessitant la création dynamique de documents, tels que la génération de factures, de rapports ou de documents personnalisés dans les applications de bureau.

Créer un générateur de factures Windows Form avec IronPDF

Une application Windows Form pour générer des factures illustre l'application pratique du développement logiciel .NET combiné avec IronPDF. Cette application permet aux utilisateurs de saisir des détails tels que les informations sur le client, les articles achetés et les prix, puis de générer une facture PDF professionnelle en un seul clic.

Configurer votre projet Windows Forms et concevoir l'interface utilisateur

Commencez par créer un nouveau projet Windows Forms dans Visual Studio. Ceci est votre fondation, où vous allez concevoir l'interface utilisateur pour votre générateur de factures. Concevez votre formulaire pour inclure les champs d'entrée nécessaires pour les détails du client et des articles, avec un bouton pour générer le PDF. C'est notre interface utilisateur de générateur de factures :

Développement logiciel .NET (Comment ça fonctionne pour les développeurs) : Figure 2 - Sortie de Windows Form de générateur de facture

L'interface utilisateur de l'application Windows Forms est conçue méticuleusement pour garantir la facilité d'utilisation et la fonctionnalité. La fenêtre principale, intitulée "Invoice Generator", est segmentée en différentes sections pour une expérience utilisateur harmonieuse.

Section d'informations sur le client

En haut, le formulaire comprend des champs pour 'Nom du client', 'Adresse du client', 'Email du client' et 'Téléphone du client'. Cette zone est dédiée à la capture des détails essentiels du client qui seront affichés en évidence sur la facture générée.

Ajout d'articles de facture

Juste en dessous de l'information client, il y a une zone intitulée 'Ajouter un article de facture'. Ici, les utilisateurs peuvent entrer les détails des articles individuels, comme 'ID de l'article', 'Description', 'Quantité', et 'Prix unitaire'. Un bouton 'Ajouter un article' se trouve à côté de ces champs, permettant aux utilisateurs d'ajouter l'article saisi à la liste de factures ci-dessous.

Liste d'articles de facture

La partie centrale du formulaire présente la section 'Informations sur la facture', affichant un tableau où les articles saisis apparaissent au fur et à mesure qu'ils sont ajoutés. Les colonnes du tableau incluent 'ID de l'article', 'Description', 'Quantité', 'Prix unitaire', et 'Prix total', la dernière colonne étant automatiquement calculée en fonction de la quantité et du prix unitaire. Un sélecteur de date intitulé 'Sélectionner la date' permet à l'utilisateur de spécifier la date de la facture, ajoutant à la spécificité du document.

Opérations sur la facture

En bas du formulaire, une étiquette affiche le 'Montant total', se mettant à jour dynamiquement à mesure que les articles sont ajoutés ou supprimés. Ceci assure aux utilisateurs un décompte en temps réel du total de la facture. De plus, un bouton 'Générer la facture' demande à l'application d'utiliser la bibliothèque IronPDF pour créer une version PDF de la facture basée sur les données saisies.

Cette interface utilisateur est non seulement fonctionnelle, mais aussi intuitive, permettant aux utilisateurs d'interagir facilement avec l'application sans courbe d'apprentissage abrupte. Elle est conçue pour accueillir toutes les informations nécessaires à la génération de factures tout en fournissant un chemin clair et simple, depuis la saisie des données jusqu'à la création du PDF.

Ajouter IronPDF à votre projet

Avec votre projet configuré, l'étape suivante est d'ajouter IronPDF dans le mélange. Ceci est fait par NuGet, le gestionnaire de paquets intégré de Visual Studio, qui vous permet d'ajouter IronPDF à votre projet sans effort. Exécutez la commande suivante dans la console Gestionnaire de paquets :

Install-Package IronPdf

Cette commande installera IronPDF et le rendra disponible pour une utilisation dans votre projet.

Développement logiciel .NET (Comment ça fonctionne pour les développeurs) : Figure 3 - Installation d'IronPDF

Implémentation de la génération de factures

Le cœur de l'application Windows Forms est sa capacité à gérer les saisies de l'utilisateur, organiser les données dans un format structuré et produire un document tangible—dans ce cas, une facture sous forme de PDF. La fonctionnalité repose sur une série d'étapes méthodiques au sein du code de l'application.

Configurer la vue grille des données

Lors de l'initialisation du formulaire, l'application appelle SetupDataGridViewColumns pour établir la structure des données où les articles de facture seront affichés. Des colonnes pour l'ID de l'article, la description, la quantité, le prix unitaire et le prix total sont créées, le prix total étant un champ en lecture seule car il est automatiquement calculé. De plus, une colonne de boutons pour supprimer des articles est ajoutée, améliorant le contrôle de l'utilisateur sur le contenu de la facture.

private void SetupDataGridViewColumns()
{
    invoiceDataGridView.Columns.Clear(); // Clear existing columns if any
    // Add columns specifying the details to be displayed in the invoice
    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; // 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 to manage deletion of items
    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
    // Add columns specifying the details to be displayed in the invoice
    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; // 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 to manage deletion of items
    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
	' Add columns specifying the details to be displayed in the invoice
	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 ' 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 to manage deletion of items
	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
$vbLabelText   $csharpLabel

Ajout d'articles de facture

Lorsqu'un utilisateur entre des détails pour un article et clique sur 'Ajouter un article', l'événement btnAddItem_Click recueille les données saisies, les valide, puis appelle AddItemToInvoice. Cette méthode ajoute une nouvelle ligne au DataGridView avec les valeurs saisies, calculant le prix total pour l'article et mettant à jour le montant total de la facture affiché en bas du formulaire.

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);
    }
    // Display the total amount accumulated
    lblTotalAmount.Text = $"{totalAmount:C2}";
}

private void btnAddItem_Click(object sender, EventArgs e)
{
    // Collect data from input controls
    string itemId = txtItemID.Text;
    string description = txtDescription.Text;
    int quantity = (int)numericUpDownQuantity.Value;
    decimal unitPrice;
    // Validate the collected data
    bool isUnitPriceValid = decimal.TryParse(txtUnitPrice.Text, out unitPrice);
    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);
    // Clear the input fields after adding the item to the grid
    txtItemID.Clear();
    txtDescription.Clear();
    txtUnitPrice.Clear();
    numericUpDownQuantity.Value = 0;
    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);
    }
    // Display the total amount accumulated
    lblTotalAmount.Text = $"{totalAmount:C2}";
}

private void btnAddItem_Click(object sender, EventArgs e)
{
    // Collect data from input controls
    string itemId = txtItemID.Text;
    string description = txtDescription.Text;
    int quantity = (int)numericUpDownQuantity.Value;
    decimal unitPrice;
    // Validate the collected data
    bool isUnitPriceValid = decimal.TryParse(txtUnitPrice.Text, out unitPrice);
    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);
    // Clear the input fields after adding the item to the grid
    txtItemID.Clear();
    txtDescription.Clear();
    txtUnitPrice.Clear();
    numericUpDownQuantity.Value = 0;
    CalculateTotalAmount();
}
Imports System

Public Sub AddItemToInvoice(ByVal itemId As String, ByVal description As String, ByVal quantity As Integer, ByVal unitPrice As Decimal)
	Dim totalPrice As Decimal = quantity * unitPrice
	invoiceDataGridView.Rows.Add(itemId, description, quantity, unitPrice, totalPrice)
End Sub

Private Sub CalculateTotalAmount()
	Dim totalAmount As Decimal = 0D
	For Each row As DataGridViewRow In invoiceDataGridView.Rows
		totalAmount += Convert.ToDecimal(If(row.Cells("totalPriceColumn").Value, 0))
	Next row
	' Display the total amount accumulated
	lblTotalAmount.Text = $"{totalAmount:C2}"
End Sub

Private Sub btnAddItem_Click(ByVal sender As Object, ByVal e As EventArgs)
	' Collect data from input controls
	Dim itemId As String = txtItemID.Text
	Dim description As String = txtDescription.Text
	Dim quantity As Integer = CInt(Math.Truncate(numericUpDownQuantity.Value))
	Dim unitPrice As Decimal = Nothing
	' Validate the collected data
	Dim isUnitPriceValid As Boolean = Decimal.TryParse(txtUnitPrice.Text, unitPrice)
	If String.IsNullOrEmpty(itemId) OrElse String.IsNullOrEmpty(description) OrElse quantity <= 0 OrElse Not isUnitPriceValid OrElse unitPrice <= 0 Then
		MessageBox.Show("Please enter valid data for all fields.", "Invalid Data", MessageBoxButtons.OK, MessageBoxIcon.Warning)
		Return
	End If
	' Add data to the DataGridView
	AddItemToInvoice(itemId, description, quantity, unitPrice)
	' Clear the input fields after adding the item to the grid
	txtItemID.Clear()
	txtDescription.Clear()
	txtUnitPrice.Clear()
	numericUpDownQuantity.Value = 0
	CalculateTotalAmount()
End Sub
$vbLabelText   $csharpLabel

Développement logiciel .NET (Comment ça fonctionne pour les développeurs) : Figure 4 - Données de Facturation

Génération de la facture PDF En cliquant sur 'Générer la facture', l'application exécute le gestionnaire d'événements btnInvoice_Click, où elle construit une chaîne HTML à l'aide d'un StringBuilder. Cette chaîne inclut les détails du client et un tableau HTML stylé rempli avec les articles de la facture du DataGridView. Le renderer d'IronPDF convertit ensuite ce HTML en un document PDF, qui est enregistré à un chemin spécifié.

private void btnInvoice_Click(object sender, EventArgs e)
{
    IronPdf.License.LicenseKey = "your-license-key"; // Replace with your IronPDF license key
    var customerName = txtName.Text;
    var customerEmail = txtEmail.Text;
    var customerAddress = txtAddress.Text;
    var customerPhone = txtPhone.Text;
    var htmlStringBuilder = new StringBuilder();
    htmlStringBuilder.Append("<html>");
    htmlStringBuilder.Append("<head>");
    htmlStringBuilder.Append("<title>Invoice</title>");
    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 { line-height: 1.6; margin-bottom: 20px; }
            .customer-info p { margin: 0 0 10px 0; color: #333; }
            .customer-info label { font-weight: bold; }
        </style>");
    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>");
    htmlStringBuilder.Append("<table><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; 
        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>");
    htmlStringBuilder.Append($"<h2>Total Amount: {lblTotalAmount.Text}</h2>");
    htmlStringBuilder.Append("</body></html>");
    var renderer = new IronPdf.ChromePdfRenderer();
    var pdfDocument = renderer.RenderHtmlAsPdf(htmlStringBuilder.ToString());
    string savePath = Path.Combine($"F:\\Invoice_{DateTime.Now:yyyyMMddHHmmss}.pdf");
    pdfDocument.SaveAs(savePath);
    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 = "your-license-key"; // Replace with your IronPDF license key
    var customerName = txtName.Text;
    var customerEmail = txtEmail.Text;
    var customerAddress = txtAddress.Text;
    var customerPhone = txtPhone.Text;
    var htmlStringBuilder = new StringBuilder();
    htmlStringBuilder.Append("<html>");
    htmlStringBuilder.Append("<head>");
    htmlStringBuilder.Append("<title>Invoice</title>");
    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 { line-height: 1.6; margin-bottom: 20px; }
            .customer-info p { margin: 0 0 10px 0; color: #333; }
            .customer-info label { font-weight: bold; }
        </style>");
    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>");
    htmlStringBuilder.Append("<table><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; 
        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>");
    htmlStringBuilder.Append($"<h2>Total Amount: {lblTotalAmount.Text}</h2>");
    htmlStringBuilder.Append("</body></html>");
    var renderer = new IronPdf.ChromePdfRenderer();
    var pdfDocument = renderer.RenderHtmlAsPdf(htmlStringBuilder.ToString());
    string savePath = Path.Combine($"F:\\Invoice_{DateTime.Now:yyyyMMddHHmmss}.pdf");
    pdfDocument.SaveAs(savePath);
    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 = "your-license-key" ' Replace with your IronPDF license key
	Dim customerName = txtName.Text
	Dim customerEmail = txtEmail.Text
	Dim customerAddress = txtAddress.Text
	Dim customerPhone = txtPhone.Text
	Dim htmlStringBuilder = New StringBuilder()
	htmlStringBuilder.Append("<html>")
	htmlStringBuilder.Append("<head>")
	htmlStringBuilder.Append("<title>Invoice</title>")
	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 { line-height: 1.6; margin-bottom: 20px; }
            .customer-info p { margin: 0 0 10px 0; color: #333; }
            .customer-info label { font-weight: bold; }
        </style>")
	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>")
	htmlStringBuilder.Append("<table><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
		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>")
	htmlStringBuilder.Append($"<h2>Total Amount: {lblTotalAmount.Text}</h2>")
	htmlStringBuilder.Append("</body></html>")
	Dim renderer = New IronPdf.ChromePdfRenderer()
	Dim pdfDocument = renderer.RenderHtmlAsPdf(htmlStringBuilder.ToString())
	Dim savePath As String = Path.Combine($"F:\Invoice_{DateTime.Now:yyyyMMddHHmmss}.pdf")
	pdfDocument.SaveAs(savePath)
	MessageBox.Show("The invoice has been successfully saved to your desktop.", "Invoice Saved", MessageBoxButtons.OK, MessageBoxIcon.Information)
End Sub
$vbLabelText   $csharpLabel

L'application confirme la création réussie de la facture avec un message à l'utilisateur.

Exécution de l'application et génération de factures Une fois que l'application Windows Forms est développée et que la bibliothèque IronPDF est intégrée, exécuter l'application et générer des factures PDF est un processus simple. L'utilisateur interagit avec l'interface utilisateur de l'application pour saisir des données et produit la sortie souhaitée.

Voici comment le processus se déroule généralement :

Lancement de l'application Démarrez l'application en l'exécutant dans Visual Studio ou en exécutant directement le fichier exécutable compilé (.exe) depuis l'environnement Windows.

Le formulaire de l'application s'affiche, prêt pour l'interaction de l'utilisateur.

Saisie des données de la facture Entrez les détails du client dans les zones de texte désignées en haut du formulaire, y compris le nom, l'adresse, l'email et le numéro de téléphone du client.

Ajoutez des articles de facture en remplissant les champs 'ID de l'article', 'Description', 'Quantité', et 'Prix unitaire' situés dans la section 'Ajouter un article de facture' du formulaire.

Cliquez sur 'Ajouter un article' pour inclure l'article dans la liste de la facture. Le DataGridView se mettra à jour pour afficher le nouvel article, ses détails, et le prix total calculé. Répétez le processus pour ajouter tous les articles nécessaires à la facture. L'étiquette 'Montant total' se mettra à jour dynamiquement pour refléter le total cumulé des articles listés.

Développement logiciel .NET (Comment ça fonctionne pour les développeurs) : Figure 4 - Données de Facturation

Développement logiciel .NET (Comment ça fonctionne pour les développeurs) : Figure 5 - Dialogue de Facture Enregistrée Cliquez sur 'Générer la facture' une fois tous les articles ajoutés et les informations client complètes. L'application compilera les données au format HTML, stylé avec CSS. IronPDF prend le relais pour convertir la chaîne HTML en un document PDF.

Il est rendu avec le moteur Chrome, garantissant une haute fidélité aux normes web modernes.

Affichage de la facture générée Après la génération du PDF, l'application enregistre le fichier PDF à un emplacement spécifié, souvent dans le même répertoire que l'application ou à un chemin défini par l'utilisateur. Un message de réussite apparaît pour notifier à l'utilisateur que la facture PDF a été enregistrée avec succès.

Les utilisateurs peuvent ensuite naviguer vers l'emplacement enregistré pour afficher ou distribuer la facture.

Sortie PDF

Développement logiciel .NET (Comment ça fonctionne pour les développeurs) : Figure 6 - Sortie PDF Le PDF de sortie affiche les informations du client en haut, suivi d'un tableau détaillé des articles achetés, y compris les descriptions, les quantités et les prix. Le montant total de la facture est indiqué à la fin du document, indiquant clairement le montant que le client doit payer.

Le PDF est stylé pour être propre et professionnel, utilisant le CSS défini dans le code pour assurer que la facture n'est pas seulement fonctionnelle mais aussi esthétiquement plaisante.

Transformer le projet Windows Forms en un exécutable

Après avoir testé minutieusement votre application Windows Forms et vous être assuré que toutes les fonctionnalités telles que la saisie de données, la génération de PDF et la sortie fonctionnent parfaitement, la prochaine étape est d'emballer votre projet en un fichier exécutable (.exe). Ce processus de conversion est simplifié dans le framework .NET, garantissant que votre application est prête pour être installée et utilisée sur les machines Windows.

Voici une approche étape par étape pour créer l'exécutable :

  1. Construire l'application : Allez dans le menu 'Build' et choisissez 'Build Solution'. Cela compile le code en assemblages et effectue les optimisations nécessaires.

Développement logiciel .NET (Comment ça fonctionne pour les développeurs) : Figure 7 - Solution de Construction

  1. Localiser l'exécutable : Une fois la construction terminée, naviguez jusqu'au dossier 'bin\Debug\net8.0' à l'intérieur du répertoire de votre projet. Ici, vous trouverez le fichier .exe ainsi que toute autre dépendance nécessaire pour exécuter votre application.

Développement logiciel .NET (Comment ça fonctionne pour les développeurs) : Figure 8 - Emplacement de l'Exécutable

  1. Tester l'exécutable : Il est recommandé d'exécuter le fichier .exe sur une autre machine pour confirmer qu'il fonctionne correctement en dehors de votre environnement de développement.
  2. Préparation pour la distribution : Pour la distribution, vous pouvez partager directement le fichier .exe s'il n'y a pas de dépendances supplémentaires nécessaires. Cependant, pour une approche plus professionnelle, envisagez de créer un installateur en utilisant un projet de configuration dans Visual Studio ou un package d'installation tiers comme Inno Setup ou WiX Toolset. Un installateur peut gérer le processus d'installation, créer des raccourcis, et gérer d'autres complexités telles que l'enregistrement dans le registre Windows si nécessaire.

En suivant ces étapes, votre application Windows Forms est condensée en un fichier exécutable unique, prêt à être partagé et utilisé. Cette conversion marque l'aboutissement du processus de développement, passant d'un projet sur votre machine de développement à un logiciel déployable pouvant être efficacement distribué et installé à travers une multitude d'environnements Windows.

Conclusion

Développement logiciel .NET (Comment ça fonctionne pour les développeurs) : Figure 9 - Licence

En conclusion, le développement d'une application Windows Forms pour générer des factures PDF en utilisant IronPDF et le .NET Framework illustre une application pratique des principes du développement logiciel. Ce projet montre non seulement la polyvalence et la puissance de l'écosystème .NET, mais aussi comment les développeurs peuvent intégrer des bibliothèques tierces comme IronPDF pour étendre la fonctionnalité et répondre à des besoins spécifiques des entreprises.

En suivant les étapes décrites, de la configuration de l'interface utilisateur à l'implémentation de la génération de PDF en passant par le packaging de l'application en un exécutable, les développeurs peuvent créer une application fonctionnelle et conviviale. Ce processus souligne l'importance de combiner des frameworks de programmation robustes avec des bibliothèques innovantes pour résoudre des problèmes du monde réel, livrant en fin de compte un produit qui est à la fois efficace et efficient.

IronPDF propose généreusement un essai gratuit pour les fonctionnalités de génération de PDF afin que les développeurs puissent explorer ses fonctionnalités et déterminer comment il s'intègre le mieux à leurs besoins. Une fois que vous aurez expérimenté les avantages et que vous serez prêt à intégrer IronPDF dans votre environnement de production, les licences commencent à partir d'options de tarification abordables.

Questions Fréquemment Posées

Comment puis-je convertir HTML en PDF en C# ?

Vous pouvez utiliser la méthode RenderHtmlAsPdf d'IronPDF pour convertir des chaînes HTML en PDFs. Vous pouvez également convertir des fichiers HTML en PDFs en utilisant RenderHtmlFileAsPdf.

Quels sont les avantages d'utiliser .NET Core pour le développement multiplateforme ?

.NET Core vous permet d'exécuter des applications sur plusieurs plateformes comme Linux, macOS et Windows, ce qui en fait un choix polyvalent pour les développeurs qui souhaitent atteindre un public plus large avec une base de code unique.

Comment puis-je générer des PDFs à partir d'une application Windows Form ?

En utilisant IronPDF, vous pouvez générer des PDFs à partir d'une application Windows Form en intégrant la bibliothèque dans votre projet et en utilisant ses méthodes pour convertir les données du formulaire ou le contenu HTML en documents PDF.

Qu'est-ce qui fait de .NET un cadre idéal pour construire des applications web ?

.NET, et en particulier ASP.NET, offre un cadre robuste pour construire des applications web dynamiques et évolutives. Il propose des outils intégrés pour le script côté serveur, l'authentification, la gestion des données, et plus encore.

Comment puis-je améliorer mon application .NET avec des capacités de génération de documents ?

L'intégration d'une bibliothèque comme IronPDF dans votre application .NET peut considérablement améliorer ses capacités de génération de documents, vous permettant de créer, manipuler et gérer des fichiers PDF directement au sein de votre application.

Le .NET peut-il être utilisé pour le développement d'applications mobiles ?

Oui, .NET prend en charge le développement d'applications mobiles via le framework Xamarin, qui fait maintenant partie de .NET MAUI. Cela permet la création d'applications mobiles multiplateformes avec des performances natives sur iOS, Android et Windows.

Quelle est l'importance du Common Language Runtime (CLR) dans .NET ?

Le Common Language Runtime (CLR) est crucial dans .NET car il gère l'exécution des programmes en convertissant le code compilé en code machine natif, assurant la compatibilité entre différents systèmes d'exploitation.

Comment puis-je intégrer la génération de PDF dans mon projet .NET en utilisant NuGet ?

Vous pouvez intégrer la génération de PDF dans votre projet .NET en utilisant NuGet pour installer une bibliothèque comme IronPDF. Cela rend l'ajout de capacités PDF pratique et simple dans Visual Studio.

Quelles sont les étapes pour créer un générateur de factures PDF en utilisant Windows Forms ?

Le processus inclut la configuration d'un projet Windows Forms, la conception de l'interface, l'ajout des bibliothèques nécessaires via NuGet, la mise en œuvre de la logique pour l'entrée de données et la génération de factures, et l'utilisation d'IronPDF pour convertir les détails de la facture en PDF.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit