Guid Struktura

Definice

Představuje globálně jedinečný identifikátor (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
Dědičnost
Atributy
Implementuje

Příklady

Následující příklad používá System.Runtime.InteropServices.GuidAttribute třídu k přiřazení identifikátoru GUID k rozhraní a k uživatelem definované třídě. Načte hodnotu identifikátoru GUID voláním GetCustomAttribute metody a porovná ji se dvěma dalšími identifikátory GUID a určí, jestli jsou stejné.

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

Všimněte si, že GuidAttribute atribut se obvykle používá v aplikaci k zveřejnění typu modelu COM. Pokud tento příklad zkompilujete, můžete spustit nástroj Pro registraci sestavení (Regasm.exe) ve vygenerovaném sestavení a vytvořit soubory registru (.reg) a zadat soubory knihovny (.tlb). Soubor .reg lze použít k registraci coclass v registru a soubor .tlb může poskytovat metadata pro spolupráci modelu COM.

Poznámky

Identifikátor GUID je 128bitové celé číslo (16 bajtů), které lze použít ve všech počítačích a sítích, kde je vyžadován jedinečný identifikátor. Takový identifikátor má velmi nízkou pravděpodobnost duplikování.

Konstruktory

Guid(Byte[])

Inicializuje novou instanci Guid struktury pomocí zadaného pole bajtů.

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

Inicializuje novou instanci Guid struktury pomocí zadaných celých čísel a bajtů.

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

Inicializuje novou instanci struktury pomocí zadaných Guid celých čísel a bajtového pole.

Guid(ReadOnlySpan<Byte>)

Inicializuje novou instanci Guid struktury pomocí hodnoty reprezentované zadaným rozsahem jen pro čtení bajtů.

Guid(String)

Inicializuje novou instanci Guid struktury pomocí hodnoty reprezentované zadaným řetězcem.

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

Inicializuje novou instanci Guid struktury pomocí zadaných nepodepsaných celých čísel a bajtů.

Pole

Empty

Instance Guid struktury jen pro čtení, jejíž hodnota je všechna nula.

Metody

CompareTo(Guid)

Porovná tuto instanci se zadaným Guid objektem a vrátí indikaci jejich relativních hodnot.

CompareTo(Object)

Porovná tuto instanci se zadaným objektem a vrací údaj o jejich relativních hodnotách.

Equals(Guid)

Vrátí hodnotu určující, zda tato instance a zadaný Guid objekt představují stejnou hodnotu.

Equals(Object)

Vrací hodnotu, která určuje, zda je tato instance rovna zadanému objektu.

GetHashCode()

Vrátí hodnotu hash pro tuto instanci.

NewGuid()

Inicializuje novou instanci Guid struktury.

Parse(ReadOnlySpan<Char>)

Převede rozsah znaků jen pro čtení, který představuje identifikátor GUID na ekvivalentní Guid strukturu.

Parse(ReadOnlySpan<Char>, IFormatProvider)

Parsuje rozsah znaků do hodnoty.

Parse(String)

Převede řetězcovou reprezentaci identifikátoru GUID na ekvivalentní Guid strukturu.

Parse(String, IFormatProvider)

Parsuje řetězec na hodnotu.

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

Převede reprezentaci rozsahu znaků identifikátoru GUID na ekvivalentní Guid strukturu za předpokladu, že je řetězec v zadaném formátu.

ParseExact(String, String)

Převede řetězcovou reprezentaci identifikátoru GUID na ekvivalentní Guid strukturu za předpokladu, že je řetězec v zadaném formátu.

ToByteArray()

Vrátí pole 16 prvků bajtů, které obsahuje hodnotu této instance.

ToString()

Vrátí řetězcovou reprezentaci hodnoty této instance ve formátu registru.

ToString(String)

Vrátí řetězcovou reprezentaci hodnoty této Guid instance podle zadaného specifikátoru formátu.

ToString(String, IFormatProvider)

Vrátí řetězcovou reprezentaci hodnoty této instance Guid třídy podle zadaného specifikátoru formátu a informací o formátu specifickém pro jazykovou verzi.

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

Pokusí se naformátovat aktuální instanci GUID do zadaného rozsahu znaků.

TryParse(ReadOnlySpan<Char>, Guid)

Převede zadané rozpětí znaků jen pro čtení obsahující reprezentaci identifikátoru GUID na ekvivalentní Guid strukturu.

TryParse(ReadOnlySpan<Char>, IFormatProvider, Guid)

Pokusí se analyzovat rozsah znaků do hodnoty.

TryParse(String, Guid)

Převede řetězcovou reprezentaci identifikátoru GUID na ekvivalentní Guid strukturu.

TryParse(String, IFormatProvider, Guid)

Pokusí se analyzovat řetězec do hodnoty.

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

Převede rozsah znaků představující identifikátor GUID na ekvivalentní Guid strukturu za předpokladu, že je řetězec v zadaném formátu.

TryParseExact(String, String, Guid)

Převede řetězcovou reprezentaci identifikátoru GUID na ekvivalentní Guid strukturu za předpokladu, že je řetězec v zadaném formátu.

TryWriteBytes(Span<Byte>)

Pokusí se napsat aktuální instanci GUID do rozsahu bajtů.

Operátory

Equality(Guid, Guid)

Určuje, zda jsou hodnoty dvou zadaných Guid objektů stejné.

GreaterThan(Guid, Guid)

Porovná dvě hodnoty a určí, která hodnota je větší.

GreaterThanOrEqual(Guid, Guid)

Porovná dvě hodnoty a určí, která hodnota je větší nebo rovna.

Inequality(Guid, Guid)

Určuje, zda se hodnoty dvou zadaných Guid objektů nerovnají.

LessThan(Guid, Guid)

Porovná dvě hodnoty a určí, která hodnota je menší.

LessThanOrEqual(Guid, Guid)

Porovná dvě hodnoty a určí, která hodnota je menší nebo rovna.

Explicitní implementace rozhraní

IComparable.CompareTo(Object)

Porovná tuto instanci se zadaným Guid objektem a vrátí indikaci jejich relativních hodnot.

IFormattable.ToString(String, IFormatProvider)

Vrátí řetězcovou reprezentaci hodnoty této instance podle zadaného specifikátoru formátu a informací o formátu specifickém pro jazykovou verzi.

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

Pokusí se naformátovat hodnotu aktuální instance do zadaného rozsahu znaků.

Platí pro