Tworzenie oprogramowania w .NET (jak to działa dla programistów)
Tworzenie oprogramowania w ramach platformy .NET Framework to potężny, wszechstronny framework wspierany przez firmę Microsoft, który umożliwia programistom .NET tworzenie solidnych, wysokiej jakości aplikacji na różne platformy, systemy operacyjne i urządzenia. Ten framework programistyczny został zaprojektowany jako kompleksowe rozwiązanie, zapewniające narzędzia, biblioteki i interfejsy API, które programiści mogą wykorzystać do wydajnego tworzenia aplikacji internetowych, desktopowych i mobilnych na platformie .NET Framework.
Dzięki obsłudze wielu języków programowania, w tym C#, Visual Basic i F#, środowisko .NET zapewnia programistom większą elastyczność, umożliwiając im pracę w preferowanym języku przy jednoczesnym korzystaniu z bogatych funkcji ekosystemu .NET Core. W tym samouczku zobaczymy, w jaki sposób IronPDF usprawnia tworzenie oprogramowania w środowisku .NET, pomagając w rozwiązywaniu rzeczywistych problemów.
Zrozumienie ekosystemu tworzenia oprogramowania .NET
Ekosystem .NET, kluczowa implementacja platformy .NET, to szeroka, wszechstronna platforma, która obejmuje różne komponenty i technologie zaprojektowane w celu ułatwienia tworzenia aplikacji na różnych systemach operacyjnych. W swej istocie platformy .NET Framework i .NET Core służą jako główne silniki do uruchamiania aplikacji .NET, zapewniając środowisko uruchomieniowe CLR (Common Language Runtime), które zarządza wykonywaniem kodu i oferuje usługi takie jak zarządzanie pamięcią, bezpieczeństwo typów, obsługa wyjątków i wiele innych.
Środowisko uruchomieniowe Common Language Runtime (CLR)
CLR jest kluczowym elementem architektury .NET, umożliwiającym wykonywanie kodu .NET w różnych systemach operacyjnych. Kompiluje on Common Intermediate Language (CIL) do natywnego kodu maszynowego, który komputer hosta może bezpośrednio wykonać. Proces ten gwarantuje, że aplikacje .NET mogą działać płynnie na różnych platformach, od głównych mobilnych systemów operacyjnych po serwery internetowe Windows.
Framework wieloplatformowy
.NET Core staje się platformą wieloplatformową, umożliwiającą uruchamianie aplikacji .NET w systemach Linux, macOS i Windows. Ta elastyczność sprawia, że .NET jest atrakcyjnym wyborem dla programistów, którzy chcą dotrzeć do szerszej grupy odbiorców korzystających z różnych urządzeń i platform. Dzięki .NET Core aplikacje można tworzyć i wdrażać na dowolnym obsługiwanym systemie operacyjnym, co zwiększa zasięg i elastyczność tworzenia oprogramowania .NET, wspieranego przez rozległą społeczność .NET.
Zintegrowane środowisko programistyczne (IDE)
Visual Studio wyróżnia się jako wiodące zintegrowane środowisko programistyczne (IDE) do tworzenia oprogramowania w .NET. Zapewnia programistom potężne narzędzia do pisania kodu, debugowania i wdrażania aplikacji .NET. Visual Studio obsługuje różne języki programowania i oferuje szeroki wachlarz funkcji do tworzenia aplikacji internetowych, desktopowych i mobilnych, co czyni je nieodzownym narzędziem dla programistów .NET.
Tworzenie aplikacji za pomocą .NET
Tworzenie aplikacji na platformie .NET wymaga wykorzystania szerokiej gamy narzędzi, bibliotek i języków programowania oferowanych przez .NET Framework, takich jak Visual Basic, co podkreśla jego wszechstronny ekosystem. Ta wszechstronność umożliwia programistom tworzenie różnego rodzaju aplikacji .NET, od aplikacji internetowych i desktopowych po rozwiązania chmurowe i mobilne.
Tworzenie stron internetowych z wykorzystaniem ASP.NET
ASP.NET, kluczowy element .NET Framework, został specjalnie zaprojektowany do tworzenia dynamicznych stron internetowych i aplikacji. Pozwala to programistom tworzyć responsywne i skalowalne aplikacje internetowe, które mogą obsłużyć ogromne ilości ruchu. ASP.NET Core, wersja ASP.NET typu open source, oferuje dodatkowe funkcje do tworzenia wieloplatformowych aplikacji internetowych, umożliwiając opracowywanie i wdrażanie aplikacji internetowych w systemach Windows, Linux i macOS.
Tworzenie aplikacji desktopowych
.NET oferuje dwa główne podejścia do tworzenia aplikacji desktopowych: Windows Forms i Windows Presentation Foundation (WPF). Windows Forms oferuje prosty sposób tworzenia aplikacji desktopowych z bogatym graficznym interfejsem użytkownika, podczas gdy WPF wykorzystuje XAML (Extensible Application Markup Language) do tworzenia atrakcyjnych wizualnie interfejsów użytkownika z zaawansowaną grafiką i animacjami.
Tworzenie aplikacji mobilnych
W zakresie tworzenia aplikacji mobilnych platforma .NET rozszerza swój zasięg na główne systemy operacyjne dla urządzeń mobilnych dzięki frameworkowi Xamarin, który został zintegrowany z platformą .NET jako .NET MAUI (Multi-platform App UI). Takie podejście pozwala programistom na ponowne wykorzystanie kodu na platformach iOS, Android i Windows, upraszczając proces tworzenia aplikacji mobilnych, które oferują wydajność i komfort użytkowania na poziomie aplikacji natywnych.
Chmura i mikrousługi
.NET doskonale nadaje się również do tworzenia aplikacji działających w chmurze. Dzięki obsłudze platformy Azure i innych platform chmurowych programiści mogą tworzyć skalowalne, rozproszone aplikacje, które wykorzystują zasoby chmury obliczeniowej. .NET Core odgrywa znaczącą rolę w tworzeniu mikrousług, oferując lekkie, modułowe i niezależnie wdrażalne usługi, które można skalować w środowiskach chmurowych.
Uczenie maszynowe i sztuczna inteligencja
Ekosystem .NET obejmuje ML.NET, framework uczenia maszynowego, który pozwala programistom na włączanie niestandardowych modeli uczenia maszynowego do swoich aplikacji .NET. Ta integracja otwiera możliwości tworzenia inteligentnych aplikacji zdolnych do analizy predykcyjnej, przetwarzania języka naturalnego i nie tylko, wykorzystując moc sztucznej inteligencji w ramach .NET Framework.
Ulepszanie tworzenia oprogramowania .NET dzięki IronPDF
W dynamicznym ekosystemie tworzenia oprogramowania .NET możliwość generowania, edycji i zarządzania dokumentami PDF bezpośrednio w aplikacjach stanowi znaczną zaletę. IronPDF, solidna biblioteka zaprojektowana dla programistów .NET, płynnie integruje się z tym środowiskiem, oferując wydajny sposób tworzenia plików PDF z aplikacji .NET, w tym tych zbudowanych przy użyciu Windows Forms.
Rola IronPDF w aplikacjach .NET
IronPDF jest świadectwem elastyczności i mocy ekosystemu .NET, zapewniając programistom intuicyjny interfejs API do generowania dokumentów PDF z HTML, obrazów, tekstu, a nawet stron internetowych ASP.NET. Ta funkcja jest szczególnie przydatna w sytuacjach wymagających dynamicznego tworzenia dokumentów, takich jak generowanie faktur, raportów lub spersonalizowanych dokumentów w aplikacjach desktopowych.
Tworzenie generatora faktur w Windows Forms za pomocą IronPDF
Aplikacja Windows Form do generowania faktur stanowi przykład praktycznego zastosowania tworzenia oprogramowania w środowisku .NET w połączeniu z IronPDF. Ta aplikacja pozwala użytkownikom wprowadzać dane, takie jak informacje o klientach, zakupione produkty i ceny, a następnie generować profesjonalną fakturę w formacie PDF za pomocą jednego kliknięcia.
Konfiguracja projektu Windows Forms i projektowanie interfejsu użytkownika
Zacznij od utworzenia nowego projektu Windows Forms w programie Visual Studio. To jest Twoja podstawa, na której stworzysz interfejs użytkownika dla swojego generatora faktur. Zaprojektuj formularz tak, aby zawierał niezbędne pola do wprowadzania danych klienta i szczegółów produktu, a także przycisk do generowania pliku PDF. Oto interfejs użytkownika naszego generatora faktur:
Interfejs użytkownika aplikacji Windows Forms został starannie zaprojektowany, aby zapewnić łatwość obsługi i funkcjonalność. Okno główne, zatytułowane "Invoice Generator", jest podzielone na różne sekcje, co zapewnia płynne działanie.
Sekcja informacji o kliencie
W górnej części formularza znajdują się pola "Nazwa klienta", "Adres klienta", "Adres e-mail klienta" oraz "Numer telefonu klienta". Obszar ten służy do wprowadzania podstawowych danych klienta, które zostaną umieszczone w widocznym miejscu na wygenerowanej fakturze.
Dodawanie pozycji do faktury
Tuż pod informacjami o kliencie znajduje się obszar oznaczony jako "Dodaj pozycję do faktury". W tym miejscu użytkownicy mogą wprowadzić szczegóły poszczególnych pozycji, takie jak "ID pozycji", "Opis", "Ilość" i "Cena jednostkowa". Obok tych pól znajduje się przycisk "Dodaj pozycję", który pozwala użytkownikom dodać wprowadzoną pozycję do listy faktur poniżej.
Lista pozycji faktury
W centralnej części formularza znajduje się sekcja "Informacje o fakturze", zawierająca tabelę, w której pojawiają się wprowadzane pozycje w miarę ich dodawania. Kolumny tabeli obejmują "ID pozycji", "Opis", "Ilość", "Cena jednostkowa" oraz "Cena całkowita", przy czym ostatnia kolumna jest obliczana automatycznie na podstawie ilości i ceny jednostkowej. Selektor daty zatytułowany "Wybierz datę" pozwala użytkownikowi określić datę faktury, co zwiększa szczegółowość dokumentu.
Operacje związane z fakturami
W dolnej części formularza znajduje się etykieta wyświetlająca "Suma całkowita", która jest dynamicznie aktualizowana w miarę dodawania lub usuwania pozycji. Dzięki temu użytkownicy mają w czasie rzeczywistym podsumowanie całkowitej wartości faktury. Dodatkowo przycisk "Generuj fakturę" powoduje, że aplikacja korzysta z biblioteki IronPDF w celu utworzenia wersji PDF faktury na podstawie wprowadzonych danych.
Ten interfejs użytkownika jest nie tylko funkcjonalny, ale także intuicyjny, co pozwala użytkownikom na łatwą interakcję z aplikacją bez konieczności długiego wdrażania się. Został zaprojektowany tak, aby pomieścić wszystkie informacje niezbędne do generowania faktur, zapewniając jednocześnie jasną i prostą ścieżkę od wprowadzenia danych do utworzenia pliku PDF.
Dodawanie IronPDF do projektu
Po skonfigurowaniu projektu następnym krokiem jest włączenie IronPDF do procesu. Odbywa się to za pośrednictwem NuGet, zintegrowanego menedżera pakietów NuGet w Visual Studio, który pozwala bez wysiłku dodać IronPDF do projektu. Uruchom następujące polecenie w konsoli menedżera pakietów:
Install-Package IronPdf
To polecenie zainstaluje IronPDF i udostępni go do użytku w Twoim projekcie.
Wdrażanie generowania faktur
Istotą aplikacji Windows Forms jest jej zdolność do obsługi danych wprowadzanych przez użytkownika, organizowania danych w ustrukturyzowanym formacie oraz tworzenia namacalnego dokumentu — w tym przypadku faktury w formacie PDF. Funkcjonalność opiera się na serii metodycznych kroków w kodzie aplikacji.
Konfiguracja widoku siatki danych
Po zainicjowaniu formularza aplikacja wywołuje metodę SetupDataGridViewColumns w celu ustalenia struktury danych, w której będą wyświetlane pozycje faktury. Tworzone są kolumny dla identyfikatora pozycji, opisu, ilości, ceny jednostkowej i ceny całkowitej, przy czym cena całkowita jest polem tylko do odczytu, ponieważ jest obliczana automatycznie. Dodatkowo dodano kolumnę przycisków do usuwania pozycji, zwiększając kontrolę użytkownika nad treścią faktury.
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 SubDodawanie pozycji do faktury
Gdy użytkownik wprowadzi szczegóły dotyczące pozycji i kliknie "Dodaj pozycję", zdarzenie btnAddItem_Click zbiera wprowadzone dane, weryfikuje je, a następnie wywołuje metodę AddItemToInvoice. Ta metoda dodaje nowy wiersz do DataGridView z wprowadzonymi wartościami, obliczając całkowitą cenę pozycji i aktualizując całkowitą kwotę faktury wyświetlaną na dole formularza.
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 SubGenerowanie faktury w formacie PDF
Po kliknięciu przycisku "Generuj fakturę" aplikacja uruchamia procedurę obsługi zdarzenia btnInvoice_Click, w której tworzy ciąg HTML przy użyciu klasy StringBuilder. Ten ciąg znaków zawiera dane klienta oraz sformatowaną tabelę HTML wypełnioną pozycjami faktury z DataGridView. Następnie renderer IronPDF konwertuje ten kod HTML na dokument PDF, który jest zapisywany w określonej lokalizacji. Aplikacja potwierdza pomyślne utworzenie faktury komunikatem wyświetlanym użytkownikowi.
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 SubUruchamianie aplikacji i generowanie faktur
Po opracowaniu aplikacji Windows Forms i zintegrowaniu biblioteki IronPDF uruchomienie aplikacji i generowanie faktur w formacie PDF jest prostym procesem. Użytkownik korzysta z interfejsu aplikacji, aby wprowadzić dane i uzyskać pożądany wynik. Oto jak zazwyczaj przebiega ten proces:
Uruchomienie aplikacji
Uruchom aplikację w środowisku Visual Studio lub bezpośrednio w systemie Windows, uruchamiając skompilowany plik wykonywalny (.exe). Formularz aplikacji wyświetla się, gotowy do interakcji z użytkownikiem.
Wprowadzanie danych faktury
Wprowadź dane klienta w przeznaczonych do tego polach tekstowych u góry formularza, w tym imię i nazwisko, adres, adres e-mail oraz numer telefonu. Dodaj pozycje faktury, wypełniając pola "ID pozycji", "Opis", "Ilość" i "Cena jednostkowa" znajdujące się w sekcji "Dodaj pozycję faktury" formularza.
Kliknij "Dodaj pozycję", aby dodać pozycję do listy faktury. Widok DataGridView zaktualizuje się, aby wyświetlić nową pozycję, jej szczegóły oraz obliczoną cenę całkowitą. Powtórz ten proces, aby dodać wszystkie niezbędne pozycje do faktury. Etykieta "Kwota całkowita" zostanie dynamicznie zaktualizowana, aby odzwierciedlić łączną sumę wymienionych pozycji.
Generowanie faktury w formacie PDF
Kliknij "Generuj fakturę", gdy wszystkie pozycje zostaną dodane, a informacje o kliencie będą kompletne. Aplikacja skompiluje dane do formatu HTML, stylizowanego za pomocą CSS. IronPDF przejmuje zadanie konwersji ciągu znaków HTML na dokument PDF. Renderowanie odbywa się za pomocą silnika Chrome, co zapewnia wysoką zgodność z nowoczesnymi standardami internetowymi.
Wyświetlanie wygenerowanej faktury
Po wygenerowaniu pliku PDF aplikacja zapisuje go w określonej lokalizacji, często w tym samym katalogu co aplikacja lub w ścieżce zdefiniowanej przez użytkownika. Pojawia się komunikat o pomyślnym zakończeniu operacji, informujący użytkownika, że faktura w formacie PDF została pomyślnie zapisana. Użytkownicy mogą następnie przejść do zapisanej lokalizacji, aby wyświetlić lub rozesłać fakturę.
Wynik w formacie PDF
W pliku PDF na górze wyświetlane są informacje o kliencie, a poniżej znajduje się szczegółowa tabela zakupionych produktów, zawierająca opisy, ilości i ceny. Całkowita kwota faktury jest podana na końcu dokumentu, wyraźnie wskazując kwotę, którą klient musi zapłacić. PDF ma przejrzysty i profesjonalny wygląd, wykorzystujący CSS zdefiniowany w kodzie, aby zapewnić, że faktura jest nie tylko funkcjonalna, ale także estetyczna.
Przekształcanie projektu Windows Forms w plik wykonywalny
Po dokładnym przetestowaniu aplikacji Windows Forms i upewnieniu się, że wszystkie funkcje, takie jak wprowadzanie danych, generowanie plików PDF i wyjście, działają bez zarzutu, następnym etapem jest spakowanie projektu do pliku wykonywalnego (.exe). Ten proces konwersji jest usprawniony w ramach .NET Framework, co gwarantuje, że aplikacja jest gotowa do instalacji i użycia na komputerach z systemem Windows.
Oto krok po kroku, jak stworzyć plik wykonywalny:
- Skompiluj aplikację: Przejdź do menu "Build" i wybierz opcję "Build Solution". Spowoduje to skompilowanie kodu do zestawów (assembly) oraz przeprowadzenie niezbędnych optymalizacji.
- Znajdź plik wykonywalny: Po zakończeniu kompilacji przejdź do folderu "bin\Debug\net8.0" w katalogu projektu. Tutaj znajdziesz plik .exe wraz z innymi zależnościami wymaganymi do uruchomienia aplikacji.
- Testowanie pliku wykonywalnego: Dobrą praktyką jest uruchomienie pliku .exe na innym komputerze, aby sprawdzić, czy działa on poprawnie poza środowiskiem programistycznym.
- Przygotowanie do dystrybucji: W celu dystrybucji można bezpośrednio udostępnić plik .exe, jeśli nie są wymagane żadne dodatkowe zależności. Jednakże, aby uzyskać bardziej profesjonalny efekt, warto rozważyć stworzenie instalatora przy użyciu projektu instalacyjnego w Visual Studio lub pakietu instalacyjnego innej firmy, takiego jak Inno Setup lub WiX Toolset. Instalator może zarządzać procesem instalacji, tworzyć skróty i obsługiwać inne złożone zadania, takie jak rejestracja w rejestrze systemu Windows, jeśli jest to konieczne.
Postępując zgodnie z tymi krokami, aplikacja Windows Forms zostanie skompresowana do pojedynczego pliku wykonywalnego, gotowego do udostępnienia i wykorzystania. Ta konwersja stanowi zwieńczenie procesu rozwoju, przejście od projektu na komputerze programisty do gotowego oprogramowania, które można efektywnie dystrybuować i instalować w wielu środowiskach Windows.
Wnioski
Podsumowując, stworzenie aplikacji Windows Forms do generowania faktur w formacie PDF przy użyciu IronPDF i .NET Framework stanowi praktyczny przykład zastosowania zasad tworzenia oprogramowania. Projekt ten nie tylko pokazuje wszechstronność i moc ekosystemu .NET, ale także demonstruje, w jaki sposób programiści mogą integrować biblioteki innych firm, takie jak IronPDF, aby rozszerzyć funkcjonalność i zaspokoić konkretne potrzeby biznesowe.
Postępując zgodnie z opisanymi krokami, od konfiguracji interfejsu użytkownika po wdrożenie generowania plików PDF i spakowanie aplikacji do pliku wykonywalnego, programiści mogą stworzyć funkcjonalną i przyjazną dla użytkownika aplikację. Proces ten podkreśla znaczenie łączenia solidnych frameworków programistycznych z innowacyjnymi bibliotekami w celu rozwiązywania rzeczywistych problemów, co ostatecznie pozwala stworzyć produkt, który jest zarówno skuteczny, jak i wydajny.
IronPDF oferuje bezpłatną wersję próbną funkcji generowania plików PDF, aby programiści mogli zapoznać się z jej możliwościami i ocenić, w jakim stopniu odpowiada ona ich potrzebom. Gdy już doświadczysz korzyści i będziesz gotowy do wdrożenia IronPDF w swoim środowisku produkcyjnym, licencje są dostępne w przystępnych cenach.
Często Zadawane Pytania
Jak mogę przekonwertować HTML na PDF w języku C#?
Możesz użyć metody RenderHtmlAsPdf biblioteki IronPDF do konwersji ciągów HTML na pliki PDF. Możesz również konwertować pliki HTML na pliki PDF za pomocą metody RenderHtmlFileAsPdf.
Jakie są korzyści z używania .NET Core do tworzenia aplikacji na różnych platformach?
.NET Core umożliwia uruchamianie aplikacji na wielu platformach, takich jak Linux, macOS i Windows, co czyni go wszechstronnym wyborem dla deweloperów chcących dotrzeć do szerszej publiczności za pomocą pojedynczej bazujacy na kodzie.
Jak mogę generować PDF-y z aplikacji Windows Form?
Korzystając z IronPDF, można generować PDF-y z aplikacji Windows Form poprzez zintegrowanie biblioteki z projektem i użycie jej metod do konwersji danych formularza lub zawartości HTML na dokumenty PDF.
Co sprawia, że .NET jest idealnym środowiskiem do tworzenia aplikacji internetowych?
.NET, a zwłaszcza ASP.NET, zapewnia solidne środowisko do budowy dynamicznych i skalowalnych aplikacji internetowych. Oferuje wbudowane narzędzia do skryptów po stronie serwera, uwierzytelniania, zarządzania danymi i nie tylko.
Jak mogę wzbogacić swoją aplikację .NET o możliwość generowania dokumentów?
Zintegrowanie biblioteki, takiej jak IronPDF, z aplikacją .NET może znacznie zwiększyć jej możliwości generowania dokumentów, umożliwiając tworzenie, manipulację i zarządzanie plikami PDF bezpośrednio w aplikacji.
Czy .NET może być używany do tworzenia aplikacji mobilnych?
Tak, .NET wspiera tworzenie aplikacji mobilnych poprzez ramy Xamarin, które są teraz częścią .NET MAUI. Umożliwia to tworzenie aplikacji mobilnych cross-platform z natywną wydajnością na iOS, Android i Windows.
Jakie jest znaczenie Common Language Runtime (CLR) w .NET?
Common Language Runtime (CLR) jest kluczowy w .NET, ponieważ zarządza wykonywaniem programów poprzez konwersję kodu skompilowanego na natywny kod maszynowy, zapewniając kompatybilność między różnymi systemami operacyjnymi.
Jak zintegrować generowanie PDF z projektem .NET za pomocą NuGet?
Możesz zintegrować generowanie PDF z projektem .NET, używając NuGet do zainstalowania biblioteki, takiej jak IronPDF. Ułatwia to dodanie możliwości PDF do projektu w programie Visual Studio.
Jakie są kroki do stworzenia generatora faktur w formacie PDF za pomocą Windows Forms?
Proces obejmuje utworzenie projektu Windows Forms, zaprojektowanie interfejsu, dodanie wymaganych bibliotek za pomocą NuGet, wdrożenie logiki do wprowadzania danych i generowania faktur oraz użycie IronPDF do konwersji szczegółów faktury na PDF.
Rozpocznij za DARMO
Rozpocznij za DARMO
Zarezerwuj darmowe Demo na żywo
Nie wymaga karty kredytowej ani tworzenia konta
