Les Identificateurs Universellement Uniques (UUID), connus sous le nom de GUID (Globally Unique Identifier) dans l'écosystème Microsoft, sont des identificateurs de 128 bits conçus pour être uniques dans les systèmes distribués. Dans le développement C#, les GUID sont essentiels pour les clés primaires de bases de données, les applications distribuées et les scénarios nécessitant une unicité garantie sans coordination centralisée.
Ce guide complet explore plusieurs approches pour générer des UUID dans les applications C#, des implémentations de base aux techniques avancées pour des cas d'utilisation spécifiques. Que vous construisiez des applications web, des logiciels de bureau ou des services cloud, comprendre comment implémenter et exploiter correctement les UUID en C# est une compétence précieuse pour tout développeur .NET.
La façon la plus simple et la plus courante de générer un UUID en C# est d'utiliser la classe System.Guid intégrée, qui fait partie du Framework .NET.
using System;
class Program
{
static void Main()
{
// Générer un nouveau GUID aléatoire
Guid newGuid = Guid.NewGuid();
// Afficher le GUID
Console.WriteLine($"UUID généré : {newGuid}");
// Exemple de sortie : UUID généré : 8c2d56f0-8a1e-4b6c-a8d2-af3a99b11f75
}
}Cette méthode génère un UUID aléatoire de Version 4 en utilisant le générateur de nombres aléatoires cryptographiquement fort fourni par le Framework .NET. Guid.NewGuid() est thread-safe et convient à la plupart des scénarios d'application. Les GUID résultants sont au format standard avec 32 chiffres hexadécimaux regroupés selon un modèle spécifique.
C# vous permet de formater les GUID de différentes manières pour répondre à diverses exigences, comme supprimer les traits d'union ou utiliser des formats spécifiques pour la compatibilité avec différents systèmes.
using System;
class Program
{
static void Main()
{
Guid uuid = Guid.NewGuid();
// Format standard (32 chiffres séparés par des traits d'union)
string standard = uuid.ToString();
Console.WriteLine($"Standard : {standard}");
// Format "N" - 32 chiffres sans traits d'union
string sansTraits = uuid.ToString("N");
Console.WriteLine($"Sans traits d'union : {sansTraits}");
// Format "B" - entouré d'accolades
string avecAccolades = uuid.ToString("B");
Console.WriteLine($"Avec accolades : {avecAccolades}");
// Format "P" - entouré de parenthèses
string avecParentheses = uuid.ToString("P");
Console.WriteLine($"Avec parenthèses : {avecParentheses}");
// Format "X" - entouré d'accolades avec préfixe 0x pour les nombres hexadécimaux
string enHex = uuid.ToString("X");
Console.WriteLine($"En hexadécimal : {enHex}");
}
}Cet exemple démontre les différentes options de formatage disponibles pour les GUID en C#. Le format 'N' est particulièrement utile pour les opérations de base de données ou lorsque vous devez minimiser la longueur de la chaîne. Les formats 'B' et 'P' sont parfois utilisés dans des technologies Microsoft spécifiques, tandis que le format 'X' est utile pour les représentations hexadécimales dans certains contextes.
Bien que les GUID aléatoires conviennent à la plupart des scénarios, parfois vous avez besoin d'UUID déterministes qui peuvent être régénérés à partir d'entrées spécifiques, comme pour la migration de données ou les systèmes distribués.
using System;
using System.Security.Cryptography;
using System.Text;
class Program
{
static void Main()
{
string input = "example.com/user/12345";
// Créer un UUID déterministe basé sur l'entrée (UUID Version 5 avec SHA1)
Guid deterministicGuid = CreateDeterministicGuid(input);
Console.WriteLine($"UUID déterministe pour '{input}' : {deterministicGuid}");
}
// Crée un UUID déterministe basé sur un espace de noms et une chaîne d'entrée
static Guid CreateDeterministicGuid(string input)
{
// Utiliser un GUID d'espace de noms fixe
Guid namespaceGuid = new Guid("5856bc41-3e97-4b75-bb69-18608123fdcc");
// Convertir le GUID d'espace de noms en tableau d'octets
byte[] namespaceBytes = namespaceGuid.ToByteArray();
// Convertir la chaîne d'entrée en tableau d'octets
byte[] nameBytes = Encoding.UTF8.GetBytes(input);
// Combiner les octets d'espace de noms et d'entrée
byte[] combinedBytes = new byte[namespaceBytes.Length + nameBytes.Length];
Array.Copy(namespaceBytes, 0, combinedBytes, 0, namespaceBytes.Length);
Array.Copy(nameBytes, 0, combinedBytes, namespaceBytes.Length, nameBytes.Length);
// Calculer le hachage SHA1
using (SHA1 sha1 = SHA1.Create())
{
byte[] hashBytes = sha1.ComputeHash(combinedBytes);
// Définir la version à 5 (UUID d'espace de noms SHA1)
hashBytes[6] = (byte)((hashBytes[6] & 0x0F) | 0x50);
// Définir la variante à RFC 4122
hashBytes[8] = (byte)((hashBytes[8] & 0x3F) | 0x80);
// Reconvertir en GUID
return new Guid(hashBytes.Take(16).ToArray());
}
}
}Cette méthode implémente une génération d'UUID Version 5 conformément à la RFC 4122, qui crée des UUID déterministes basés sur un espace de noms et un nom. Lorsque vous fournissez les mêmes entrées, vous obtiendrez le même UUID en sortie à chaque fois. C'est utile pour les scénarios où vous avez besoin de cohérence entre les systèmes ou lors de la migration de données entre environnements. Notez que dans les versions plus récentes de .NET, vous pourriez préférer utiliser SHA256 au lieu de SHA1 pour une sécurité améliorée.
Pour les opérations de base de données, en particulier avec des index clusterisés, les GUID séquentiels peuvent offrir de meilleures performances que les GUID aléatoires en réduisant la fragmentation de l'index.
using System;
class Program
{
static void Main()
{
// Générer 5 GUID séquentiels
for (int i = 0; i < 5; i++)
{
Guid sequentialGuid = CreateSequentialGuid();
Console.WriteLine($"GUID séquentiel {i+1} : {sequentialGuid}");
}
}
// Crée un GUID séquentiel basé sur l'horodatage actuel
static Guid CreateSequentialGuid()
{
// Obtenir un nouveau GUID aléatoire
byte[] guidBytes = Guid.NewGuid().ToByteArray();
// Obtenir les octets de DateTime actuels
byte[] timestampBytes = BitConverter.GetBytes(DateTime.UtcNow.Ticks);
// Copier les octets d'horodatage dans la première partie du GUID
Array.Copy(timestampBytes, 0, guidBytes, 0, Math.Min(timestampBytes.Length, 6));
// Fixer la version à 4
guidBytes[7] = (byte)((guidBytes[7] & 0x0F) | 0x40);
// Fixer la variante à RFC 4122
guidBytes[8] = (byte)((guidBytes[8] & 0x3F) | 0x80);
return new Guid(guidBytes);
}
}Les GUID séquentiels combinent les avantages des GUID (unicité universelle) et des ID séquentiels (performances optimales de la base de données). L'implémentation ci-dessus intègre un horodatage dans les premiers octets du GUID tout en maintenant les bits de version et de variante requis selon la spécification UUID. Cette approche est particulièrement utile pour les opérations de base de données à haute performance où les index de table doivent rester défragmentés.
Pour les applications qui utilisent fréquemment des GUID, il est avantageux de créer une classe utilitaire qui centralise votre logique de génération de GUID. Voici une classe utilitaire complète qui fournit diverses méthodes de génération de GUID :
using System;
using System.Security.Cryptography;
using System.Text;
namespace VotreEspace.Utilitaires
{
/// <summary>
/// Fournit des méthodes pour générer et manipuler des UUID/GUID
/// </summary>
public static class GuidUtility
{
// GUID d'espaces de noms standard définis dans RFC 4122
public static readonly Guid DnsNamespace = new Guid("6ba7b810-9dad-11d1-80b4-00c04fd430c8");
public static readonly Guid UrlNamespace = new Guid("6ba7b811-9dad-11d1-80b4-00c04fd430c8");
public static readonly Guid OidNamespace = new Guid("6ba7b812-9dad-11d1-80b4-00c04fd430c8");
/// <summary>
/// Génère un GUID aléatoire (Version 4)
/// </summary>
public static Guid NewGuid()
{
return Guid.NewGuid();
}
/// <summary>
/// Génère un GUID séquentiel optimisé pour les opérations de base de données
/// </summary>
public static Guid NewSequentialGuid()
{
byte[] guidBytes = Guid.NewGuid().ToByteArray();
byte[] timestampBytes = BitConverter.GetBytes(DateTime.UtcNow.Ticks);
Array.Copy(timestampBytes, 0, guidBytes, 0, Math.Min(timestampBytes.Length, 6));
// Définir la version à 4
guidBytes[7] = (byte)((guidBytes[7] & 0x0F) | 0x40);
// Définir la variante à RFC 4122
guidBytes[8] = (byte)((guidBytes[8] & 0x3F) | 0x80);
return new Guid(guidBytes);
}
/// <summary>
/// Crée un GUID Version 5 déterministe à partir d'un espace de noms et d'un nom
/// </summary>
public static Guid CreateNameBasedGuid(Guid namespaceGuid, string name)
{
if (string.IsNullOrEmpty(name))
throw new ArgumentNullException(nameof(name));
byte[] namespaceBytes = namespaceGuid.ToByteArray();
byte[] nameBytes = Encoding.UTF8.GetBytes(name);
byte[] combinedBytes = new byte[namespaceBytes.Length + nameBytes.Length];
Array.Copy(namespaceBytes, 0, combinedBytes, 0, namespaceBytes.Length);
Array.Copy(nameBytes, 0, combinedBytes, namespaceBytes.Length, nameBytes.Length);
using (SHA1 sha1 = SHA1.Create())
{
byte[] hashBytes = sha1.ComputeHash(combinedBytes);
// Définir la version à 5 (espace de noms SHA1)
hashBytes[6] = (byte)((hashBytes[6] & 0x0F) | 0x50);
// Définir la variante à RFC 4122
hashBytes[8] = (byte)((hashBytes[8] & 0x3F) | 0x80);
return new Guid(hashBytes.Take(16).ToArray());
}
}
/// <summary>
/// Crée un GUID déterministe basé sur une URL
/// </summary>
public static Guid CreateUrlBasedGuid(string url)
{
return CreateNameBasedGuid(UrlNamespace, url);
}
/// <summary>
/// Crée un GUID déterministe basé sur DNS
/// </summary>
public static Guid CreateDnsBasedGuid(string dns)
{
return CreateNameBasedGuid(DnsNamespace, dns);
}
}
}Cette classe utilitaire encapsule différentes stratégies de génération d'UUID/GUID, ce qui facilite la génération de GUID appropriés pour différents scénarios dans votre application. Elle comprend des méthodes pour les GUID aléatoires, les GUID séquentiels pour les bases de données et les GUID basés sur des noms pour l'identification déterministe. La classe suit les normes RFC 4122 et peut être étendue avec des méthodes supplémentaires selon les besoins spécifiques de vos applications.
Lorsque vous travaillez avec des GUID provenant de sources externes ou d'entrées utilisateur, il est important de les valider correctement. Voici comment analyser et valider les GUID en C# :
using System;
class Program
{
static void Main()
{
// Exemples de chaînes GUID valides et invalides
string[] guidStrings = new string[]
{
"8c2d56f0-8a1e-4b6c-a8d2-af3a99b11f75", // Format standard valide
"8c2d56f08a1e4b6ca8d2af3a99b11f75", // Valide sans traits d'union
"{8c2d56f0-8a1e-4b6c-a8d2-af3a99b11f75}", // Valide avec accolades
"pas-une-valeur-guid", // Invalide
"8c2d56f0-8a1e-4b6c-a8d2-af3a99b11f" // Invalide (trop court)
};
foreach (string guidString in guidStrings)
{
if (TryParseGuid(guidString, out Guid parsedGuid))
{
Console.WriteLine($"GUID valide : '{guidString}' => {parsedGuid}");
}
else
{
Console.WriteLine($"GUID invalide : '{guidString}'");
}
}
}
// Tente d'analyser une chaîne comme GUID et la valide
static bool TryParseGuid(string input, out Guid result)
{
// Utiliser la méthode TryParse intégrée
if (Guid.TryParse(input, out result))
{
return true;
}
// Une validation supplémentaire pourrait être ajoutée ici si nécessaire
// Par exemple, vérifier s'il s'agit d'un GUID vide
return false;
}
// Vérifie si un GUID est vide/par défaut
static bool IsEmptyGuid(Guid guid)
{
return guid == Guid.Empty;
}
}Cet exemple démontre comment utiliser Guid.TryParse() pour valider et analyser des chaînes GUID. La méthode gère divers formats de GUID, y compris ceux avec ou sans traits d'union, et ceux entourés d'accolades ou de parenthèses. Pour la plupart des applications, la méthode TryParse intégrée est suffisante, mais vous pouvez étendre la validation avec des règles métier supplémentaires si nécessaire, comme la vérification des GUID vides ou la validation de formats spécifiques.
Lorsque vous générez des GUID à grande échelle, les considérations de performance deviennent importantes. Voici comment générer efficacement un grand nombre de GUID et un code de benchmarking :
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Threading.Tasks;
class Program
{
static void Main()
{
// Benchmarker différentes méthodes de génération de GUID
BenchmarkGuidGeneration(1000000); // Générer 1 million de GUID
}
static void BenchmarkGuidGeneration(int count)
{
Console.WriteLine($"Benchmark de génération de {count:N0} GUID...");
// Benchmark Guid.NewGuid() standard
Stopwatch standardWatch = Stopwatch.StartNew();
List<Guid> standardGuids = new List<Guid>(count);
for (int i = 0; i < count; i++)
{
standardGuids.Add(Guid.NewGuid());
}
standardWatch.Stop();
Console.WriteLine($"Guid.NewGuid() standard : {standardWatch.ElapsedMilliseconds} ms");
// Benchmark génération parallèle de GUID
Stopwatch parallelWatch = Stopwatch.StartNew();
List<Guid> parallelGuids = new List<Guid>(count);
object lockObj = new object();
Parallel.For(0, count, i =>
{
Guid guid = Guid.NewGuid();
lock (lockObj)
{
parallelGuids.Add(guid);
}
});
parallelWatch.Stop();
Console.WriteLine($"Génération parallèle de GUID : {parallelWatch.ElapsedMilliseconds} ms");
// Utilisation mémoire
Console.WriteLine($"Utilisation mémoire pour {count:N0} GUID : {(count * 16) / (1024.0 * 1024.0):F2} Mo");
}
}Ce code de benchmarking compare les performances de la génération de GUID séquentielle et parallèle. Guid.NewGuid() est thread-safe et utilise un générateur de nombres aléatoires cryptographiquement fort, ce qui le rend relativement lent par rapport aux générateurs de nombres aléatoires non cryptographiques, mais garantit l'unicité. Pour les applications nécessitant une génération de GUID haute performance, le traitement parallèle peut aider, mais soyez conscient de la surcharge de synchronisation des threads. Chaque GUID prend 16 octets de mémoire, donc la génération d'un grand nombre de GUID peut consommer des ressources importantes.
Lorsque vous travaillez avec des UUID/GUID dans des applications C#, choisissez la méthode de génération appropriée en fonction de vos besoins spécifiques. Pour la plupart des besoins à usage général, la méthode standard Guid.NewGuid() offre un bon équilibre entre l'aléatoire, l'unicité et les performances. Pour les applications intensives en base de données, envisagez des GUID séquentiels pour minimiser la fragmentation de l'index. Lorsque l'identification déterministe est nécessaire dans les systèmes distribués, utilisez des GUID basés sur le nom avec des espaces de noms appropriés.
N'oubliez pas que les GUID, bien que très utiles, présentent des compromis. Ils sont plus grands que les ID entiers (16 octets contre 4 octets pour INT ou 8 octets pour BIGINT), ce qui peut potentiellement affecter le stockage et les performances dans de très grands ensembles de données. Cependant, leur unicité garantie sans coordination centralisée les rend inestimables pour les systèmes distribués, la synchronisation des données et les architectures cloud modernes. Validez toujours les GUID provenant de sources externes et envisagez de mettre en cache les valeurs fréquemment utilisées pour améliorer les performances.
Pour générer rapidement des UUID sans écrire de code, vous pouvez toujours utiliser notre outil en ligne de génération d'UUID, qui fournit diverses versions et formats d'UUID en un simple clic.