C# Nouvelle GUID (Comment ça fonctionne pour les développeurs)

Qu'est-ce qu'un GUID ?

Un GUID (Identifiant Unique Global) est un identifiant unique utilisé dans le développement logiciel. Dans le framework .NET, les GUIDs sont représentés sous forme de structure Guid dans le namespace System. Les GUIDs sont souvent utilisés comme clés primaires dans les bases de données, ainsi que pour d'autres fins dans d'autres systèmes où des identificateurs uniques sont nécessaires à travers les systèmes.

using System;

class Program
{
    static void Main()
    {
        // Generate a new GUID
        Guid newGuid = Guid.NewGuid();

        // Output the newly generated GUID to the console
        Console.WriteLine(newGuid);
    }
}

using System;

class Program
{
    static void Main()
    {
        // Generate a new GUID
        Guid newGuid = Guid.NewGuid();

        // Output the newly generated GUID to the console
        Console.WriteLine(newGuid);
    }
}

Imports System

Friend Class Program
	Shared Sub Main()
		' Generate a new GUID
		Dim newGuid As Guid = Guid.NewGuid()

		' Output the newly generated GUID to the console
		Console.WriteLine(newGuid)
	End Sub
End Class

Structure et format d'un 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 en utilisant la méthode ToString(), le GUID est représenté dans ce format. Cette représentation rend facile le stockage des GUIDs dans des formats basés sur du texte, tels que JSON, XML ou les bases de données.

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

using System;

class Example
{
    static void Main()
    {
        // Generate a new GUID
        Guid newGuid = Guid.NewGuid();

        // Convert the GUID to a string
        string guidString = newGuid.ToString();

        // Output the GUID string
        Console.WriteLine(guidString);
    }
}

using System;

class Example
{
    static void Main()
    {
        // Generate a new GUID
        Guid newGuid = Guid.NewGuid();

        // Convert the GUID to a string
        string guidString = newGuid.ToString();

        // Output the GUID string
        Console.WriteLine(guidString);
    }
}

Imports System

Friend Class Example
	Shared Sub Main()
		' Generate a new GUID
		Dim newGuid As Guid = Guid.NewGuid()

		' Convert the GUID to a string
		Dim guidString As String = newGuid.ToString()

		' Output the GUID string
		Console.WriteLine(guidString)
	End Sub
End Class

Ce code convertit le GUID en chaîne et l'affiche.

using System;

class ParseExample
{
    static void Main()
    {
        // Define a GUID string
        string guidString = "e02fd0e4-00fd-090A-ca30-0d00a0038ba0";

        // Convert the string back into a GUID object
        Guid parsedGuid = Guid.Parse(guidString);

        // Output the parsed GUID
        Console.WriteLine(parsedGuid);
    }
}

using System;

class ParseExample
{
    static void Main()
    {
        // Define a GUID string
        string guidString = "e02fd0e4-00fd-090A-ca30-0d00a0038ba0";

        // Convert the string back into a GUID object
        Guid parsedGuid = Guid.Parse(guidString);

        // Output the parsed GUID
        Console.WriteLine(parsedGuid);
    }
}

Imports System

Friend Class ParseExample
	Shared Sub Main()
		' Define a GUID string
		Dim guidString As String = "e02fd0e4-00fd-090A-ca30-0d00a0038ba0"

		' Convert the string back into a GUID object
		Dim parsedGuid As Guid = Guid.Parse(guidString)

		' Output the parsed GUID
		Console.WriteLine(parsedGuid)
	End Sub
End Class

Comparer deux GUIDs

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

Voici un exemple :

using System;

class CompareExample
{
    static void Main()
    {
        // Generate two new GUIDs
        Guid guid1 = Guid.NewGuid();
        Guid guid2 = Guid.NewGuid();

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

using System;

class CompareExample
{
    static void Main()
    {
        // Generate two new GUIDs
        Guid guid1 = Guid.NewGuid();
        Guid guid2 = Guid.NewGuid();

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

Imports System

Friend Class CompareExample
	Shared Sub Main()
		' Generate two new GUIDs
		Dim guid1 As Guid = Guid.NewGuid()
		Dim guid2 As Guid = Guid.NewGuid()

		' Compare the two GUIDs
		If guid1 = guid2 Then
			Console.WriteLine("The two GUIDs are the same.")
		Else
			Console.WriteLine("The two GUIDs are different.")
		End If
	End Sub
End Class

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

Erreurs courantes lors de l'utilisation des GUIDs

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 GUIDs maintiendront une certaine sorte d'ordre.

2. Comparaisons de chaînes au lieu de comparaisons de GUIDs : Comparer des GUIDs en tant que chaînes peut être inefficace. Comparez toujours les objets GUIDs directement plutôt que de les convertir en chaînes et de comparer les valeurs des chaînes.

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

GUIDs dans .NET Core et le Framework

Les GUIDs sont pris en charge à la fois dans .NET Framework et .NET Core. L'utilisation de la classe Guid reste cohérente à travers 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 GUIDs en utilisant la méthode Guid.NewGuid().

GUID vs UUID

Les GUIDs sont similaires aux UUIDs (Identifiants Universellement Uniques), et les termes sont souvent utilisés de manière interchangeable. Bien qu'il y ait quelques différences mineures dans la spécification, ils servent le même but de générer des identificateurs 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 des GUIDs lorsque vous avez besoin de générer des noms de fichiers uniques pour vos documents PDF. Cela garantit que chaque PDF généré a un nom unique, empêchant tout écrasement de fichiers ou conflit de noms. Voici un exemple simple de l'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 couvert les bases des GUIDs en C#. Vous avez vu comment générer de nouveaux GUIDs, 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 de GUID, garantissant que chaque identifiant est unique à travers les systèmes. Les développeurs travaillant en .NET peuvent compter sur les GUIDs pour fournir de l'aléatoire et de l'unicité dans leurs applications.

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