Guid.ParseExact Metodo

Riferimento

Definizione

Spazio dei nomi:: System

Assembly:: System.Runtime.dll

Assembly:: netstandard.dll

Assembly:: mscorlib.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Overload

ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Converte la rappresentazione in forma di intervallo di caratteri di un GUID nella struttura Guid equivalente, purché la stringa sia nel formato specificato.
ParseExact(String, String)	Converte la rappresentazione di stringa di un GUID nella struttura Guid equivalente, purché la stringa sia nel formato specificato.

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

Converte la rappresentazione in forma di intervallo di caratteri di un GUID nella struttura Guid equivalente, purché la stringa sia nel formato specificato.

public:
 static Guid ParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format);

public static Guid ParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format);

static member ParseExact : ReadOnlySpan<char> * ReadOnlySpan<char> -> Guid

Public Shared Function ParseExact (input As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char)) As Guid

Parametri

input: ReadOnlySpan<Char>

Intervallo di sola lettura contenente i caratteri che rappresentano il GUID da convertire.

format: ReadOnlySpan<Char>

Intervallo di sola lettura di caratteri che rappresenta uno degli identificatori seguenti che indica il formato esatto da usare durante l'interpretazione di input: "N", "D", "B", "P" o "X".

Restituisce

Guid

Struttura che contiene il valore analizzato.

Commenti

Il ParseExact metodo richiede che l'intervallo di caratteri di sola lettura venga convertito esattamente nel formato specificato dal format parametro , dopo la rimozione di spazi vuoti iniziali e finali. Nella tabella seguente vengono illustrati gli identificatori di formato accettati per il format parametro . "0" rappresenta una cifra; i trattini ("-"), le parentesi graffe ("{", "}") e le parentesi ("(", ")") vengono visualizzate come illustrato.

Identificatore	Formato del `input` parametro
N	32 cifre esadecimali: 00000000000000000000000000000000
D	32 cifre esadecimali separate da trattini: 00000000-0000-0000-0000-000000000000
B	32 cifre esadecimali separate da trattini, racchiuse tra parentesi graffe: {00000000-0000-0000-0000-000000000000}
P	32 cifre esadecimali separate da trattini, racchiuse tra parentesi: (00000000-0000-0000-0000-000000000000)
X	Quattro valori esadecimali racchiusi tra parentesi graffe, dove il quarto valore è un subset di otto valori esadecimali racchiusi tra parentesi graffe: {0x00000000,0x0000,0x0000,{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}}

Si applica a

ParseExact(String, String)

Converte la rappresentazione di stringa di un GUID nella struttura Guid equivalente, purché la stringa sia nel formato specificato.

public:
 static Guid ParseExact(System::String ^ input, System::String ^ format);

public static Guid ParseExact (string input, string format);

static member ParseExact : string * string -> Guid

Public Shared Function ParseExact (input As String, format As String) As Guid

Parametri

input: String

GUID da convertire.

format: String

Uno dei seguenti identificatori, che indica il formato esatto da usare durante l'interpretazione di input: "N", "D", "B", "P" o "X".

Restituisce

Guid

Struttura che contiene il valore analizzato.

Eccezioni

ArgumentNullException

input o format è null.

FormatException

input non è nel formato specificato da format.

Esempio

Nell'esempio seguente viene chiamato il ToString(String) metodo con ognuno degli identificatori di formato supportati per generare una matrice di stringhe che rappresentano un singolo GUID. Questi vengono quindi passati al ParseExact metodo , che analizza correttamente solo la stringa conforme all'identificatore di 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)
{
    try
    {
        Guid newGuid = Guid.ParseExact(stringGuid, "B");
        Console.WriteLine($"Successfully parsed {stringGuid}");
    }
    catch (ArgumentNullException)
    {
        Console.WriteLine("The string to be parsed is null.");
    }
    catch (FormatException)
    {
        Console.WriteLine($"Bad Format: {stringGuid}");
    }
}

// The example displays output similar to the following:
//
//    Bad Format: eb5c8c7d187a44e68afb81e854c39457
//    Bad Format: eb5c8c7d-187a-44e6-8afb-81e854c39457
//    Successfully parsed {eb5c8c7d-187a-44e6-8afb-81e854c39457}
//    Bad Format: (eb5c8c7d-187a-44e6-8afb-81e854c39457)
//    Bad Format: {0xeb5c8c7d,0x187a,0x44e6,{0x8a,0xfb,0x81,0xe8,0x54,0xc3,0x94,0x57}}

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
    try
        let newGuid = Guid.ParseExact(stringGuid, "B")
        printfn $"Successfully parsed {stringGuid}"
    with
    | :? ArgumentNullException ->
        printfn "The string to be parsed is null."
    | :? FormatException ->
        printfn $"Bad Format: {stringGuid}"

// The example displays output similar to the following:
//
//    Bad Format: eb5c8c7d187a44e68afb81e854c39457
//    Bad Format: eb5c8c7d-187a-44e6-8afb-81e854c39457
//    Successfully parsed {eb5c8c7d-187a-44e6-8afb-81e854c39457}
//    Bad Format: (eb5c8c7d-187a-44e6-8afb-81e854c39457)
//    Bad Format: {0xeb5c8c7d,0x187a,0x44e6,{0x8a,0xfb,0x81,0xe8,0x54,0xc3,0x94,0x57}}

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

      ' Parse the strings in the array using the "B" format specifier.
      For Each stringGuid In stringGuids
         Try
            Dim newGuid As Guid = Guid.ParseExact(stringGuid, "B")
            Console.WriteLine("Successfully parsed {0}", stringGuid)
         Catch e As ArgumentNullException
            Console.WriteLine("The string to be parsed is null.")
         Catch e As FormatException
            Console.WriteLine("Bad Format: {0}", stringGuid)
         End Try   
      Next      
   End Sub
End Module
' The example displays the following output:
'    Bad Format: 3351d3f0006747089ff928b5179b2051
'    Bad Format: 3351d3f0-0067-4708-9ff9-28b5179b2051
'    Successfully parsed {3351d3f0-0067-4708-9ff9-28b5179b2051}
'    Bad Format: (3351d3f0-0067-4708-9ff9-28b5179b2051)
'    Bad Format: {0x3351d3f0,0x0067,0x4708,{0x9f,0xf9,0x28,0xb5,0x17,0x9b,0x20,0x51}}

Commenti

Il ParseExact metodo richiede che la stringa venga convertita esattamente nel formato specificato dal format parametro , dopo la rimozione di spazi vuoti iniziali e finali. Nella tabella seguente vengono illustrati gli identificatori di formato accettati per il format parametro . "0" rappresenta una cifra; i trattini ("-"), le parentesi graffe ("{", "}") e le parentesi ("(", ")") vengono visualizzate come illustrato.

Identificatore	Formato del `input` parametro
N	32 cifre esadecimali: 00000000000000000000000000000000
D	32 cifre esadecimali separate da trattini: 00000000-0000-0000-0000-000000000000
B	32 cifre esadecimali separate da trattini, racchiuse tra parentesi graffe: {00000000-0000-0000-0000-000000000000}
P	32 cifre esadecimali separate da trattini, racchiuse tra parentesi: (00000000-0000-0000-0000-000000000000)
X	Quattro valori esadecimali racchiusi tra parentesi graffe, dove il quarto valore è un subset di otto valori esadecimali racchiusi tra parentesi graffe: {0x00000000,0x0000,0x0000,{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}}

Vedi anche

TryParseExact(String, String, Guid)

Si applica a

Condividi tramite

Guid.ParseExact Metodo

Definizione

Overload

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

Parametri

Restituisce

Commenti

Si applica a

ParseExact(String, String)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Vedi anche

Si applica a

Risorse aggiuntive