Guid Struktura

Odwołanie

Definicja

Przestrzeń nazw:: System

Zestaw:: System.Runtime.dll

Zestaw:: mscorlib.dll

Zestaw:: netstandard.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Reprezentuje unikatowy identyfikator globalny (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

Dziedziczenie: Object

ValueType
Guid

Atrybuty: SerializableAttribute ComVisibleAttribute

Implementuje: IComparable IComparable<Guid> IEquatable<Guid> IFormattable ISpanFormattable IParsable<Guid> IParsable<TSelf> ISpanParsable<Guid>

Przykłady

W poniższym przykładzie użyto System.Runtime.InteropServices.GuidAttribute klasy do przypisania identyfikatora GUID do interfejsu i do klasy zdefiniowanej przez użytkownika. Pobiera wartość identyfikatora GUID przez wywołanie GetCustomAttribute metody i porównuje ją z dwoma innymi identyfikatorami GUID, aby określić, czy są równe.

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

Należy pamiętać, że GuidAttribute atrybut jest zwykle używany w aplikacji do uwidaczniania typu com. Jeśli skompilujesz ten przykład, możesz uruchomić narzędzie rejestracji zestawów (Regasm.exe) na wygenerowanych zestawach, aby utworzyć pliki rejestru (reg) i biblioteki typów (.tlb). Plik reg może służyć do rejestrowania coklasy w rejestrze, a plik tlb może zapewnić metadane dla międzyoperacyjności MODELU COM.

Uwagi

Identyfikator GUID to 128-bitowa liczba całkowita (16 bajtów), która może być używana we wszystkich komputerach i sieciach wszędzie tam, gdzie wymagany jest unikatowy identyfikator. Taki identyfikator ma bardzo niskie prawdopodobieństwo duplikowania.

Konstruktory

Guid(Byte[])	Inicjuje Guid nowe wystąpienie struktury przy użyciu określonej tablicy bajtów.
Guid(Int32, Int16, Int16, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte)	Inicjuje Guid nowe wystąpienie struktury przy użyciu określonych liczb całkowitych i bajtów.
Guid(Int32, Int16, Int16, Byte[])	Inicjuje nowe wystąpienie Guid struktury przy użyciu określonych liczb całkowitych i tablicy bajtów.
Guid(ReadOnlySpan<Byte>)	Inicjuje nowe wystąpienie Guid struktury przy użyciu wartości reprezentowanej przez określony zakres bajtów tylko do odczytu.
Guid(String)	Inicjuje nowe wystąpienie Guid struktury przy użyciu wartości reprezentowanej przez określony ciąg.
Guid(UInt32, UInt16, UInt16, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte)	Inicjuje nowe wystąpienie Guid struktury przy użyciu określonych niepodpisanych liczb całkowitych i bajtów.

Pola

Empty

Wystąpienie Guid struktury tylko do odczytu, którego wartość to wszystkie zera.

Metody

CompareTo(Guid)	Porównuje to wystąpienie z określonym Guid obiektem i zwraca wskazanie ich wartości względnych.
CompareTo(Object)	Porównuje to wystąpienie z określonym obiektem i zwraca wskazanie ich względnych wartości.
Equals(Guid)	Zwraca wartość wskazującą, czy to wystąpienie i określony Guid obiekt reprezentują tę samą wartość.
Equals(Object)	Zwraca wartość wskazującą, czy to wystąpienie jest równe podanemu obiektowi.
GetHashCode()	Zwraca wartość skrótu dla tego wystąpienia.
NewGuid()	Inicjuje Guid nowe wystąpienie struktury.
Parse(ReadOnlySpan<Char>)	Konwertuje zakres znaków tylko do odczytu, który reprezentuje identyfikator GUID do równoważnej Guid struktury.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Analizuje zakres znaków w wartości.
Parse(String)	Konwertuje reprezentację ciągu identyfikatora GUID na równoważną Guid strukturę.
Parse(String, IFormatProvider)	Analizuje ciąg w wartości.
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Konwertuje reprezentację zakresu znaków identyfikatora GUID na równoważną Guid strukturę, pod warunkiem, że ciąg jest w określonym formacie.
ParseExact(String, String)	Konwertuje reprezentację ciągu identyfikatora GUID na równoważną Guid strukturę, pod warunkiem, że ciąg jest w określonym formacie.
ToByteArray()	Zwraca 16-elementową tablicę bajtów zawierającą wartość tego wystąpienia.
ToString()	Zwraca ciąg reprezentujący wartość tego wystąpienia w formacie rejestru.
ToString(String)	Zwraca reprezentację ciągu wartości tego Guid wystąpienia zgodnie z podanym specyfikatorem formatu.
ToString(String, IFormatProvider)	Zwraca reprezentację ciągu wartości tego wystąpienia Guid klasy zgodnie z podanym specyfikatorem formatu i informacjami o formacie specyficznym dla kultury.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>)	Próbuje sformatować bieżące wystąpienie identyfikatora GUID w podanym zakresie znaków.
TryParse(ReadOnlySpan<Char>, Guid)	Konwertuje określony zakres znaków tylko do odczytu zawierający reprezentację identyfikatora GUID na równoważną Guid strukturę.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Guid)	Próbuje przeanalizować zakres znaków w wartości.
TryParse(String, Guid)	Konwertuje reprezentację ciągu identyfikatora GUID na równoważną Guid strukturę.
TryParse(String, IFormatProvider, Guid)	Próbuje przeanalizować ciąg w wartości.
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, Guid)	Konwertuje zakres znaków reprezentujący identyfikator GUID na równoważną Guid strukturę, pod warunkiem, że ciąg jest w określonym formacie.
TryParseExact(String, String, Guid)	Konwertuje reprezentację ciągu identyfikatora GUID na równoważną Guid strukturę, pod warunkiem, że ciąg jest w określonym formacie.
TryWriteBytes(Span<Byte>)	Próbuje zapisać bieżące wystąpienie identyfikatora GUID w zakresie bajtów.

Operatory

Equality(Guid, Guid)	Wskazuje, czy wartości dwóch określonych Guid obiektów są równe.
GreaterThan(Guid, Guid)	Porównuje dwie wartości, aby określić, które wartości są większe.
GreaterThanOrEqual(Guid, Guid)	Porównuje dwie wartości, aby określić, które wartości są większe lub równe.
Inequality(Guid, Guid)	Wskazuje, czy wartości dwóch określonych Guid obiektów nie są równe.
LessThan(Guid, Guid)	Porównuje dwie wartości, aby określić, które wartości są mniejsze.
LessThanOrEqual(Guid, Guid)	Porównuje dwie wartości, aby określić, które wartości są mniejsze lub równe.

Jawne implementacje interfejsu

IComparable.CompareTo(Object)	Porównuje to wystąpienie z określonym Guid obiektem i zwraca wskazanie ich wartości względnych.
IFormattable.ToString(String, IFormatProvider)	Zwraca reprezentację ciągu wartości tego wystąpienia zgodnie z podanym specyfikatorem formatu i informacjami o formacie specyficznym dla kultury.
ISpanFormattable.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Próbuje sformatować wartość bieżącego wystąpienia w podanym zakresie znaków.

Dotyczy