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

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

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

Language-integrated query (LINQ), potężna funkcja języka C#, umożliwia programistom tworzenie przejrzystych, wyrazistych zapytań dla różnych źródeł danych. W tym poście omówimy wykorzystanie IronPDF, wszechstronnej biblioteki C# do pracy z dokumentami PDF, przy użyciu funkcji Distinct języka LINQ. Pokażemy, w jaki sposób to połączenie może ułatwić proces tworzenia unikalnych dokumentów na podstawie zbioru danych. W tym artykule zapoznamy się z funkcją distinct języka C# LINQ w połączeniu z IronPDF.

Jak korzystać z metody Distinct w C# LINQ

  1. Utwórz nowy projekt konsoli.
  2. Zaimportuj przestrzeń nazw System.Linq.
  3. Utwórz listę zawierającą wiele pozycji.
  4. Wywołaj metodę Distinct() z listy.
  5. Pobierz unikalne wartości i wyświetl wynik w konsoli.
  6. Usuń wszystkie utworzone obiekty.

Czym jest LINQ

Programiści mogą tworzyć jasne i wyraziste zapytania do manipulacji danymi bezpośrednio w swoim kodzie dzięki funkcji LINQ (Language Integrated Query) języka C#. Wprowadzony po raz pierwszy w .NET Framework 3.5, LINQ oferuje standardową składnię do wysyłania zapytań do różnych źródeł danych, w tym baz danych i kolekcji. LINQ ułatwia proste zadania, takie jak filtrowanie i projekcja, za pomocą operatorów takich jak Where i Select, co poprawia czytelność kodu. Ponieważ funkcja ta pozwala na opóźnione wykonanie w celu uzyskania optymalnej szybkości, jest ona kluczowa dla programistów C#, aby zapewnić szybkie i naturalne wykonywanie operacji na danych w sposób analogiczny do SQL.

Zrozumienie LINQ Distinct

Zbędne elementy można usunąć z kolekcji lub sekwencji za pomocą funkcji LINQ Distinct. W przypadku braku niestandardowego komparatora równości porównuje elementy przy użyciu ich domyślnego komparatora. To sprawia, że jest to świetna opcja w sytuacjach, gdy trzeba pracować z unikalną kolekcją i usuwać zduplikówane elementy. Technika Distinct wykorzystuje domyślne komparatory równości do oceny wartości. Wykluczy on duplikaty, aby zwrócić tylko unikalne elementy.

Podstawowe zastosowanie

Aby uzyskać odrębne elementy, najprostszym sposobem jest użycie metody Distinct bezpośrednio na kolekcji.

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

public class DistinctExample
{
    public static void Example()
    {
        // Example list with duplicate integers
        List<int> numbers = new List<int> { 1, 2, 2, 3, 4, 4, 5 };

        // Using Distinct to remove duplicates
        var distinctNumbers = numbers.Distinct();

        // Display the distinct numbers
        foreach (var number in distinctNumbers)
        {
            Console.WriteLine(number);
        }
    }
}
using System.Linq;
using System.Collections.Generic;

public class DistinctExample
{
    public static void Example()
    {
        // Example list with duplicate integers
        List<int> numbers = new List<int> { 1, 2, 2, 3, 4, 4, 5 };

        // Using Distinct to remove duplicates
        var distinctNumbers = numbers.Distinct();

        // Display the distinct numbers
        foreach (var number in distinctNumbers)
        {
            Console.WriteLine(number);
        }
    }
}
Imports System.Linq
Imports System.Collections.Generic

Public Class DistinctExample
	Public Shared Sub Example()
		' Example list with duplicate integers
		Dim numbers As New List(Of Integer) From {1, 2, 2, 3, 4, 4, 5}

		' Using Distinct to remove duplicates
		Dim distinctNumbers = numbers.Distinct()

		' Display the distinct numbers
		For Each number In distinctNumbers
			Console.WriteLine(number)
		Next number
	End Sub
End Class
$vbLabelText   $csharpLabel

Niestandardowy komparator równości

Można zdefiniować niestandardowe porównanie równości, używając przeciążenia funkcji Distinct. Jest to pomocne, jeśli chcesz porównać elementy według określonych standardów. Proszę zapoznać się z poniższym przykładem:

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

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

public class PersonEqualityComparer : IEqualityComparer<Person>
{
    public bool Equals(Person x, Person y)
    {
        return x.FirstName == y.FirstName && x.LastName == y.LastName;
    }

    public int GetHashCode(Person obj)
    {
        return obj.FirstName.GetHashCode() ^ obj.LastName.GetHashCode();
    }
}

public class DistinctCustomComparerExample
{
    public static void Example()
    {
        // Example list of people
        List<Person> people = new List<Person>
        {
            new Person { FirstName = "John", LastName = "Doe" },
            new Person { FirstName = "Jane", LastName = "Doe" },
            new Person { FirstName = "John", LastName = "Doe" }
        };

        // Using Distinct with a custom equality comparer
        var distinctPeople = people.Distinct(new PersonEqualityComparer());

        // Display distinct people
        foreach (var person in distinctPeople)
        {
            Console.WriteLine($"{person.FirstName} {person.LastName}");
        }
    }
}
using System;
using System.Collections.Generic;
using System.Linq;

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

public class PersonEqualityComparer : IEqualityComparer<Person>
{
    public bool Equals(Person x, Person y)
    {
        return x.FirstName == y.FirstName && x.LastName == y.LastName;
    }

    public int GetHashCode(Person obj)
    {
        return obj.FirstName.GetHashCode() ^ obj.LastName.GetHashCode();
    }
}

public class DistinctCustomComparerExample
{
    public static void Example()
    {
        // Example list of people
        List<Person> people = new List<Person>
        {
            new Person { FirstName = "John", LastName = "Doe" },
            new Person { FirstName = "Jane", LastName = "Doe" },
            new Person { FirstName = "John", LastName = "Doe" }
        };

        // Using Distinct with a custom equality comparer
        var distinctPeople = people.Distinct(new PersonEqualityComparer());

        // Display distinct people
        foreach (var person in distinctPeople)
        {
            Console.WriteLine($"{person.FirstName} {person.LastName}");
        }
    }
}
Imports System
Imports System.Collections.Generic
Imports System.Linq

Public Class Person
	Public Property FirstName() As String
	Public Property LastName() As String
End Class

Public Class PersonEqualityComparer
	Implements IEqualityComparer(Of Person)

	Public Function Equals(ByVal x As Person, ByVal y As Person) As Boolean Implements IEqualityComparer(Of Person).Equals
		Return x.FirstName = y.FirstName AndAlso x.LastName = y.LastName
	End Function

	Public Function GetHashCode(ByVal obj As Person) As Integer Implements IEqualityComparer(Of Person).GetHashCode
		Return obj.FirstName.GetHashCode() Xor obj.LastName.GetHashCode()
	End Function
End Class

Public Class DistinctCustomComparerExample
	Public Shared Sub Example()
		' Example list of people
		Dim people As New List(Of Person) From {
			New Person With {
				.FirstName = "John",
				.LastName = "Doe"
			},
			New Person With {
				.FirstName = "Jane",
				.LastName = "Doe"
			},
			New Person With {
				.FirstName = "John",
				.LastName = "Doe"
			}
		}

		' Using Distinct with a custom equality comparer
		Dim distinctPeople = people.Distinct(New PersonEqualityComparer())

		' Display distinct people
		For Each person In distinctPeople
			Console.WriteLine($"{person.FirstName} {person.LastName}")
		Next person
	End Sub
End Class
$vbLabelText   $csharpLabel

Używanie Distinct z typami wartości

Nie ma potrzeby podawania niestandardowego porównania równości podczas korzystania z metody Distinct w przypadku typów wartości.

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

public class DistinctValueTypeExample
{
    public static void Example()
    {
        List<int> integers = new List<int> { 1, 2, 2, 3, 4, 4, 5 };

        // Using Distinct to remove duplicates
        var distinctIntegers = integers.Distinct();

        // Display distinct integers
        foreach (var integer in distinctIntegers)
        {
            Console.WriteLine(integer);
        }
    }
}
using System;
using System.Collections.Generic;
using System.Linq;

public class DistinctValueTypeExample
{
    public static void Example()
    {
        List<int> integers = new List<int> { 1, 2, 2, 3, 4, 4, 5 };

        // Using Distinct to remove duplicates
        var distinctIntegers = integers.Distinct();

        // Display distinct integers
        foreach (var integer in distinctIntegers)
        {
            Console.WriteLine(integer);
        }
    }
}
Imports System
Imports System.Collections.Generic
Imports System.Linq

Public Class DistinctValueTypeExample
	Public Shared Sub Example()
		Dim integers As New List(Of Integer) From {1, 2, 2, 3, 4, 4, 5}

		' Using Distinct to remove duplicates
		Dim distinctIntegers = integers.Distinct()

		' Display distinct integers
		For Each [integer] In distinctIntegers
			Console.WriteLine([integer])
		Next [integer]
	End Sub
End Class
$vbLabelText   $csharpLabel

Używanie Distinct z typami anonimowymi

Distinct może być używane z typami anonimowymi w celu usunięcia duplikatów na podstawie określonych atrybutów. Proszę zapoznać się z poniższym przykładem:

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

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

public class DistinctAnonymousTypesExample
{
    public static void Example()
    {
        List<Person> people = new List<Person>
        {
            new Person { FirstName = "John", LastName = "Doe" },
            new Person { FirstName = "Jane", LastName = "Doe" },
            new Person { FirstName = "John", LastName = "Doe" }
        };

        // Using Distinct with anonymous types
        var distinctPeople = people
            .Select(p => new { p.FirstName, p.LastName })
            .Distinct();

        // Display distinct anonymous types
        foreach (var person in distinctPeople)
        {
            Console.WriteLine($"{person.FirstName} {person.LastName}");
        }
    }
}
using System;
using System.Collections.Generic;
using System.Linq;

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

public class DistinctAnonymousTypesExample
{
    public static void Example()
    {
        List<Person> people = new List<Person>
        {
            new Person { FirstName = "John", LastName = "Doe" },
            new Person { FirstName = "Jane", LastName = "Doe" },
            new Person { FirstName = "John", LastName = "Doe" }
        };

        // Using Distinct with anonymous types
        var distinctPeople = people
            .Select(p => new { p.FirstName, p.LastName })
            .Distinct();

        // Display distinct anonymous types
        foreach (var person in distinctPeople)
        {
            Console.WriteLine($"{person.FirstName} {person.LastName}");
        }
    }
}
Imports System
Imports System.Collections.Generic
Imports System.Linq

Public Class Person
	Public Property FirstName() As String
	Public Property LastName() As String
End Class

Public Class DistinctAnonymousTypesExample
	Public Shared Sub Example()
		Dim people As New List(Of Person) From {
			New Person With {
				.FirstName = "John",
				.LastName = "Doe"
			},
			New Person With {
				.FirstName = "Jane",
				.LastName = "Doe"
			},
			New Person With {
				.FirstName = "John",
				.LastName = "Doe"
			}
		}

		' Using Distinct with anonymous types
		Dim distinctPeople = people.Select(Function(p) New With {
			Key p.FirstName,
			Key p.LastName
		}).Distinct()

		' Display distinct anonymous types
		For Each person In distinctPeople
			Console.WriteLine($"{person.FirstName} {person.LastName}")
		Next person
	End Sub
End Class
$vbLabelText   $csharpLabel

Wyróżnia się określoną właściwością

Podczas pracy z obiektami można albo stworzyć własną logikę rozróżniania według określonego atrybutu, albo skorzystać z metody rozszerzenia DistinctBy z bibliotek innych firm (takich jak MoreLINQ).

// Ensure to include the MoreLINQ Library
using MoreLinq;
using System;
using System.Collections.Generic;
using System.Linq;

public class Person
{
    public int Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

public class DistinctByExample
{
    public static void Example()
    {
        List<Person> people = new List<Person>
        {
            new Person { Id = 1, FirstName = "John", LastName = "Doe" },
            new Person { Id = 2, FirstName = "Jane", LastName = "Doe" },
            new Person { Id = 1, FirstName = "John", LastName = "Doe" }
        };

        // Using DistinctBy to filter distinct people by Id
        var distinctPeople = people.DistinctBy(p => p.Id);

        // Display distinct people
        foreach (var person in distinctPeople)
        {
            Console.WriteLine($"{person.Id}: {person.FirstName} {person.LastName}");
        }
    }
}
// Ensure to include the MoreLINQ Library
using MoreLinq;
using System;
using System.Collections.Generic;
using System.Linq;

public class Person
{
    public int Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

public class DistinctByExample
{
    public static void Example()
    {
        List<Person> people = new List<Person>
        {
            new Person { Id = 1, FirstName = "John", LastName = "Doe" },
            new Person { Id = 2, FirstName = "Jane", LastName = "Doe" },
            new Person { Id = 1, FirstName = "John", LastName = "Doe" }
        };

        // Using DistinctBy to filter distinct people by Id
        var distinctPeople = people.DistinctBy(p => p.Id);

        // Display distinct people
        foreach (var person in distinctPeople)
        {
            Console.WriteLine($"{person.Id}: {person.FirstName} {person.LastName}");
        }
    }
}
' Ensure to include the MoreLINQ Library
Imports MoreLinq
Imports System
Imports System.Collections.Generic
Imports System.Linq

Public Class Person
	Public Property Id() As Integer
	Public Property FirstName() As String
	Public Property LastName() As String
End Class

Public Class DistinctByExample
	Public Shared Sub Example()
		Dim people As New List(Of Person) From {
			New Person With {
				.Id = 1,
				.FirstName = "John",
				.LastName = "Doe"
			},
			New Person With {
				.Id = 2,
				.FirstName = "Jane",
				.LastName = "Doe"
			},
			New Person With {
				.Id = 1,
				.FirstName = "John",
				.LastName = "Doe"
			}
		}

		' Using DistinctBy to filter distinct people by Id
		Dim distinctPeople = people.DistinctBy(Function(p) p.Id)

		' Display distinct people
		For Each person In distinctPeople
			Console.WriteLine($"{person.Id}: {person.FirstName} {person.LastName}")
		Next person
	End Sub
End Class
$vbLabelText   $csharpLabel

IronPDF

Programiści mogą tworzyć, edytować i modyfikować dokumenty PDF przy użyciu języka C# z pomocą biblioteki .NET IronPDF Website. Program oferuje szereg narzędzi i funkcji umożliwiających wykonywanie różnych zadań związanych z plikami PDF, takich jak generowanie plików PDF z HTML, konwersja HTML do PDF, łączenie lub dzielenie dokumentów PDF oraz dodawanie tekstu, obrazów i adnotacji do już istniejących plików PDF. Aby dowiedzieć się więcej o IronPDF, zapoznaj się z dokumentacją IronPDF.

Główną funkcją IronPDF jest konwersja HTML do PDF, która zachowuje układ i style dokumentu. Możesz generować pliki PDF z treści internetowych, idealne do raportów, faktur i dokumentacji. Obsługuje konwersję plików HTML, adresów URL i ciągów znaków HTML do plików PDF.

using IronPdf;

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

        // 1. 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");

        // 2. 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");

        // 3. 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();

        // 1. 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");

        // 2. 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");

        // 3. 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()

		' 1. 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")

		' 2. 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")

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

Funkcje IronPDF

  • Konwersja HTML do PDF: Możesz użyć IronPDF do konwersji dowolnego rodzaju danych HTML — w tym plików, adresów URL i ciągów kodu HTML — na dokumenty PDF.
  • Generowanie plików PDF: Tekst, obrazy i inne elementy można programowo dodawać do dokumentów PDF przy użyciu języka programowania C#.
  • Manipulacja plikami PDF: IronPDF może dzielić plik PDF na wiele plików, łączyć kilka dokumentów PDF w jeden plik oraz edytować istniejące pliki PDF.
  • Formularze PDF: Biblioteka umożliwia użytkownikom tworzenie i wypełnianie formularzy PDF, co sprawia, że jest przydatna w sytuacjach, w których konieczne jest gromadzenie i przetwarzanie danych z formularzy.
  • Funkcje bezpieczeństwa: IronPDF może służyć do szyfrowania dokumentów PDF oraz zapewniania ochrony hasłem i uprawnieniami.
  • Wyodrębnianie tekstu: Tekst z plików PDF można wyodrębnić za pomocą IronPDF.

Zainstaluj IronPDF

Pobierz bibliotekę IronPDF; jest to niezbędne do skonfigurowania projektu. Aby to zrobić, wprowadź następujący kod do konsoli menedżera pakietów NuGet:

Install-Package IronPdf

C# LINQ Distinct (How It Works For Developers): Figure 1 - To install the IronPDF library using the NuGet Package Manager Console, enter the following command: Install IronPDF or dotnet add package IronPdf

Dodatkową opcją jest użycie menedżera pakietów NuGet do wyszukania pakietu "IronPDF". Z listy wszystkich pakietów NuGet powiązanych z IronPDF możemy wybrać i pobrać potrzebny pakiet.

C# LINQ Distinct (How It Works For Developers): Figure 2 - To install the IronPDF library using the NuGet Package Manager, search for the package IronPDF in the Browse tab and choose the latest version of IronPDF package to download and install in your project.

LINQ z IronPDF

Rozważmy sytuację, w której dysponujemy zbiorem danych i chcemy utworzyć różne dokumenty PDF zgodnie z różnymi wartościami w tym zbiorze. Właśnie w tym miejscu ujawnia się przydatność LINQ Distinct, szczególnie w połączeniu z IronPDF do szybkiego tworzenia dokumentów.

Generowanie odrębnych plików PDF za pomocą LINQ i IronPDF

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

public class DocumentGenerator
{
    public static void Main()
    {
        // Sample data representing categories
        List<string> categories = new List<string>
        {
            "Technology",
            "Business",
            "Health",
            "Technology",
            "Science",
            "Business",
            "Health"
        };

        // Use LINQ Distinct to filter out duplicate values
        var distinctCategories = categories.Distinct();

        // Generate a distinct elements PDF document for each category
        foreach (var category in distinctCategories)
        {
            GeneratePdfDocument(category);
        }
    }

    private static void GeneratePdfDocument(string category)
    {
        // Create a new PDF document using IronPDF
        IronPdf.HtmlToPdf renderer = new IronPdf.HtmlToPdf();
        PdfDocument pdf = renderer.RenderHtmlAsPdf($"<h1>{category} Report</h1>");

        // Save the PDF to a file
        string pdfFilePath = $"{category}_Report.pdf";
        pdf.SaveAs(pdfFilePath);

        // Display a message with the file path
        Console.WriteLine($"PDF generated successfully. File saved at: {pdfFilePath}");
    }
}
using IronPdf;
using System;
using System.Collections.Generic;
using System.Linq;

public class DocumentGenerator
{
    public static void Main()
    {
        // Sample data representing categories
        List<string> categories = new List<string>
        {
            "Technology",
            "Business",
            "Health",
            "Technology",
            "Science",
            "Business",
            "Health"
        };

        // Use LINQ Distinct to filter out duplicate values
        var distinctCategories = categories.Distinct();

        // Generate a distinct elements PDF document for each category
        foreach (var category in distinctCategories)
        {
            GeneratePdfDocument(category);
        }
    }

    private static void GeneratePdfDocument(string category)
    {
        // Create a new PDF document using IronPDF
        IronPdf.HtmlToPdf renderer = new IronPdf.HtmlToPdf();
        PdfDocument pdf = renderer.RenderHtmlAsPdf($"<h1>{category} Report</h1>");

        // Save the PDF to a file
        string pdfFilePath = $"{category}_Report.pdf";
        pdf.SaveAs(pdfFilePath);

        // Display a message with the file path
        Console.WriteLine($"PDF generated successfully. File saved at: {pdfFilePath}");
    }
}
Imports IronPdf
Imports System
Imports System.Collections.Generic
Imports System.Linq

Public Class DocumentGenerator
	Public Shared Sub Main()
		' Sample data representing categories
		Dim categories As New List(Of String) From {"Technology", "Business", "Health", "Technology", "Science", "Business", "Health"}

		' Use LINQ Distinct to filter out duplicate values
		Dim distinctCategories = categories.Distinct()

		' Generate a distinct elements PDF document for each category
		For Each category In distinctCategories
			GeneratePdfDocument(category)
		Next category
	End Sub

	Private Shared Sub GeneratePdfDocument(ByVal category As String)
		' Create a new PDF document using IronPDF
		Dim renderer As New IronPdf.HtmlToPdf()
		Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf($"<h1>{category} Report</h1>")

		' Save the PDF to a file
		Dim pdfFilePath As String = $"{category}_Report.pdf"
		pdf.SaveAs(pdfFilePath)

		' Display a message with the file path
		Console.WriteLine($"PDF generated successfully. File saved at: {pdfFilePath}")
	End Sub
End Class
$vbLabelText   $csharpLabel

W tym przykładzie szereg odrębnych kategorii uzyskuje się za pomocą metody Distinct dla kolekcji kategorii. Pomaga to usunąć z sekwencji powtarzające się elementy. Następnie za pomocą IronPDF tworzy się dokument PDF zawierający te unikalne elementy. Ta metoda gwarantuje, że oddzielne dokumenty PDF są tworzone wyłącznie dla unikalnych kategorii.

Wynik na konsoli

C# LINQ Distinct (jak to działa dla programistów): Rysunek 3 – Wynik na konsoli

Wygenerowany plik PDF

C# LINQ Distinct (jak to działa dla programistów): Rysunek 4 – Plik PDF: Raport technologiczny

Aby dowiedzieć się więcej o przykładowym kodzie IronPDF służącym do generowania plików PDF przy użyciu HTML, zapoznaj się z przykładowym kodem IronPDF HTML do PDF.

Wnioski

Metoda rozszerzenia Distinct w LINQ w połączeniu z IronPDF oferuje solidny i wydajny mechanizm tworzenia unikalnych dokumentów PDF na podstawie wartości. Ta metoda usprawnia kod i gwarantuje efektywne tworzenie dokumentów, niezależnie od tego, czy pracujesz z kategoriami, tagami czy innymi danymi, które wymagają oddzielnych dokumentów.

Wykorzystując LINQ do przetwarzania danych oraz IronPDF do tworzenia dokumentów, można opracować niezawodne i elastyczne rozwiązanie do zarządzania różnymi aspektami aplikacji napisanych w języku C#. Korzystając z tych strategii w swoich projektach, należy pamiętać o szczególnych potrzebach aplikacji i dostosować wdrożenie tak, aby osiągnąć maksymalną niezawodność i wydajność.

Często Zadawane Pytania

Jak mogę usunąć zduplikówane wpisy z kolekcji w języku C#?

Możesz użyć metody Distinct w LINQ, aby usunąć zduplikówane wpisy z kolekcji w języku C#. Metoda ta jest szczególnie przydatna w połączeniu z IronPDF do generowania unikalnych dokumentów PDF z odrębnych kategorii danych.

Jak przekonwertować HTML na PDF w języku C#?

Aby przekonwertować HTML na PDF w języku C#, można użyć metody RenderHtmlAsPdf biblioteki IronPDF. Pozwala to na wydajną konwersję ciągów znaków lub plików HTML na dokumenty PDF.

Czy mogę używać metody Distinct w LINQ z obiektami niestandardowymi?

Tak, można używać metody Distinct w LINQ z obiektami niestandardowymi, podając niestandardowy komparator równości. Jest to przydatne, gdy trzeba zdefiniować konkretne kryteria określania unikalności w procesie generowania plików PDF za pomocą IronPDF.

Jakie są zalety korzystania z LINQ w połączeniu z IronPDF?

Wykorzystanie LINQ wraz z IronPDF pozwala programistom tworzyć unikalne i wydajne dokumenty PDF w oparciu o przetwarzanie danych. Zwiększa to czytelność kodu i wydajność, zwłaszcza podczas zarządzania zadaniami generowania dokumentów na dużą skalę.

W jaki sposób metoda Distinct w LINQ może usprawnić tworzenie dokumentów PDF?

Metoda Distinct w LINQ może usprawnić tworzenie dokumentów PDF, zapewniając, że w ostatecznym wyniku znajdą się tylko unikalne wpisy. Metodę tę można wykorzystać w połączeniu z IronPDF do generowania odrębnych dokumentów PDF dla różnych kategorii danych.

Czy podczas korzystania z IronPDF można dostosować wygląd pliku PDF?

Tak, IronPDF oferuje różne opcje dostosowywania plików PDF, w tym ustawianie rozmiarów stron, marginesów oraz dodawanie nagłówków i stopek. Te opcje można połączyć z LINQ, aby tworzyć unikalne, dostosowane do potrzeb dokumenty.

W jakich sytuacjach warto użyć metody Distinct w LINQ przy pracy z plikami PDF?

W scenariuszach takich jak generowanie raportów, faktur lub dowolnych dokumentów wymagających unikalności danych z zestawu danych warto skorzystać z metody Distinct biblioteki LINQ w połączeniu z plikami PDF. IronPDF pozwala efektywnie tworzyć przejrzyste i unikalne pliki PDF.

W jaki sposób LINQ poprawia wydajność aplikacji PDF opartych na danych?

LINQ poprawia wydajność aplikacji PDF opartych na danych, umożliwiając programistom filtrowanie i manipulowanie zestawami danych przed wygenerowaniem plików PDF. Dzięki temu w plikach PDF znajdują się tylko niezbędne i unikalne dane, co optymalizuje wydajność i wykorzystanie zasobów.

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