Guid.TryParseExact Método

Definición

Espacio de nombres:

System

Ensamblado:

System.Runtime.dll

Sobrecargas

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.

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

Source:

Guid.cs

Convierte el intervalo de caracteres que representa el GUID en la estructura Guid equivalente, siempre y cuando la cadena tenga el formato especificado.

public:
 static bool TryParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, [Runtime::InteropServices::Out] Guid % result);

public static bool TryParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, out Guid result);

static member TryParseExact : ReadOnlySpan<char> * ReadOnlySpan<char> * Guid -> bool

Public Shared Function TryParseExact (input As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char), ByRef result As Guid) As Boolean

Parámetros

input

ReadOnlySpan<Char>

Intervalo de solo lectura que contiene los caracteres que representan el GUID que se va a convertir.

format

ReadOnlySpan<Char>

Intervalo de solo lectura que contiene un carácter que representa uno de los siguientes especificadores que indica el formato exacto que se va a usar al interpretar input: "N", "D", "B", "P" o "X".

result

Guid

Cuando este método devuelve un resultado, contiene el valor analizado. Si el método devuelve true, result contiene un Guidválido. Si el método devuelve false, result es igual a Empty.

Devoluciones

Boolean

Es true si la operación de análisis se realizó correctamente; de lo contrario, es false.

TryParseExact(String, String, Guid)

Source:

Guid.cs

Convierte la representación de cadena de un identificador GUID en la estructura Guid equivalente, siempre y cuando la cadena tenga el formato especificado.

public:
 static bool TryParseExact(System::String ^ input, System::String ^ format, [Runtime::InteropServices::Out] Guid % result);

public static bool TryParseExact (string? input, string? format, out Guid result);

static member TryParseExact : string * string * Guid -> bool

Public Shared Function TryParseExact (input As String, format As String, ByRef result As Guid) As Boolean

Parámetros

input

String

Hora GUID que se va a convertir.

format

String

Uno de los siguientes especificadores que indica el formato exacto que se va a usar al interpretar input: "N", "D", "B", "P" o "X".

result

Guid

Cuando este método devuelve un resultado, contiene el valor analizado. Si el método devuelve true, result contiene un Guidválido. Si el método devuelve false, result es igual a Empty.

Devoluciones

Boolean

Es true si la operación de análisis se realizó correctamente; de lo contrario, es false.

Ejemplos

En el ejemplo siguiente se llama al ToString(String) método con cada uno de los especificadores de formato admitidos para generar una matriz de cadenas que representan un único GUID. A continuación, se pasan al TryParseExact método , que analiza correctamente la cadena que se ajusta al especificador de formato "B".

// Define an array of all format specifiers.
string[] formats = { "N", "D", "B", "P", "X" };
Guid guid = Guid.NewGuid();
// Create an array of valid Guid string representations.
var stringGuids = new string[formats.Length];
for (int ctr = 0; ctr < formats.Length; ctr++)
    stringGuids[ctr] = guid.ToString(formats[ctr]);

// Parse the strings in the array using the "B" format specifier.
foreach (var stringGuid in stringGuids)
{
    if (Guid.TryParseExact(stringGuid, "B", out var newGuid))
        Console.WriteLine($"Successfully parsed {stringGuid}");
    else
        Console.WriteLine($"Unable to parse '{stringGuid}'");
}

// The example displays output similar to the following:
//
//    Unable to parse 'c0fb150f6bf344df984a3a0611ae5e4a'
//    Unable to parse 'c0fb150f-6bf3-44df-984a-3a0611ae5e4a'
//    Successfully parsed {c0fb150f-6bf3-44df-984a-3a0611ae5e4a}
//    Unable to parse '(c0fb150f-6bf3-44df-984a-3a0611ae5e4a)'
//    Unable to parse '{0xc0fb150f,0x6bf3,0x44df,{0x98,0x4a,0x3a,0x06,0x11,0xae,0x5e,0x4a}}'

open System

// Define an array of all format specifiers.
let formats = [| "N"; "D"; "B"; "P"; "X" |]

let guid = Guid.NewGuid()

// Create an array of valid Guid string representations.
let stringGuids = 
    Array.map guid.ToString formats

// Parse the strings in the array using the "B" format specifier.
for stringGuid in stringGuids do
    match Guid.TryParseExact(stringGuid, "B") with
    | true, newGuid ->
        printfn $"Successfully parsed {stringGuid}"
    | _ ->
        printfn $"Unable to parse '{stringGuid}'"

// The example displays output similar to the following:
//
//    Unable to parse 'c0fb150f6bf344df984a3a0611ae5e4a'
//    Unable to parse 'c0fb150f-6bf3-44df-984a-3a0611ae5e4a'
//    Successfully parsed {c0fb150f-6bf3-44df-984a-3a0611ae5e4a}
//    Unable to parse '(c0fb150f-6bf3-44df-984a-3a0611ae5e4a)'
//    Unable to parse '{0xc0fb150f,0x6bf3,0x44df,{0x98,0x4a,0x3a,0x06,0x11,0xae,0x5e,0x4a}}'

Module Example
   Public Sub Main()
      ' Define an array of all format specifiers.
      Dim formats() As String = { "N", "D", "B", "P", "X" }
      Dim guid As Guid = Guid.NewGuid()
      ' Create an array of valid Guid string representations.
      Dim stringGuids(formats.Length - 1) As String
      For ctr As Integer = 0 To formats.Length - 1
         stringGuids(ctr) = guid.ToString(formats(ctr))
      Next

      ' Try to parse the strings in the array using the "B" format specifier.
      For Each stringGuid In stringGuids
         Dim newGuid As Guid
         If Guid.TryParseExact(stringGuid, "B", newGuid) Then
            Console.WriteLine("Successfully parsed {0}", stringGuid)
         Else
            Console.WriteLine("Unable to parse '{0}'", stringGuid)
         End If   
      Next      
   End Sub
End Module
' The example displays the following output:
'    Unable to parse 'c0fb150f6bf344df984a3a0611ae5e4a'
'    Unable to parse 'c0fb150f-6bf3-44df-984a-3a0611ae5e4a'
'    Successfully parsed {c0fb150f-6bf3-44df-984a-3a0611ae5e4a}
'    Unable to parse '(c0fb150f-6bf3-44df-984a-3a0611ae5e4a)'
'    Unable to parse '{0xc0fb150f,0x6bf3,0x44df,{0x98,0x4a,0x3a,0x06,0x11,0xae,0x5e,0x4a}}'

Comentarios

Este método requiere que la cadena se convierta exactamente en el formato especificado por el format parámetro , después de quitar los caracteres de espacio en blanco iniciales y finales. Devuelve false si input es null o no está en el formato especificado por formaty no produce una excepción.

En la tabla siguiente se muestran los especificadores de formato aceptados para el format parámetro . "0" representa un dígito; Los guiones ("-"), las llaves ("{", "}") y los paréntesis ("(", ")") aparecen como se muestra.

Especificador	Formato del input parámetro
N	32 dígitos: 00000000000000000000000000000000
D	32 dígitos separados por guiones: 00000000-0000-0000-0000-000000000000
B	32 dígitos separados por guiones, entre llaves: {00000000-0000-0000-0000-000000000000}
P	32 dígitos separados por guiones, entre paréntesis: (00000000-0000-0000-0000-000000000000)
X	Cuatro valores hexadecimales entre llaves, donde el cuarto valor es un subconjunto de ocho valores hexadecimales que también se incluyen entre llaves: {0x00000000,0x0000,0x0000,{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}}

Consulte también

• ParseExact(String, String)