Guid Struct

Definizione

Rappresenta un identificatore univoco globale (GUID).

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
Ereditarietà
Attributi
Implementazioni

Esempio

Nell'esempio seguente viene usata la System.Runtime.InteropServices.GuidAttribute classe per assegnare un GUID a un'interfaccia e a una classe definita dall'utente. Recupera il valore del GUID chiamando il GetCustomAttribute metodo e lo confronta con due altri GUID per determinare se sono uguali.

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

Si noti che l'attributo GuidAttribute viene in genere usato in un'applicazione per esporre un tipo a COM. Se si compila questo esempio, è possibile eseguire lo strumento Registrazione assembly (Regasm.exe) nell'assembly generato per creare file del Registro di sistema (.reg) e libreria dei tipi (con estensione tlb). Il file reg può essere usato per registrare la coclasse nel Registro di sistema e il file tlb può fornire metadati per l'interoperabilità COM.

Commenti

Un GUID è un intero a 128 bit (16 byte) che può essere usato in tutti i computer e nelle reti ovunque sia necessario un identificatore univoco. Tale identificatore ha una probabilità molto bassa di essere duplicata.

Costruttori

Guid(Byte[])

Inizializza una nuova istanza della struttura Guid con la matrice di byte specificata.

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

Inizializza una nuova istanza della struttura Guid usando gli interi e i byte specificati.

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

Inizializza una nuova istanza della struttura Guid usando gli interi e la matrice di byte specificati.

Guid(ReadOnlySpan<Byte>)

Inizializza una nuova istanza della struttura Guid con il valore rappresentato dall'intervallo di byte di sola lettura specificato.

Guid(String)

Inizializza una nuova istanza della struttura Guid con il valore rappresentato dalla stringa specificata.

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

Inizializza una nuova istanza della struttura Guid usando gli interi senza segno e i byte specificati.

Campi

Empty

Istanza di sola lettura della struttura Guid, i cui valori sono tutti pari a zero.

Metodi

CompareTo(Guid)

Confronta questa istanza con un oggetto Guid specificato e restituisce un'indicazione dei valori relativi.

CompareTo(Object)

Confronta questa istanza con un oggetto specificato e restituisce un'indicazione dei valori relativi.

Equals(Guid)

Restituisce un valore che indica se l'istanza e un oggetto Guid specificato rappresentano lo stesso valore.

Equals(Object)

Restituisce un valore che indica se questa istanza è uguale a un oggetto specificato.

GetHashCode()

Restituisce il codice hash per l'istanza.

NewGuid()

Inizializza una nuova istanza della struttura Guid.

Parse(ReadOnlySpan<Char>)

Converte un intervallo di caratteri di sola lettura che rappresenta un GUID nella struttura Guid equivalente.

Parse(ReadOnlySpan<Char>, IFormatProvider)

Analizza un intervallo di caratteri in un valore.

Parse(String)

Converte la rappresentazione di stringa di un GUID nella struttura Guid equivalente.

Parse(String, IFormatProvider)

Analizza una stringa in un valore.

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

Converte la rappresentazione in forma di intervallo di caratteri di un GUID nella struttura Guid equivalente, purché la stringa sia nel formato specificato.

ParseExact(String, String)

Converte la rappresentazione di stringa di un GUID nella struttura Guid equivalente, purché la stringa sia nel formato specificato.

ToByteArray()

Restituisce una matrice di byte a 16 elementi che contiene il valore di questa istanza.

ToString()

Restituisce una rappresentazione di stringa del valore di questa istanza nel formato del Registro di sistema.

ToString(String)

Restituisce una rappresentazione di stringa del valore di questa istanza Guid, in base all'identificatore di formato specificato.

ToString(String, IFormatProvider)

Restituisce una rappresentazione di stringa del valore di questa istanza della classe Guid, in base all'identificatore di formato fornito e alle informazioni di formato specifiche delle impostazioni cultura.

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

Tenta di formattare l'istanza corrente del GUID nell'intervallo di caratteri specificato.

TryParse(ReadOnlySpan<Char>, Guid)

Converte l'intervallo di sola lettura specificato di caratteri contenenti la rappresentazione di un GUID nella struttura Guid equivalente.

TryParse(ReadOnlySpan<Char>, IFormatProvider, Guid)

Tenta di analizzare un intervallo di caratteri in un valore.

TryParse(String, Guid)

Converte la rappresentazione di stringa di un GUID nella struttura Guid equivalente.

TryParse(String, IFormatProvider, Guid)

Prova a analizzare una stringa in un valore.

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

Converte l'intervallo di caratteri che rappresenta il GUID nella struttura Guid equivalente, purché la stringa sia nel formato specificato.

TryParseExact(String, String, Guid)

Converte la rappresentazione di stringa di un GUID nella struttura Guid equivalente, purché la stringa sia nel formato specificato.

TryWriteBytes(Span<Byte>)

Tenta di scrivere l'istanza del GUID corrente in un intervallo di byte.

Operatori

Equality(Guid, Guid)

Indica se i valori di due oggetti Guid specificati sono uguali.

GreaterThan(Guid, Guid)

Confronta due valori per determinare quale è maggiore.

GreaterThanOrEqual(Guid, Guid)

Confronta due valori per determinare quale è maggiore o uguale.

Inequality(Guid, Guid)

Indica se i valori di due oggetti Guid specificati non sono uguali.

LessThan(Guid, Guid)

Confronta due valori per determinare quali sono meno.

LessThanOrEqual(Guid, Guid)

Confronta due valori per determinare quale è minore o uguale.

Implementazioni dell'interfaccia esplicita

IComparable.CompareTo(Object)

Confronta questa istanza con un oggetto Guid specificato e restituisce un'indicazione dei valori relativi.

IFormattable.ToString(String, IFormatProvider)

Restituisce una rappresentazione di stringa del valore di questa istanza, in base all'identificatore di formato specificato e alle informazioni di formato specifiche delle impostazioni cultura.

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

Tenta di formattare il valore dell'istanza corrente nell'intervallo di caratteri specificato.

Si applica a