Come convalidare il GUID è un GUID

Come determinare se una stringa contiene un GUID rispetto a solo una stringa di numeri.

un GUID conterrà sempre almeno 1 carattere alfa?

Vedi se questi aiutano: -

Guid guidResult = Guid.Parse(inputString)

( http://msdn.microsoft.com/en-us/library/system.guid.parse.aspx )

bool isValid = Guid.TryParse(inputString, out guidOutput)

http://msdn.microsoft.com/en-us/library/system.guid.tryparse.aspx

Quando sto solo testando una stringa per vedere se è un GUID, non voglio davvero creare un oggetto Guid di cui non ho bisogno. Così...

public static class GuidEx
{
    public static bool IsGuid(string value)
    {
        Guid x;
        return Guid.TryParse(value, out x);
    }
}

Ed ecco come lo usi:

string testMe = "not a guid";
if (GuidEx.IsGuid(testMe))
{
...
}

Un GUID è un numero a 16 byte (128 bit), tipicamente rappresentato da una stringa esadecimale di 32 caratteri. Un GUID (in formato esadecimale) non deve contenere caratteri alfabetici, anche se probabilmente lo farebbe. Se stai mirando a un GUID in formato esadecimale, puoi verificare che la stringa sia lunga 32 caratteri (dopo aver eliminato i trattini e le parentesi graffe) e abbia solo lettere AF e numeri.

Esiste un certo stile di presentazione dei GUID (posizionamento dei trattini) e le espressioni regolari possono essere utilizzate per verificarlo, ad es.

@"^(\{{0,1}([0-9a-fA-F]){8}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){12}\}{0,1})$"

da http://www.geekzilla.co.uk/view8AD536EF-BC0D-427F-9F15-3A1BC663848E.htm . Detto questo, va sottolineato che il GUID è in realtà un numero a 128 bit e potrebbe essere rappresentato in diversi modi.

Non vi è alcuna garanzia che un GUID contenga caratteri alfabetici. FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFFè un GUID valido così è 00000000-0000-0000-0000-000000000000e qualsiasi altra via di mezzo.

Se stai usando .NET 4.0, puoi usare la risposta sopra per Guid.Parse e Guid.TryParse. Altrimenti, puoi fare qualcosa del genere:

public static bool TryParseGuid(string guidString, out Guid guid)
{
    if (guidString == null) throw new ArgumentNullException("guidString");
    try
    {
        guid = new Guid(guidString);
        return true;
    }
    catch (FormatException)
    {
        guid = default(Guid);
        return false;
    }
}

Sulla base della risposta accettata, ho creato un metodo di estensione come segue:

public static Guid ToGuid(this string aString)
{
    Guid newGuid;

    if (string.IsNullOrWhiteSpace(aString))
    {
        return MagicNumbers.defaultGuid;
    }

    if (Guid.TryParse(aString, out newGuid))
    {
        return newGuid;
    }

    return MagicNumbers.defaultGuid;
}

Dove "MagicNumbers.defaultGuid" è solo "un vuoto" tutto zero Guid "00000000-0000-0000-0000-000000000000".

Nel mio caso, restituire quel valore come risultato di una conversione ToGuid non valida non è stato un problema.

vedi http://en.wikipedia.org/wiki/Globally_unique_identifier

Non vi è alcuna garanzia che un alfa sarà effettivamente presente.

Restituirà il Guid se è Guid valido, altrimenti restituirà Guid.Empty

if (!Guid.TryParse(yourGuidString, out yourGuid)){
          yourGuid= Guid.Empty;
}

if (MyGuid! = Guild.Empty)

{

// Valid Guild

}

altro {

// Gilda non valida

}

Utilizza la funzionalità standard del costruttore GUID

Public Function IsValid(pString As String) As Boolean

    Try
        Dim mGuid As New Guid(pString)
    Catch ex As Exception
        Return False
    End Try
    Return True

End Function