Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. csharp-linq-distinct-guide
.NET AIDE

C# LINQ Distinct (Comment ça fonctionne pour les développeurs)

Curtis Chau
Curtis Chau
Mis à jour:

La requête intégrée au langage (LINQ), une fonctionnalité puissante du langage C#, permet aux programmeurs de créer des requêtes claires et expressives pour une variété de sources de données. This post will discuss the use of IronPDF, a versatile C# library for working with PDF documents, using LINQ's Distinct function. Nous montrerons comment cette combinaison peut faciliter le processus de création de documents uniques à partir d'une collection. Dans cet article, nous allons apprendre la fonction distinct de C# LINQ avec IronPDF.

Comment utiliser la méthode Distinct de LINQ en C

  1. Créez un nouveau projet console.
  2. Importez l'espace de noms System.Linq.
  3. Créez une liste avec plusieurs éléments.
  4. Appelez la méthode Distinct() depuis la liste.
  5. Obtenez les valeurs uniques et affichez le résultat sur la console.
  6. Disposez de tous les objets créés.

Qu'est-ce que LINQ

Les développeurs peuvent construire des requêtes claires et expressives pour la manipulation de données directement dans leur code grâce à la fonctionnalité LINQ (Language Integrated Query) de C#. Incluse pour la première fois dans le .NET Framework 3.5, LINQ offre une syntaxe standard pour interroger une gamme de sources de données, y compris les bases de données et les collections. LINQ simplifie des tâches simples comme le filtrage et la projection en utilisant des opérateurs tels que Where et Select, ce qui améliore la lisibilité du code. Parce qu'elle permet une exécution différée pour une vitesse optimale, cette fonctionnalité est cruciale pour les développeurs C# pour s'assurer que les opérations de manipulation de données sont effectuées rapidement et naturellement de manière analogue au SQL.

Comprendre LINQ Distinct

Les éléments dupliqués peuvent être supprimés d'une collection ou d'une séquence à l'aide de la fonction Distinct de LINQ. En l'absence de comparateur d'égalité personnalisé, il compare les éléments en utilisant leur comparateur par défaut. Cela en fait une excellente option dans les situations où vous avez besoin de travailler avec une collection unique et de supprimer les composants en double. La méthode Distinct utilise les comparateurs d'égalité par défaut pour évaluer les valeurs. Elle exclura les doublons pour ne retourner que des éléments uniques.

Utilisation de base

Pour obtenir des éléments distincts, la façon la plus simple de l'utiliser est d'utiliser la méthode Distinct directement sur une collection.

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

Comparateur d'égalité personnalisé

Vous pouvez définir une comparaison d'égalité personnalisée en utilisant une surcharge de la fonction Distinct. Cela est utile si vous souhaitez comparer des éléments selon des critères particuliers. Veuillez vous référer à l'exemple suivant :

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

Utilisation de Distinct avec des types de valeur

Vous n'avez pas besoin de fournir une comparaison d'égalité personnalisée lors de l'utilisation de la méthode Distinct avec des types de valeur.

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

Utilisation de Distinct avec des types anonymes

Distinct peut être utilisé avec des types anonymes pour supprimer les doublons basés sur des attributs particuliers. Veuillez vous référer à l'exemple suivant :

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

Distinct par une propriété spécifique

Lorsque vous travaillez avec des objets, vous pouvez soit créer votre logique pour distinguer par un certain attribut, soit utiliser la méthode d'extension DistinctBy à partir de bibliothèques tierces (comme 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

Les programmeurs peuvent créer, éditer et modifier des documents PDF en utilisant le langage C# avec l'aide de la bibliothèque .NET Site Web IronPDF. Le programme offre une gamme d'outils et de fonctionnalités pour permettre diverses tâches impliquant des fichiers PDF, telles que générer des PDFs à partir de HTML, convertir du HTML en PDF, fusionner ou diviser des documents PDF, et ajouter du texte, des images et des annotations aux PDFs déjà existants. Pour en savoir plus sur IronPDF, veuillez vous référer à leur Documentation IronPDF.

La fonctionnalité principale d'IronPDF est la Conversion d'HTML en PDF, qui conserve vos mises en page et styles intacts. Vous pouvez générer des PDFs à partir de contenu web, idéal pour les rapports, les factures et la documentation. Il prend en charge la conversion de fichiers HTML, d'URLs et de chaînes HTML en fichiers 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

Caractéristiques de IronPDF

  • Convertir HTML en PDF : Vous pouvez utiliser IronPDF pour convertir tout type de données HTML—y compris des fichiers, des URLs, et des chaînes de code HTML—en documents PDF.
  • Génération de PDF : Du texte, des images, et d'autres éléments peuvent être ajoutés de manière programmatique à des documents PDF en utilisant le langage de programmation C#.
  • Manipulation de PDF : IronPDF peut diviser un fichier PDF en plusieurs fichiers, fusionner plusieurs documents PDF en un seul fichier, et éditer des PDFs déjà existants.
  • Formulaires PDF : La bibliothèque permet aux utilisateurs de construire et de remplir des formulaires PDF, ce qui est utile dans les situations où des données de formulaire doivent être recueillies et traitées.
  • Fonctionnalités de sécurité : IronPDF peut être utilisé pour crypter des documents PDF et fournir une protection par mot de passe et autorisation.
  • Extraction de texte : Du texte à partir de fichiers PDF peut être extrait en utilisant IronPDF.

Installer IronPDF

Obtenez la bibliothèque IronPDF ; c'est nécessaire pour configurer votre projet. Entrez le code suivant dans la console du gestionnaire de packages NuGet pour accomplir cela :

Install-Package IronPdf

C# LINQ Distinct (Comment ça fonctionne pour les développeurs) : Figure 1 - Pour installer la bibliothèque IronPDF en utilisant la console du gestionnaire de packages NuGet, entrez la commande suivante : Install IronPDF ou dotnet add package IronPdf

Utiliser le gestionnaire de packages NuGet pour rechercher le package "IronPDF" est une option complémentaire. Nous pouvons choisir et télécharger le package requis dans cette liste parmi tous les packages NuGet associés à IronPDF.

C# LINQ Distinct (Comment ça fonctionne pour les développeurs) : Figure 2 - Pour installer la bibliothèque IronPDF en utilisant le gestionnaire de packages NuGet, recherchez le package IronPDF dans l'onglet Parcourir et choisissez la dernière version du package IronPDF pour l'installer dans votre projet.

LINQ Avec IronPDF

Considérez une situation dans laquelle vous avez un ensemble de données et vous souhaitez créer divers documents PDF en fonction de différentes valeurs de cet ensemble. C'est là que l'utilité du Distinct de LINQ brille, notamment lorsqu'il est utilisé avec IronPDF pour créer des documents rapidement.

Génération de PDFs Distincts avec LINQ et 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

Dans cet exemple, une série de catégories distinctes est obtenue en utilisant la méthode Distinct pour la collection de catégories. Elle aide à retirer les éléments dupliqués d'une séquence. Ensuite, IronPDF est utilisé pour créer un document PDF avec ces éléments uniques. Cette méthode garantit que des documents PDF séparés sont produits uniquement pour les catégories uniques.

Sortie de la console

C# LINQ Distinct (Comment ça fonctionne pour les développeurs) : Figure 3 - Sortie de la console

Sortie de PDF généré

C# LINQ Distinct (Comment ça fonctionne pour les développeurs) : Figure 4 - Sortie de PDF : Rapport Technologique

Pour en savoir plus sur l'exemple de code IronPDF pour générer des PDFs en utilisant HTML, consultez l'Exemple de code IronPDF HTML en PDF.

Conclusion

La méthode d'extension Distinct de LINQ en conjonction avec IronPDF offre un mécanisme robuste et efficace pour créer des documents PDF uniques basés sur des valeurs. Cette méthode simplifie le code et garantit une production de documents efficace, que vous travailliez avec des catégories, des étiquettes ou toute autre donnée nécessitant des documents séparés.

Vous pouvez développer une solution fiable et expressive pour gérer différents aspects de vos applications C# en utilisant LINQ pour le traitement des données et IronPDF pour la production de documents. Lorsque vous utilisez ces stratégies pour vos projets, gardez à l'esprit les besoins particuliers de votre application et ajustez l'implémentation pour atteindre une fiabilité et une performance maximales.

Questions Fréquemment Posées

Comment puis-je supprimer les doublons d'une collection en C#?

Vous pouvez utiliser la méthode Distinct de LINQ pour supprimer les doublons d'une collection en C#. Cette méthode est particulièrement utile lorsqu'elle est combinée avec IronPDF pour générer des documents PDF uniques à partir de catégories de données distinctes.

Comment convertir du HTML en PDF en C#?

Pour convertir du HTML en PDF en C#, vous pouvez utiliser la méthode RenderHtmlAsPdf d'IronPDF. Cela vous permet de convertir des chaînes ou des fichiers HTML en documents PDF de manière efficace.

Puis-je utiliser la méthode Distinct de LINQ avec des objets personnalisés?

Oui, vous pouvez utiliser la méthode Distinct de LINQ avec des objets personnalisés en fournissant un comparateur d'égalité personnalisé. Cela est utile lorsque vous devez définir des critères spécifiques pour déterminer l'unicité dans votre processus de génération de PDF avec IronPDF.

Quel est l'avantage d'utiliser LINQ avec IronPDF?

Utiliser LINQ avec IronPDF permet aux développeurs de créer des documents PDF uniques et efficaces basés sur le traitement des données. Cela améliore la lisibilité et les performances du code, en particulier lors de la gestion de tâches de génération de documents à grande échelle.

Comment la méthode Distinct de LINQ améliore-t-elle la création de documents PDF?

La méthode Distinct de LINQ peut améliorer la création de documents PDF en veillant à ce que seuls les éléments uniques soient inclus dans le résultat final. Cette méthode peut être utilisée en conjonction avec IronPDF pour générer des documents PDF distincts pour diverses catégories de données.

Est-il possible de personnaliser la sortie PDF lors de l'utilisation d'IronPDF?

Oui, IronPDF offre diverses options pour personnaliser la sortie PDF, y compris la définition des tailles de page, des marges et l'ajout d'en-têtes ou de pieds de page. Cette personnalisation peut être combinée avec LINQ pour créer des sorties de documents sur mesure et uniques.

Quels scénarios peuvent bénéficier de l'utilisation de la méthode Distinct de LINQ avec les PDFs?

Des scénarios tels que la génération de rapports, de factures ou tout document nécessitant l'unicité à partir d'un ensemble de données peuvent bénéficier de l'utilisation de la méthode Distinct de LINQ avec les PDFs. IronPDF peut être exploité pour produire des sorties PDF propres et distinctes de manière efficace.

Comment LINQ améliore-t-il l'efficacité des applications PDF axées sur les données?

LINQ améliore l'efficacité des applications PDF axées sur les données en permettant aux développeurs de filtrer et de manipuler les ensembles de données avant de générer des PDFs. Cela garantit que seules les données nécessaires et uniques sont incluses dans les PDFs, optimisant ainsi les performances et l'utilisation des ressources.

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

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

Lire la suite

Articles connexes

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