Guid Structure

Référence

Définition

Espace de noms:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

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, 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>

[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>

[<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, IFormattable

Héritage: Object

ValueType
Guid

Attributs: SerializableAttribute ComVisibleAttribute

Implémente: IComparable IComparable<Guid> IEquatable<Guid> IFormattable ISpanFormattable IParsable<Guid> IParsable<TSelf> ISpanParsable<Guid>

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 GetCustomAttribute méthode et la 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 COM Interop.

Remarques

Un GUID est un entier 128 bits (16 octets) qui peut être utilisé sur tous les ordinateurs et réseaux 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(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 dans 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.
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<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 dans 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.

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 la valeur la plus élevée.
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 de l’instance actuelle dans l’étendue de caractères fournie.

S’applique à