Guid Structure

Définition

Représente un GUID (identificateur global unique).

public value class Guid : IComparable, IComparable<Guid>, IEquatable<Guid>, IFormattable
public value class Guid : IComparable, IComparable<Guid>, IEquatable<Guid>, ISpanFormattable
public value class Guid : IComparable, IComparable<Guid>, IEquatable<Guid>, IParsable<Guid>, ISpanFormattable, ISpanParsable<Guid>
public value class Guid : IComparable, IComparable<Guid>, IEquatable<Guid>, IParsable<Guid>, ISpanFormattable, ISpanParsable<Guid>, IUtf8SpanFormattable
public value class Guid : IComparable, IFormattable
public struct Guid : IComparable, IComparable<Guid>, IEquatable<Guid>, IFormattable
public readonly struct Guid : IComparable, IComparable<Guid>, IEquatable<Guid>, ISpanFormattable
public readonly struct Guid : IComparable, IComparable<Guid>, IEquatable<Guid>, IParsable<Guid>, ISpanFormattable, ISpanParsable<Guid>
public readonly struct Guid : IComparable, IComparable<Guid>, IEquatable<Guid>, IParsable<Guid>, ISpanFormattable, ISpanParsable<Guid>, IUtf8SpanFormattable
[System.Serializable]
public struct Guid : IComparable, IFormattable
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct Guid : IComparable, IComparable<Guid>, IEquatable<Guid>, IFormattable
type Guid = struct
    interface IFormattable
type Guid = struct
    interface ISpanFormattable
    interface IFormattable
type Guid = struct
    interface IFormattable
    interface IParsable<Guid>
    interface ISpanFormattable
    interface ISpanParsable<Guid>
type Guid = struct
    interface IFormattable
    interface IParsable<Guid>
    interface ISpanFormattable
    interface ISpanParsable<Guid>
    interface IUtf8SpanFormattable
[<System.Serializable>]
type Guid = struct
    interface IFormattable
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Guid = struct
    interface IFormattable
Public Structure Guid
Implements IComparable, IComparable(Of Guid), IEquatable(Of Guid), IFormattable
Public Structure Guid
Implements IComparable, IComparable(Of Guid), IEquatable(Of Guid), ISpanFormattable
Public Structure Guid
Implements IComparable, IComparable(Of Guid), IEquatable(Of Guid), IParsable(Of Guid), ISpanFormattable, ISpanParsable(Of Guid)
Public Structure Guid
Implements IComparable, IComparable(Of Guid), IEquatable(Of Guid), IParsable(Of Guid), ISpanFormattable, ISpanParsable(Of Guid), IUtf8SpanFormattable
Public Structure Guid
Implements IComparable, IFormattable
Héritage
Attributs
Implémente

Exemples

L’exemple suivant utilise la System.Runtime.InteropServices.GuidAttribute classe pour affecter un GUID à une interface et à une classe définie par l’utilisateur. Il récupère la valeur du GUID en appelant la méthode et la GetCustomAttribute compare à deux autres GUID pour déterminer s’ils sont égaux.

using namespace System;
using namespace System::Runtime::InteropServices;

// Guid for the interface IMyInterface.
[Guid("F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4")]
public interface class IMyInterface
{
public:
   void MyMethod();
};


// Guid for the coclass MyTestClass.
[Guid("936DA01F-9ABD-4d9d-80C7-02AF85C822A8")]
public ref class MyTestClass: public IMyInterface
{
public:
   virtual void MyMethod(){}
};

int main()
{
   Attribute^ IMyInterfaceAttribute = Attribute::GetCustomAttribute( IMyInterface::typeid, GuidAttribute::typeid );

   // The Value property of GuidAttribute returns a string. 
   System::Console::WriteLine( String::Concat(  "IMyInterface Attribute: ", (dynamic_cast<GuidAttribute^>(IMyInterfaceAttribute))->Value ) );

   // Using the string to create a guid.
   Guid myGuid1 = Guid(dynamic_cast<GuidAttribute^>(IMyInterfaceAttribute)->Value);

   // Using a byte array to create a guid.
   Guid myGuid2 = Guid(myGuid1.ToByteArray());

   // Equals is overridden to perform a value comparison.
   if ( myGuid1.Equals( myGuid2 ) )
      System::Console::WriteLine(  "myGuid1 equals myGuid2" );
   else
      System::Console::WriteLine(  "myGuid1 not equals myGuid2" );

   // Equality operator can also be used to determine if two guids have same value.
   if ( myGuid1 == myGuid2 )
      System::Console::WriteLine(  "myGuid1 == myGuid2" );
   else
      System::Console::WriteLine(  "myGuid1 != myGuid2" );
}
// The example displays the following output:
//       IMyInterface Attribute: F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4
//       myGuid1 equals myGuid2
//       myGuid1 == myGuid2
using System;
using System.Runtime.InteropServices;

// Guid for the interface IMyInterface.
[Guid("F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4")]
interface IMyInterface
{
    void MyMethod();
}

// Guid for the coclass MyTestClass.
[Guid("936DA01F-9ABD-4d9d-80C7-02AF85C822A8")]
public class MyTestClass : IMyInterface
{
    public void MyMethod() {}

    public static void Main( string []args )
    {
        GuidAttribute IMyInterfaceAttribute = (GuidAttribute) Attribute.GetCustomAttribute(typeof(IMyInterface), typeof(GuidAttribute));

        System.Console.WriteLine("IMyInterface Attribute: " + IMyInterfaceAttribute.Value );

        // Use the string to create a guid.
        Guid myGuid1 = new Guid(IMyInterfaceAttribute.Value );
        // Use a byte array to create a guid.
        Guid myGuid2 = new Guid(myGuid1.ToByteArray());

        if (myGuid1.Equals(myGuid2))
            System.Console.WriteLine("myGuid1 equals myGuid2");
        else
            System.Console.WriteLine("myGuid1 does not equal myGuid2" );

        // Equality operator can also be used to determine if two guids have same value.
        if ( myGuid1 == myGuid2 )
            System.Console.WriteLine( "myGuid1 == myGuid2" );
        else
            System.Console.WriteLine( "myGuid1 != myGuid2" );
    }
}
// The example displays the following output:
//       IMyInterface Attribute: F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4
//       myGuid1 equals myGuid2
//       myGuid1 == myGuid2
open System
open System.Runtime.InteropServices

// Guid for the interface IMyInterface.
[<Guid "F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4">]
type IMyInterface =
    abstract MyMethod: unit -> unit

// Guid for the coclass MyTestClass.
[<Guid "936DA01F-9ABD-4d9d-80C7-02AF85C822A8">]
type MyTestClass() =
    interface IMyInterface with
        member _.MyMethod() = ()

let IMyInterfaceAttribute = 
    Attribute.GetCustomAttribute(typeof<IMyInterface>, typeof<GuidAttribute>) :?> GuidAttribute

printfn $"IMyInterface Attribute: {IMyInterfaceAttribute.Value}"

// Use the string to create a guid.
let myGuid1 = Guid IMyInterfaceAttribute.Value
// Use a byte array to create a guid.
let myGuid2 = Guid(myGuid1.ToByteArray())

if myGuid1.Equals myGuid2 then
    printfn "myGuid1 equals myGuid2"
else
    printfn "myGuid1 does not equal myGuid2"

// Equality operator can also be used to determine if two guids have same value.
if myGuid1 = myGuid2 then
    printfn "myGuid1 == myGuid2"
else
    printfn "myGuid1 <> myGuid2"

// The example displays the following output:
//       IMyInterface Attribute: F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4
//       myGuid1 equals myGuid2
//       myGuid1 == myGuid2
Imports System.Runtime.InteropServices

' Guid for the interface IMyInterface.
<Guid("F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4")> _
Interface IMyInterface
    Sub MyMethod()
End Interface

' Guid for the coclass MyTestClass.
<Guid("936DA01F-9ABD-4d9d-80C7-02AF85C822A8")> _
Public Class MyTestClass
    Implements IMyInterface

    Public Sub MyMethod() Implements IMyInterface.MyMethod
    End Sub

    Public Shared Sub Main()
        Dim IMyInterfaceAttribute As GuidAttribute = CType(Attribute.GetCustomAttribute(GetType(IMyInterface), GetType(GuidAttribute)),
                                                           GuidAttribute)

        Console.WriteLine("IMyInterface Attribute: " + IMyInterfaceAttribute.Value)

        ' Use the string to create a guid.
        Dim myGuid1 As New Guid(IMyInterfaceAttribute.Value)
        ' Use a byte array to create a guid.
        Dim myGuid2 As New Guid(myGuid1.ToByteArray())

        If myGuid1.Equals(myGuid2) Then
            Console.WriteLine("myGuid1 equals myGuid2")
        Else
            Console.WriteLine("myGuid1 does not equal myGuid2")
        End If 

        ' The equality operator can also be used to determine if two guids have same value.
        If myGuid1.ToString() = myGuid2.ToString() Then
            Console.WriteLine("myGuid1 == myGuid2")
        Else
            Console.WriteLine("myGuid1 != myGuid2")
        End If
    End Sub
End Class
' The example displays the following output:
'       IMyInterface Attribute: F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4
'       myGuid1 equals myGuid2
'       myGuid1 == myGuid2

Notez que l’attribut GuidAttribute est généralement utilisé dans une application pour exposer un type à COM. Si vous compilez cet exemple, vous pouvez exécuter l’outil d’inscription d’assembly (Regasm.exe) sur l’assembly généré pour créer des fichiers de registre (.reg) et de bibliothèque de types (.tlb). Le fichier .reg peut être utilisé pour inscrire la coclasse dans le Registre, et le fichier .tlb peut fournir des métadonnées pour l’interopérabilité COM.

Remarques

Un GUID est un entier de 128 bits (16 octets) qui peut être utilisé sur tous les ordinateurs et réseaux partout où un identificateur unique est requis. Un tel identificateur a une très faible probabilité d’être dupliqué.

Constructeurs

Guid(Byte[])

Initialise une nouvelle instance de la structure Guid à l'aide du tableau d'octets spécifié.

Guid(Int32, Int16, Int16, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte)

Initialise une nouvelle instance de la structure Guid à l'aide des entiers et des octets spécifiés.

Guid(Int32, Int16, Int16, Byte[])

Initialise une nouvelle instance de la structure Guid à l'aide des entiers et du tableau d'octets spécifiés.

Guid(ReadOnlySpan<Byte>)

Initialise une nouvelle instance de la structure Guid à l'aide de la valeur représentée par la plage d’octets en lecture seule spécifiée.

Guid(ReadOnlySpan<Byte>, Boolean)

Représente un GUID (identificateur global unique).

Guid(String)

Initialise une nouvelle instance de la structure Guid à l'aide de la valeur représentée par la chaîne spécifiée.

Guid(UInt32, UInt16, UInt16, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte)

Initialise une nouvelle instance de la structure Guid à l'aide des entiers et des octets non signés spécifiés.

Champs

Empty

Instance en lecture seule de la structure Guid dont la valeur ne peut être composée que de zéros.

Méthodes

CompareTo(Guid)

Compare cette instance à un objet Guid spécifié et retourne une indication de leurs valeurs relatives.

CompareTo(Object)

Compare cette instance à un objet spécifié et retourne une indication de leurs valeurs relatives.

Equals(Guid)

Retourne une valeur indiquant si cette instance et un objet Guid spécifié représentent la même valeur.

Equals(Object)

Retourne une valeur qui indique si cette instance est égale à un objet spécifié.

GetHashCode()

Retourne le code de hachage de cette instance.

NewGuid()

Initialise une nouvelle instance de la structure Guid.

Parse(ReadOnlySpan<Char>)

Convertit une étendue de caractères en lecture seule qui représente un GUID en une structure Guid équivalente.

Parse(ReadOnlySpan<Char>, IFormatProvider)

Analyse une étendue de caractères dans une valeur.

Parse(String)

Convertit la représentation sous forme de chaîne d'un GUID en une structure Guid équivalente.

Parse(String, IFormatProvider)

Analyse une chaîne en une valeur.

ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Convertit la représentation d’une étendue de caractères d’un GUID en une structure Guid équivalente, à condition que la chaîne soit au format spécifié.

ParseExact(String, String)

Convertit la représentation sous forme de chaîne d'un GUID en une structure Guid équivalente, à condition que la chaîne soit au format spécifié.

ToByteArray()

Retourne un tableau d'octets à 16 éléments qui contient la valeur de cette instance.

ToByteArray(Boolean)

Représente un GUID (identificateur global unique).

ToString()

Retourne une représentation sous forme de chaîne de la valeur de cette instance au format du Registre.

ToString(String)

Retourne une représentation sous forme de chaîne de la valeur de cette instance Guid, selon le spécificateur de format fourni.

ToString(String, IFormatProvider)

Retourne une représentation sous forme de chaîne de la valeur de cette instance de la classe Guid, selon le spécificateur de format et les informations de format propres à la culture fournis.

TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>)

Représente un GUID (identificateur global unique).

TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>)

Tente de mettre en forme l’instance GUID actuelle dans l’étendue de caractères fournie.

TryParse(ReadOnlySpan<Char>, Guid)

Convertit l’étendue de caractères en lecture seule spécifiée contenant la représentation d’un GUID en la structure Guid équivalente.

TryParse(ReadOnlySpan<Char>, IFormatProvider, Guid)

Tente d’analyser une étendue de caractères dans une valeur.

TryParse(String, Guid)

Convertit la représentation sous forme de chaîne d'un GUID en une structure Guid équivalente.

TryParse(String, IFormatProvider, Guid)

Tente d’analyser une chaîne en une valeur.

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, Guid)

Convertit l’étendue de caractères représentant le GUID en la structure Guid équivalente, à condition que la chaîne soit au format spécifié.

TryParseExact(String, String, Guid)

Convertit la représentation sous forme de chaîne d'un GUID en une structure Guid équivalente, à condition que la chaîne soit au format spécifié.

TryWriteBytes(Span<Byte>)

Tente d’écrire l’instance GUID actuelle dans une plage d’octets.

TryWriteBytes(Span<Byte>, Boolean, Int32)

Représente un GUID (identificateur global unique).

Opérateurs

Equality(Guid, Guid)

Indique si les valeurs de deux objets Guid spécifiés sont égaux.

GreaterThan(Guid, Guid)

Compare deux valeurs pour déterminer laquelle est supérieure.

GreaterThanOrEqual(Guid, Guid)

Compare deux valeurs pour déterminer laquelle est supérieure ou égale.

Inequality(Guid, Guid)

Indique si les valeurs de deux objets Guid spécifiés ne sont pas égaux.

LessThan(Guid, Guid)

Compare deux valeurs pour déterminer laquelle est inférieure.

LessThanOrEqual(Guid, Guid)

Compare deux valeurs pour déterminer laquelle est inférieure ou égale.

Implémentations d’interfaces explicites

IComparable.CompareTo(Object)

Compare cette instance à un objet Guid spécifié et retourne une indication de leurs valeurs relatives.

IFormattable.ToString(String, IFormatProvider)

Retourne une représentation sous forme de chaîne de la valeur de cette instance, selon le spécificateur de format et les informations de mise en forme propres à la culture fournis.

ISpanFormattable.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Tente de mettre en forme la valeur du instance actuel dans l’étendue de caractères fournie.

IUtf8SpanFormattable.TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Tente de mettre en forme la valeur de la instance actuelle en UTF-8 dans l’étendue d’octets fournie.

S’applique à