Guid Estructura

Definición

Espacio de nombres:

System

Ensamblado:

System.Runtime.dll

Representa un identificador único global (GUID).

public value class Guid : IComparable, IComparable<Guid>, IEquatable<Guid>, IParsable<Guid>, ISpanFormattable, ISpanParsable<Guid>, IUtf8SpanFormattable

public readonly struct Guid : IComparable, IComparable<Guid>, IEquatable<Guid>, IParsable<Guid>, ISpanFormattable, ISpanParsable<Guid>, IUtf8SpanFormattable

type Guid = struct
    interface IFormattable
    interface IParsable<Guid>
    interface ISpanFormattable
    interface ISpanParsable<Guid>
    interface IUtf8SpanFormattable

Public Structure Guid
Implements IComparable, IComparable(Of Guid), IEquatable(Of Guid), IParsable(Of Guid), ISpanFormattable, ISpanParsable(Of Guid), IUtf8SpanFormattable

Herencia

Object

ValueType

Guid

Implementaciones

IComparable IComparable<Guid> IEquatable<Guid> IFormattable ISpanFormattable IParsable<Guid> IParsable<TSelf> ISpanParsable<Guid> IUtf8SpanFormattable

Ejemplos

En el ejemplo siguiente se usa la System.Runtime.InteropServices.GuidAttribute clase para asignar un GUID a una interfaz y a una clase definida por el usuario. Recupera el valor del GUID llamando al GetCustomAttribute método y lo compara con otros dos GUID para determinar si son iguales.

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

Tenga en cuenta que el GuidAttribute atributo se usa normalmente en una aplicación para exponer un tipo a COM. Si compila este ejemplo, puede ejecutar la herramienta Registro de ensamblados (Regasm.exe) en el ensamblado generado para crear archivos del registro (.reg) y de biblioteca de tipos (.tlb). El archivo .reg se puede usar para registrar la coclase en el Registro y el archivo .tlb puede proporcionar metadatos para la interoperabilidad COM.

Comentarios

Un GUID es un entero de 128 bits (16 bytes) que se puede usar en todos los equipos y redes donde se requiera un identificador único. Este identificador tiene una probabilidad muy baja de duplicarse.

Constructores

Guid(Byte[])	Inicializa una nueva instancia de la estructura Guid usando la matriz de bytes especificada.
Guid(Int32, Int16, Int16, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte)	Inicializa una nueva instancia de la estructura Guid usando los enteros y bytes especificados.
Guid(Int32, Int16, Int16, Byte[])	Inicializa una nueva instancia de la estructura Guid usando la matriz de enteros y bytes especificada.
Guid(ReadOnlySpan<Byte>)	Inicializa una nueva instancia de la estructura Guid usando el valor representado por el intervalo de bytes de solo lectura especificado.
Guid(ReadOnlySpan<Byte>, Boolean)	Representa un identificador único global (GUID).
Guid(String)	Inicializa una nueva instancia de la estructura Guid usando el valor representado por la cadena especificada.
Guid(UInt32, UInt16, UInt16, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte)	Inicializa una nueva instancia de la estructura Guid usando los enteros y bytes sin firmar especificados.

Campos

Empty

Instancia de solo lectura de la estructura Guid cuyo valor es todo ceros.

Métodos

CompareTo(Guid)	Compara esta instancia con un objeto Guid especificado y devuelve una indicación de los valores relativos.
CompareTo(Object)	Compara esta instancia con un objeto especificado y devuelve una indicación de los valores relativos.
Equals(Guid)	Devuelve un valor que indica si esta instancia y un objeto Guid especificado representan el mismo valor.
Equals(Object)	Devuelve un valor que indica si esta instancia es igual que un objeto especificado.
GetHashCode()	Devuelve el código hash de esta instancia.
NewGuid()	Inicializa una nueva instancia de la estructura Guid.
Parse(ReadOnlySpan<Char>)	Convierte un intervalo de caracteres de solo lectura que representa un GUID en la estructura Guid equivalente.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Analiza un intervalo de caracteres en un valor.
Parse(String)	Convierte la representación de cadena de un identificador GUID en la estructura Guid equivalente.
Parse(String, IFormatProvider)	Analiza una cadena en un valor.
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Convierte la representación de intervalo de caracteres de un identificador GUID en la estructura Guid equivalente, siempre y cuando la cadena tenga el formato especificado.
ParseExact(String, String)	Convierte la representación de cadena de un identificador GUID en la estructura Guid equivalente, siempre y cuando la cadena tenga el formato especificado.
ToByteArray()	Devuelve una matriz de bytes de 16 elementos que contiene el valor de esta instancia.
ToByteArray(Boolean)	Representa un identificador único global (GUID).
ToString()	Devuelve una representación de cadena del valor de esta instancia con formato del Registro.
ToString(String)	Devuelve una representación de cadena del valor de esta instancia de Guid, de acuerdo con el especificador de formato proporcionado.
ToString(String, IFormatProvider)	Devuelve una representación de cadena del valor de esta instancia de la clase Guid, de acuerdo con el especificador de formato proporcionado y la información de formato específica de la referencia cultural.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>)	Representa un identificador único global (GUID).
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>)	Intenta dar formato a la instancia de GUID actual en el intervalo de caracteres especificado.
TryParse(ReadOnlySpan<Char>, Guid)	Convierte el intervalo de caracteres de solo lectura especificado que contiene la representación de un GUID en la estructura Guid equivalente.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Guid)	Intenta analizar un intervalo de caracteres en un valor.
TryParse(String, Guid)	Convierte la representación de cadena de un identificador GUID en la estructura Guid equivalente.
TryParse(String, IFormatProvider, Guid)	Intenta analizar una cadena en un valor.
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, Guid)	Convierte el intervalo de caracteres que representa el GUID en la estructura Guid equivalente, siempre y cuando la cadena tenga el formato especificado.
TryParseExact(String, String, Guid)	Convierte la representación de cadena de un identificador GUID en la estructura Guid equivalente, siempre y cuando la cadena tenga el formato especificado.
TryWriteBytes(Span<Byte>)	Intenta escribir la instancia de GUID actual en un intervalo de bytes.
TryWriteBytes(Span<Byte>, Boolean, Int32)	Representa un identificador único global (GUID).

Operadores

Equality(Guid, Guid)	Indica si los valores de los dos objetos Guid especificados son iguales.
GreaterThan(Guid, Guid)	Compara dos valores para determinar cuál es mayor.
GreaterThanOrEqual(Guid, Guid)	Compara dos valores para determinar cuál es mayor o igual.
Inequality(Guid, Guid)	Indica si los valores de los dos objetos Guid especificados no son iguales.
LessThan(Guid, Guid)	Compara dos valores para determinar cuál es menor.
LessThanOrEqual(Guid, Guid)	Compara dos valores para determinar cuál es menor o igual.

Implementaciones de interfaz explícitas

ISpanFormattable.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Intenta dar formato al valor de la instancia actual en el intervalo de caracteres proporcionado.
IUtf8SpanFormattable.TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Intenta dar formato al valor de la instancia actual como UTF-8 en el intervalo de bytes proporcionado.