C# New GUID (How It Works For Developers) (Nouveau GUID en C# (Comment cela fonctionne pour les développeurs))

La méthode NewGuid() dans une classe Guid est couramment utilisée pour créer un identifiant unique global (GUID). Un GUID est un nombre entier de 128 bits qui peut être utilisé sur tous les ordinateurs et réseaux pour identifier les informations de manière unique sans risque de duplication. Cet article fournira un guide approfondi sur la manière de travailler avec les GUIDs (Globally Unique IDentifiers) en C#, en se concentrant sur les utilisations pratiques, les exemples et les extraits de code. Nous explorerons également la bibliothèque IronPDF.

Qu'est-ce qu'un GUID ?

Un GUID (Globally Unique Identifier) est un identifiant unique utilisé dans le développement logiciel. Dans le framework .NET, les GUID sont représentés sous la forme d'une structure Guid au sein de l'espace de noms System. Les GUID sont souvent utilisés comme clés primaires dans les bases de données, ainsi qu'à d'autres fins dans d'autres systèmes où des identifiants uniques sont nécessaires entre les systèmes.

Générer des GUID dans C# ;

Pour générer un nouveau GUID en C#, la fonction Guid.NewGuid() est utilisée. Cette méthode crée une nouvelle instance d'un objet GUID et garantit que chaque GUID généré est unique. En interne, les GUID sont générés à l'aide d'un générateur de nombres aléatoires afin de garantir qu'aucun GUID n'a la même valeur.

Voici un exemple de code simple pour générer un nouveau GUID :

using System;
class Program
{
    static void Main()
    {
        Guid newGuid = Guid.NewGuid();
        Console.WriteLine(newGuid);
    }
}

using System;
class Program
{
    static void Main()
    {
        Guid newGuid = Guid.NewGuid();
        Console.WriteLine(newGuid);
    }
}

Imports System
Friend Class Program
	Shared Sub Main()
		Dim newGuid As Guid = Guid.NewGuid()
		Console.WriteLine(newGuid)
	End Sub
End Class

Dans ce code, la méthode Guid.NewGuid() crée un nouveau GUID en utilisant un générateur de nombres aléatoires en interne et Console.WriteLine affiche le GUID nouvellement généré dans la console.

Structure et format des GUID

Un GUID se compose de 32 chiffres hexadécimaux, généralement affichés dans un format de 8-4-4-4-12 (par exemple, e02fd0e4-00fd-090A-ca30-0d00a0038ba0). Lorsqu'il est converti en chaîne à l'aide de la méthode ToString(), le GUID est représenté dans ce format. Cette représentation facilite le stockage des GUID dans des formats textuels, tels que JSON, XML ou les bases de données.

L'exemple de code ci-dessous montre comment convertir un GUID en chaîne de caractères :

Guid newGuid = Guid.NewGuid();
string guidString = newGuid.ToString();
Console.WriteLine(guidString);

Guid newGuid = Guid.NewGuid();
string guidString = newGuid.ToString();
Console.WriteLine(guidString);

Dim newGuid As Guid = Guid.NewGuid()
Dim guidString As String = newGuid.ToString()
Console.WriteLine(guidString)

Ce code convertit le GUID en une chaîne de caractères et l'affiche.

Analyse des chaînes GUID

Il peut arriver que vous deviez analyser une chaîne de caractères pour la convertir en un objet GUID. Ceci est fait en utilisant la méthode Guid.Parse(). Si la chaîne est au bon format, elle sera analysée en une instance de GUID. Si le format est incorrect, une exception sera levée.

Voici un exemple de code :

string guidString = "e02fd0e4-00fd-090A-ca30-0d00a0038ba0";
Guid parsedGuid = Guid.Parse(guidString);
Console.WriteLine(parsedGuid);

string guidString = "e02fd0e4-00fd-090A-ca30-0d00a0038ba0";
Guid parsedGuid = Guid.Parse(guidString);
Console.WriteLine(parsedGuid);

Dim guidString As String = "e02fd0e4-00fd-090A-ca30-0d00a0038ba0"
Dim parsedGuid As Guid = Guid.Parse(guidString)
Console.WriteLine(parsedGuid)

Dans ce code, la méthode Guid.Parse() convertit la chaîne en un objet GUID.

Comparaison de deux GUID

Les GUID peuvent être comparés pour voir s'ils sont égaux ou non. La structure Guid implémente l'opérateur d'égalité (==), donc vous pouvez comparer directement deux objets GUID.

En voici un exemple :

Guid guid1 = Guid.NewGuid();
Guid guid2 = Guid.NewGuid();
if (guid1 == guid2)
{
    Console.WriteLine("The two GUIDs are the same.");
}
else
{
    Console.WriteLine("The two GUIDs are different.");
}

Guid guid1 = Guid.NewGuid();
Guid guid2 = Guid.NewGuid();
if (guid1 == guid2)
{
    Console.WriteLine("The two GUIDs are the same.");
}
else
{
    Console.WriteLine("The two GUIDs are different.");
}

Dim guid1 As Guid = Guid.NewGuid()
Dim guid2 As Guid = Guid.NewGuid()
If guid1 = guid2 Then
	Console.WriteLine("The two GUIDs are the same.")
Else
	Console.WriteLine("The two GUIDs are different.")
End If

Dans ce code, les deux GUID sont comparés. Étant donné que chaque GUID généré par Guid.NewGuid() est unique, le résultat sera généralement "Les deux GUID sont différents."

Erreurs courantes lors de l'utilisation des GUID

1. Supposer que les GUIDs sont séquentiels : Les GUIDs sont aléatoires, et la méthode NewGuid() ne génère pas de valeurs séquentielles. Par conséquent, vous ne devez pas supposer que les GUID conserveront un quelconque ordre.

2. Comparaison de chaînes de caractères au lieu de GUID : Comparer des GUID en tant que chaînes peut être inefficace. Comparez toujours les objets GUID directement plutôt que de les convertir en chaînes et de comparer les valeurs des chaînes.

3. Utilisation des GUID dans de grandes bases de données sans indexation : Les GUID peuvent être volumineux et peuvent affecter les performances dans de grandes bases de données s'ils ne sont pas correctement indexés. Assurez-vous que vos colonnes GUID sont indexées lorsque vous les utilisez comme clés primaires.

GUIDs dans .NET Core et Framework

Les GUID sont pris en charge à la fois dans .NET Framework et .NET Core. L'utilisation de la classe Guid reste cohérente entre les différentes versions de la plateforme .NET. Par conséquent, les développeurs travaillant avec n'importe quelle version de .NET peuvent facilement générer des GUID en utilisant la méthode Guid.NewGuid().

GUID vs UUID

Les GUID sont similaires aux UUID (Identifiants Uniques Universels), et les termes sont souvent utilisés de manière interchangeable. Bien qu'il y ait quelques différences mineures dans la spécification, elles servent le même objectif de génération d'identifiants uniques.

Utiliser IronPDF avec GUID

IronPDF est une bibliothèque PDF pour générer des PDFs à partir de HTML et d'autres opérations PDF dans les applications .NET. Vous pouvez combiner IronPDF avec les GUID lorsque vous avez besoin de générer des noms de fichiers uniques pour vos documents PDF. Cela permet de s'assurer que chaque PDF généré porte un nom unique, évitant ainsi tout écrasement de fichier ou conflit de dénomination. Voici un exemple simple d'utilisation d'IronPDF avec un nouveau GUID :

using System;
using IronPdf;
class Program
{
    static void Main()
    {
        // Generate a new GUID object for the PDF filename
        Guid pdfId = Guid.NewGuid();
        string filename = $"{pdfId}.pdf";
        // Create a PDF document using IronPDF
        var renderer = new ChromePdfRenderer();
        var pdfDocument = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1>");
        // Save the PDF with the unique filename
        pdfDocument.SaveAs(filename);
        Console.WriteLine($"PDF saved as: {filename}");
    }
}

using System;
using IronPdf;
class Program
{
    static void Main()
    {
        // Generate a new GUID object for the PDF filename
        Guid pdfId = Guid.NewGuid();
        string filename = $"{pdfId}.pdf";
        // Create a PDF document using IronPDF
        var renderer = new ChromePdfRenderer();
        var pdfDocument = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1>");
        // Save the PDF with the unique filename
        pdfDocument.SaveAs(filename);
        Console.WriteLine($"PDF saved as: {filename}");
    }
}

Imports System
Imports IronPdf
Friend Class Program
	Shared Sub Main()
		' Generate a new GUID object for the PDF filename
		Dim pdfId As Guid = Guid.NewGuid()
		Dim filename As String = $"{pdfId}.pdf"
		' Create a PDF document using IronPDF
		Dim renderer = New ChromePdfRenderer()
		Dim pdfDocument = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1>")
		' Save the PDF with the unique filename
		pdfDocument.SaveAs(filename)
		Console.WriteLine($"PDF saved as: {filename}")
	End Sub
End Class

Exécutez le code ci-dessus dans Visual Studio et observez le résultat.

Nous utilisons Guid.NewGuid() pour créer un GUID aléatoire unique pour chaque fichier PDF. Ce GUID est converti en chaîne et utilisé comme nom de fichier.

Conclusion

Dans cet article, nous avons abordé les bases des GUID en C#. Vous avez vu comment générer de nouveaux GUID, les comparer, les analyser à partir de chaînes et les utiliser dans des scénarios pratiques tels que les bases de données. La méthode Guid.NewGuid() facilite la génération d'une nouvelle instance d'un GUID, garantissant que chaque identifiant est unique à travers les systèmes. Les développeurs qui travaillent avec .NET peuvent compter sur les GUID pour assurer le caractère aléatoire et unique de leurs applications.

IronPDF comprend l'importance de tester avant d'investir, c'est pourquoi nous proposons un essai gratuit. Vous pouvez évaluer les performances du logiciel sans frais. Si vous le trouvez bénéfique, les licences commencent à $749.