Ikona wiadomości
Przejdź do treści stopki
  1. IronPDF
  2. Blog IronPDF
  3. Pomoc .NET
  4. csharp-groupby
POMOC .NET

C# Groupby (jak to działa dla programistów)

Jacob Mellor, Dyrektor Technologiczny @ Team Iron
Jacob Mellor
Zaktualizowano:

W języku C# metoda GroupBy jest potężnym narzędziem, które organizuje elementy ze źródła danych w grupy na podstawie określonego klucza. Metoda ta jest częścią LINQ (Language Integrated Query) i może być używana do grupowania elementów według jednej lub wielu właściwości, co czyni ją nieocenioną przy analizie i manipulacji danymi. Metoda GroupBy upraszcza złożone operacje na danych, umożliwiając wydajną organizację i pobieranie danych na podstawie określonych kryteriów. W tym wpisie na blogu omówimy funkcję GroupBy oraz bibliotekę IronPDF.

Podstawy GroupBy

Istota metody GroupBy polega na jej zdolności do kategoryzowania elementów danej kolekcji w grupy zgodnie z określonym kluczem. Ta kluczowa właściwość określa sposób grupowania elementów. Na przykład można pogrupować listę uczniów według wartości klucza wieku, tworząc klastry uczniów w tym samym wieku. Każda grupa jest reprezentowana przez wartość klucza i zbiór elementów, które mają ten sam klucz. Właściwością kluczową może być dowolny obiekt, taki jak ciąg znaków, liczba, a nawet obiekt anonimowy, co zapewnia elastyczność w grupowaniu danych.

Używanie GroupBy ze składnią metody

W języku C# istnieją dwa sposoby zastosowania metody GroupBy: składnia metody i składnia zapytania. Składnia metody wykorzystuje wyrażenia lambda do zdefiniowania klucza grupowania i stanowi bezpośrednie podejście do zastosowania operacji GroupBy.

Rozważmy następujący przykład wykorzystujący składnię metod do pogrupowania listy uczniów według wieku:

using System;
using System.Collections.Generic;
using System.Linq;

public class Student
{
    public string Name { get; set; }
    public int Age { get; set; }
}

public class Program
{
    public static void Main()
    {
        List<Student> studentList = new List<Student>
        {
            new Student { Name = "Alice", Age = 20 },
            new Student { Name = "Bob", Age = 20 },
            new Student { Name = "Charlie", Age = 21 }
        };

        // Group students by their age using GroupBy
        var groupedResult = studentList.GroupBy(student => student.Age);

        foreach (var group in groupedResult)
        {
            Console.WriteLine($"Age Group: {group.Key}");

            foreach (var student in group)
            {
                Console.WriteLine($"Student Name: {student.Name}");
            }
        }
    }
}
using System;
using System.Collections.Generic;
using System.Linq;

public class Student
{
    public string Name { get; set; }
    public int Age { get; set; }
}

public class Program
{
    public static void Main()
    {
        List<Student> studentList = new List<Student>
        {
            new Student { Name = "Alice", Age = 20 },
            new Student { Name = "Bob", Age = 20 },
            new Student { Name = "Charlie", Age = 21 }
        };

        // Group students by their age using GroupBy
        var groupedResult = studentList.GroupBy(student => student.Age);

        foreach (var group in groupedResult)
        {
            Console.WriteLine($"Age Group: {group.Key}");

            foreach (var student in group)
            {
                Console.WriteLine($"Student Name: {student.Name}");
            }
        }
    }
}
Imports System
Imports System.Collections.Generic
Imports System.Linq

Public Class Student
	Public Property Name() As String
	Public Property Age() As Integer
End Class

Public Class Program
	Public Shared Sub Main()
		Dim studentList As New List(Of Student) From {
			New Student With {
				.Name = "Alice",
				.Age = 20
			},
			New Student With {
				.Name = "Bob",
				.Age = 20
			},
			New Student With {
				.Name = "Charlie",
				.Age = 21
			}
		}

		' Group students by their age using GroupBy
		Dim groupedResult = studentList.GroupBy(Function(student) student.Age)

		For Each group In groupedResult
			Console.WriteLine($"Age Group: {group.Key}")

			For Each student In group
				Console.WriteLine($"Student Name: {student.Name}")
			Next student
		Next group
	End Sub
End Class
$vbLabelText   $csharpLabel

C# GroupBy (jak to działa dla programistów): Rysunek 1 — Wynik wyświetlony w konsoli z poprzedniego przykładu kodu

Metoda LINQ GroupBy wykorzystuje wyrażenie lambda do grupowania uczniów według wartości klucza Age. group.Key reprezentuje grupę wiekową, a wewnętrzna pętla foreach iteruje po każdym uczniu w grupie, wypisując ich imiona.

Wykorzystanie funkcji GroupBy w składni zapytań

Składnia zapytań oferuje bardziej wyrazisty sposób wykonywania operacji grupowania, przypominający zapytania typu SQL. Jest to szczególnie przydatne w przypadku złożonych transformacji danych i wielu kryteriów grupowania. Oto jak można osiągnąć podobną funkcjonalność jak w poprzednim przykładzie, używając składni zapytań:

using System;
using System.Collections.Generic;
using System.Linq;

public static class Program
{
    public static void Main()
    {
        List<Student> studentList = new List<Student>
        {
            new Student { Name = "Alice", Age = 20 },
            new Student { Name = "Bob", Age = 20 },
            new Student { Name = "Charlie", Age = 21 }
        };

        // Group students by their age using query syntax
        var groupedResult = from student in studentList
                            group student by student.Age into ageGroup
                            select new { Age = ageGroup.Key, Students = ageGroup };

        foreach (var group in groupedResult)
        {
            Console.WriteLine($"Age Group: {group.Age}");

            foreach (var student in group.Students)
            {
                Console.WriteLine($"Student Name: {student.Name}");
            }
        }
    }
}
using System;
using System.Collections.Generic;
using System.Linq;

public static class Program
{
    public static void Main()
    {
        List<Student> studentList = new List<Student>
        {
            new Student { Name = "Alice", Age = 20 },
            new Student { Name = "Bob", Age = 20 },
            new Student { Name = "Charlie", Age = 21 }
        };

        // Group students by their age using query syntax
        var groupedResult = from student in studentList
                            group student by student.Age into ageGroup
                            select new { Age = ageGroup.Key, Students = ageGroup };

        foreach (var group in groupedResult)
        {
            Console.WriteLine($"Age Group: {group.Age}");

            foreach (var student in group.Students)
            {
                Console.WriteLine($"Student Name: {student.Name}");
            }
        }
    }
}
Imports System
Imports System.Collections.Generic
Imports System.Linq

Public Module Program
	Public Sub Main()
		Dim studentList As New List(Of Student) From {
			New Student With {
				.Name = "Alice",
				.Age = 20
			},
			New Student With {
				.Name = "Bob",
				.Age = 20
			},
			New Student With {
				.Name = "Charlie",
				.Age = 21
			}
		}

		' Group students by their age using query syntax
		Dim groupedResult = From student In studentList
			Group student By student.Age Into ageGroup = Group
			Select New With {
				Key .Age = Age,
				Key .Students = ageGroup
			}

		For Each group In groupedResult
			Console.WriteLine($"Age Group: {group.Age}")

			For Each student In group.Students
				Console.WriteLine($"Student Name: {student.Name}")
			Next student
		Next group
	End Sub
End Module
$vbLabelText   $csharpLabel

W tym fragmencie składnia zapytania grupuje uczniów według wieku, podobnie jak składnia metody, ale z inną składnią, którą niektórzy uważają za bardziej czytelna.

Grupowanie według wielu kluczy i właściwości

Bardziej zaawansowane wykorzystanie metody GroupBy polega na grupowaniu danych według wielu kluczy lub właściwości. Technika ta pozwala na bardziej szczegółową analizę danych i kategoryzację w oparciu o wiele wartości. Korzystając z obiektów anonimowych lub krotek, można grupować elementy na podstawie kombinacji właściwości, zapewniając bogatszą strukturę danych dla aplikacji.

Przykład: Grupowanie uczniów według imienia i wieku

Rozważmy scenariusz, w którym trzeba pogrupować uczniów nie tylko według wartości klucza wieku, ale także według imienia, aby zidentyfikować uczniów o tym samym imieniu i wartości klucza wieku na liście. Można to osiągnąć poprzez grupowanie według typu anonimowego zawierającego zarówno imię, jak i wiek.

using System;
using System.Collections.Generic;
using System.Linq;

public static class Program
{
    public static void Main()
    {
        List<Student> studentList = new List<Student>
        {
            new Student { Name = "Alice", Age = 20 },
            new Student { Name = "Alice", Age = 21 },
            new Student { Name = "Bob", Age = 20 },
            new Student { Name = "Charlie", Age = 21 }
        };

        // Group students by both Name and Age using an anonymous type as the key
        var groupedResult = studentList.GroupBy(student => new { student.Name, student.Age });

        foreach (var group in groupedResult)
        {
            Console.WriteLine($"Group Key: Name = {group.Key.Name}, Age = {group.Key.Age}");

            foreach (var student in group)
            {
                Console.WriteLine($"Student Name: {student.Name}, Age: {student.Age}");
            }
        }
    }
}
using System;
using System.Collections.Generic;
using System.Linq;

public static class Program
{
    public static void Main()
    {
        List<Student> studentList = new List<Student>
        {
            new Student { Name = "Alice", Age = 20 },
            new Student { Name = "Alice", Age = 21 },
            new Student { Name = "Bob", Age = 20 },
            new Student { Name = "Charlie", Age = 21 }
        };

        // Group students by both Name and Age using an anonymous type as the key
        var groupedResult = studentList.GroupBy(student => new { student.Name, student.Age });

        foreach (var group in groupedResult)
        {
            Console.WriteLine($"Group Key: Name = {group.Key.Name}, Age = {group.Key.Age}");

            foreach (var student in group)
            {
                Console.WriteLine($"Student Name: {student.Name}, Age: {student.Age}");
            }
        }
    }
}
Imports System
Imports System.Collections.Generic
Imports System.Linq

Public Module Program
	Public Sub Main()
		Dim studentList As New List(Of Student) From {
			New Student With {
				.Name = "Alice",
				.Age = 20
			},
			New Student With {
				.Name = "Alice",
				.Age = 21
			},
			New Student With {
				.Name = "Bob",
				.Age = 20
			},
			New Student With {
				.Name = "Charlie",
				.Age = 21
			}
		}

		' Group students by both Name and Age using an anonymous type as the key
		Dim groupedResult = studentList.GroupBy(Function(student) New With {
			Key student.Name,
			Key student.Age
		})

		For Each group In groupedResult
			Console.WriteLine($"Group Key: Name = {group.Key.Name}, Age = {group.Key.Age}")

			For Each student In group
				Console.WriteLine($"Student Name: {student.Name}, Age: {student.Age}")
			Next student
		Next group
	End Sub
End Module
$vbLabelText   $csharpLabel

W tym przykładzie uczniowie są pogrupowani według imienia i wieku przy użyciu typu anonimowego jako klucza. W rezultacie powstają grupy, w których każda unikalna kombinacja imienia i wieku jest reprezentowana jako oddzielna grupa, co pokazuje elastyczność funkcji GroupBy w złożonych scenariuszach grupowania.

Dodatkowe informacje o GroupBy

Zaawansowane wykorzystanie funkcji GroupBy

Funkcja GroupBy staje się jeszcze bardziej potężna, gdy trzeba grupować według wielu wartości klucza lub gdy chcesz wykonać dodatkowe operacje na zgrupowanych danych, takie jak liczenie, filtrowanie czy sortowanie. Można to osiągnąć, łącząc metodę GroupBy z innymi metodami LINQ lub używając typów anonimowych do grupowania według wielu właściwości.

Wykonanie odroczone w GroupBy

Należy pamiętać, że GroupBy wykorzystuje odroczone wykonywanie, przetwarzając elementy podczas iteracji według danego klucza. Oznacza to, że operacja grupowania nie jest wykonywana natychmiast po wywołaniu metody GroupBy. Zamiast tego wykonanie jest odkładane do momentu iteracji nad zgrupowanymi danymi, na przykład w pętli foreach. Takie zachowanie jest wydajne, ponieważ pozwala na dalszą optymalizację zapytań i modyfikacje przed ostatecznym przetworzeniem danych.

Wprowadzenie IronPDF do projektów C

C# GroupBy (jak to działa dla programistów): Rysunek 2 – strona internetowa IronPDF

IronPDF to kompleksowa biblioteka dla języka C#, która umożliwia programistom tworzenie, edycję i konwersję dokumentów PDF w aplikacjach .NET. To potężne narzędzie oferuje szeroki zakres funkcji, od generowania plików PDF z HTML po edycję istniejących plików PDF i wiele więcej. IronPDF ułatwia integrację funkcji PDF z aplikacjami, co czyni go cennym narzędziem w każdym projekcie wymagającym pracy z plikami PDF.

Kluczową funkcją IronPDF jest konwersja HTML do PDF, zapewniająca zachowanie układów i stylów. Generuje pliki PDF na podstawie treści internetowych, dzięki czemu świetnie nadaje się do tworzenia raportów, faktur i dokumentacji. Pliki HTML, adresy URL i ciągi znaków HTML można płynnie konwertować do formatu PDF.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}
using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}
Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		' Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class
$vbLabelText   $csharpLabel

Generowanie raportów PDF na podstawie zgrupowanych danych

Rozszerzmy nasze poprzednie przykłady grupowania uczniów według klucza wieku. Po podziale uczniów na grupy użyjemy IronPDF do wygenerowania raportu w formacie PDF, zawierającego listę tych grup wraz z nazwiskami uczniów w każdej z nich.

using IronPdf;
using System;
using System.Collections.Generic;
using System.Linq;

public class Student
{
    public string Name { get; set; }
    public int Age { get; set; }
}

public class Program
{
    public static void Main()
    {
        // Initialize IronPDF license if applicable
        IronPdf.License.LicenseKey = "License";

        List<Student> studentList = new List<Student>
        {
            new Student { Name = "Alice", Age = 20 },
            new Student { Name = "Bob", Age = 20 },
            new Student { Name = "Charlie", Age = 21 },
            new Student { Name = "David", Age = 21 }
        };

        // Group students by their age
        var groupedResult = studentList.GroupBy(student => student.Age);

        // Create HTML content for the PDF report
        var htmlContent = "<h1>Student Report</h1>";

        foreach (var group in groupedResult)
        {
            htmlContent += $"<h2>Age Group: {group.Key}</h2><ul>";

            foreach (var student in group)
            {
                htmlContent += $"<li>{student.Name}</li>";
            }

            htmlContent += "</ul>";
        }

        // Initialize IronPDF renderer and generate PDF
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);

        // Specify path to save the PDF file
        var outputPath = "StudentReport.pdf";
        pdf.SaveAs(outputPath);

        Console.WriteLine($"PDF report generated at {outputPath}");
    }
}
using IronPdf;
using System;
using System.Collections.Generic;
using System.Linq;

public class Student
{
    public string Name { get; set; }
    public int Age { get; set; }
}

public class Program
{
    public static void Main()
    {
        // Initialize IronPDF license if applicable
        IronPdf.License.LicenseKey = "License";

        List<Student> studentList = new List<Student>
        {
            new Student { Name = "Alice", Age = 20 },
            new Student { Name = "Bob", Age = 20 },
            new Student { Name = "Charlie", Age = 21 },
            new Student { Name = "David", Age = 21 }
        };

        // Group students by their age
        var groupedResult = studentList.GroupBy(student => student.Age);

        // Create HTML content for the PDF report
        var htmlContent = "<h1>Student Report</h1>";

        foreach (var group in groupedResult)
        {
            htmlContent += $"<h2>Age Group: {group.Key}</h2><ul>";

            foreach (var student in group)
            {
                htmlContent += $"<li>{student.Name}</li>";
            }

            htmlContent += "</ul>";
        }

        // Initialize IronPDF renderer and generate PDF
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);

        // Specify path to save the PDF file
        var outputPath = "StudentReport.pdf";
        pdf.SaveAs(outputPath);

        Console.WriteLine($"PDF report generated at {outputPath}");
    }
}
Imports IronPdf
Imports System
Imports System.Collections.Generic
Imports System.Linq

Public Class Student
	Public Property Name() As String
	Public Property Age() As Integer
End Class

Public Class Program
	Public Shared Sub Main()
		' Initialize IronPDF license if applicable
		IronPdf.License.LicenseKey = "License"

		Dim studentList As New List(Of Student) From {
			New Student With {
				.Name = "Alice",
				.Age = 20
			},
			New Student With {
				.Name = "Bob",
				.Age = 20
			},
			New Student With {
				.Name = "Charlie",
				.Age = 21
			},
			New Student With {
				.Name = "David",
				.Age = 21
			}
		}

		' Group students by their age
		Dim groupedResult = studentList.GroupBy(Function(student) student.Age)

		' Create HTML content for the PDF report
		Dim htmlContent = "<h1>Student Report</h1>"

		For Each group In groupedResult
			htmlContent &= $"<h2>Age Group: {group.Key}</h2><ul>"

			For Each student In group
				htmlContent &= $"<li>{student.Name}</li>"
			Next student

			htmlContent &= "</ul>"
		Next group

		' Initialize IronPDF renderer and generate PDF
		Dim renderer = New ChromePdfRenderer()
		Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)

		' Specify path to save the PDF file
		Dim outputPath = "StudentReport.pdf"
		pdf.SaveAs(outputPath)

		Console.WriteLine($"PDF report generated at {outputPath}")
	End Sub
End Class
$vbLabelText   $csharpLabel

W tym przykładzie najpierw grupujemy uczniów według wieku za pomocą metody GroupBy. Następnie tworzymy ciąg znaków HTML, który zwraca ta metoda, formatujący te zgrupowane dane w raport, z nagłówkami dla każdej grupy wiekowej i listami nazwisk uczniów w każdej grupie. Następnie używamy klasy ChromePdfRenderer biblioteki IronPDF do konwersji tego ciągu znaków HTML na dokument PDF. Powstały plik PDF jest zapisywany, zapewniając przejrzysty raport z podziałem uczniów według wieku.

Wynik

Oto plik PDF wygenerowany przez IronPDF:

C# GroupBy (jak to działa dla programistów): Rysunek 3 – Plik PDF wygenerowany na podstawie poprzedniego przykładu kodu

Wnioski

C# GroupBy (jak to działa dla programistów): Rysunek 4 – Plan licencyjny IronPDF

Metoda GroupBy w języku C# jest wszechstronnym i potężnym narzędziem do grupowania danych na podstawie określonych kluczy. Niezależnie od tego, czy preferujesz składnię metod z wyrażeniami lambda, czy bardziej deklaratywną składnię zapytań, GroupBy umożliwia organizowanie złożonych struktur danych w sposób przejrzysty i czytelny. Opanowując metodę GroupBy i inne metody LINQ, możesz znacznie zwiększyć swoje możliwości manipulowania danymi i analizowania ich w aplikacjach napisanych w języku C#.

IronPDF oferuje bezpłatną wersję próbną dla osób, które chcą zapoznać się z jego funkcjami przed podjęciem decyzji o zakupie. Dla tych, którzy są gotowi zintegrować to narzędzie ze swoimi projektami, licencja zaczyna się od $799, co czyni je opłacalną inwestycją w profesjonalną obsługę i generowanie plików PDF w aplikacjach C#.

Często Zadawane Pytania

Czym jest metoda GroupBy w języku C#?

W języku C# metoda GroupBy jest funkcją LINQ, która organizuje elementy ze źródła danych w grupy na podstawie określonego klucza, upraszczając analizę i manipulację danymi.

Jak działa metoda GroupBy w kontekście składni metod w języku C#?

Korzystając ze składni metody z wyrażeniami lambda, metoda GroupBy grupuje elementy według określonego klucza. Na przykład można pogrupować listę uczniów według wieku, tworząc klastry uczniów w podobnym wieku.

Czy można używać składni zapytań z metodą GroupBy?

Tak, składnia zapytań może być używana z metodą GroupBy, zapewniając bardziej zbliżony do języka SQL i wyrazisty sposób wykonywania operacji grupowania, zwłaszcza w przypadku złożonych transformacji danych.

Jak można grupować dane według wielu kluczy za pomocą funkcji GroupBy?

Można grupować dane według wielu kluczy, używając obiektów anonimowych lub krotek, co pozwala na bardziej szczegółową analizę danych w oparciu o kombinacje właściwości.

Czym jest odroczone wykonanie w kontekście GroupBy?

Wykonanie odroczone oznacza, że operacja GroupBy nie jest wykonywana natychmiast po wywołaniu. Jest ona przetwarzana podczas iteracji nad zgrupowanymi danymi, co pozwala na optymalizację zapytań.

Jak wygenerować raporty PDF ze zgrupowanych danych przy użyciu języka C#?

Za pomocą IronPDF można konwertować ciągi HTML, które formatują zgrupowane dane w raporty, na dokumenty PDF. Umożliwia to łatwe generowanie starannie sformatowanych raportów PDF na podstawie danych zgrupowanych za pomocą GroupBy.

Jakie są zaawansowane techniki grupowania w języku C#?

Zaawansowane techniki grupowania w języku C# obejmują wykorzystanie obiektów anonimowych lub krotek do grupowania danych według wielu kluczy lub właściwości, co zwiększa możliwości przeprowadzania złożonych analiz danych.

W jaki sposób IronPDF może pomóc w profesjonalnym zarządzaniu plikami PDF w aplikacjach .NET?

IronPDF zapewnia programistom C# narzędzia do tworzenia i edycji dokumentów PDF, w tym generowania raportów PDF na podstawie treści HTML. Pomaga to w efektywnym zarządzaniu profesjonalnymi plikami PDF w aplikacjach .NET.

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

Jacob Mellor, Dyrektor Technologiczny @ Team Iron
Jacob Mellor
  Czat z zespołem inżynierów teraz
Dyrektor ds. technologii

Jacob Mellor jest Chief Technology Officer w Iron Software i wizjonerskim inżynierem, pionierem technologii C# PDF. Jako pierwotny deweloper głównej bazy kodowej Iron Software, kształtuje architekturę produktów firmy od jej początku, przekształcając ją wspólnie z CEO Cameron Rimington w firmę liczą...

Czytaj więcej

Powiązane artykuły

30-dniowy okres próbny → Pełna wersja produktu. Bez ograniczeń. Bez karty. Bezpłatna próba

Zespol wsparcia Iron

Jestesmy online 24 godziny, 5 dni w tygodniu.
Czat
Email
Zadzwon do mnie