Guid.TryParseExact Método
Definição
Importante
Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.
Sobrecargas
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, Guid) |
Converte um intervalo de caracteres que representa o GUID na estrutura Guid equivalente, desde que a cadeia de caracteres esteja no formato especificado. |
TryParseExact(String, String, Guid) |
Converte a representação de cadeia de caracteres de um GUID na estrutura Guid equivalente, desde que a cadeia de caracteres esteja no formato especificado. |
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, Guid)
- Origem:
- Guid.cs
- Origem:
- Guid.cs
- Origem:
- Guid.cs
Converte um intervalo de caracteres que representa o GUID na estrutura Guid equivalente, desde que a cadeia de caracteres esteja no 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>
Um intervalo somente leitura que contém os caracteres que representam o GUID a ser convertido.
- format
- ReadOnlySpan<Char>
Um intervalo somente leitura contendo um caractere que representa um dos especificadores a seguir, o qual indica o formato exato a ser usado ao interpretar input
: "N", "D", "B", "P" ou "X".
- result
- Guid
Quando este método retorna, ele contém o valor analisado. Se o método retornar true
, result
conterá um Guid válido. Se o método retornar false
, result
será igual a Empty.
Retornos
true
se a operação de análise for bem-sucedida; caso contrário, false
.
Aplica-se a
TryParseExact(String, String, Guid)
- Origem:
- Guid.cs
- Origem:
- Guid.cs
- Origem:
- Guid.cs
Converte a representação de cadeia de caracteres de um GUID na estrutura Guid equivalente, desde que a cadeia de caracteres esteja no 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);
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
O GUID a converter.
- format
- String
Um dos seguintes especificadores que indica o formato exato a ser usado ao interpretar input
: "N", "D", "B", "P" ou "X".
- result
- Guid
Quando este método retorna, ele contém o valor analisado. Se o método retornar true
, result
conterá um Guid válido. Se o método retornar false
, result
será igual a Empty.
Retornos
true
se a operação de análise for bem-sucedida; caso contrário, false
.
Exemplos
O exemplo a seguir chama o ToString(String) método com cada um dos especificadores de formato com suporte para gerar uma matriz de cadeias de caracteres que representam um único GUID. Em seguida, eles são passados para o TryParseExact método , que analisa com êxito a cadeia de caracteres que está em conformidade com o 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}}'
Comentários
Esse método requer que a cadeia de caracteres seja convertida para estar exatamente no formato especificado pelo parâmetro , depois que caracteres format
de espaço em branco à esquerda e à direita forem removidos. Ele retornará false
se input
estiver null
ou não estiver no formato especificado por format
e não gerar uma exceção.
A tabela a seguir mostra os especificadores de formato aceitos para o parâmetro format
. "0" representa um dígito; hifens ("-"), chaves ("{", "}") e parênteses (“(”, ")”) são exibidos como mostrado.
Especificador | Formato do input parâmetro |
---|---|
N | 32 dígitos: 00000000000000000000000000000000 |
D | 32 dígitos separados por hifens: 00000000-0000-0000-0000-000000000000 |
B | 32 dígitos separados por hifens, entre chaves: {00000000-0000-0000-0000-000000000000} |
P | 32 dígitos separados por hifens, entre parênteses: (00000000-0000-0000-0000-000000000000) |
X | Quatro valores hexadecimais entre chaves, em que o quarto valor é um subconjunto de oito valores hexadecimais que também é incluído entre chaves: {0x00000000,0x0000,0x0000,{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}} |