Cómo validar GUID es un GUID

Respuestas:

9

Cuando solo estoy probando una cadena para ver si es un GUID, realmente no quiero crear un objeto Guid que no necesito. Entonces...

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

Y así es como se usa:

string testMe = "not a guid";
if (GuidEx.IsGuid(testMe))
{
...
}
Doug Clutter
fuente
5
actualización para 2018return Guid.TryParse(value, out var _);
espere el
7

Un GUID es un número de 16 bytes (128 bits), normalmente representado por una cadena hexadecimal de 32 caracteres. Un GUID (en formato hexadecimal) no necesita contener ningún carácter alfabético, aunque por casualidad probablemente lo haría. Si está apuntando a un GUID en forma hexadecimal, puede verificar que la cadena tenga 32 caracteres (después de quitar los guiones y los corchetes) y solo tenga letras AF y números.

Existe cierto estilo de presentación de GUID (colocación de guiones) y se pueden usar expresiones regulares para verificar esto, por ejemplo,

@"^(\{{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})$"

de http://www.geekzilla.co.uk/view8AD536EF-BC0D-427F-9F15-3A1BC663848E.htm . Dicho esto, debe enfatizarse que el GUID realmente es un número de 128 bits y podría representarse de varias formas diferentes.

tofutim
fuente
6

No hay garantía de que un GUID contenga caracteres alfabéticos. FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFFes un GUID válido, por lo que es 00000000-0000-0000-0000-000000000000y cualquier cosa intermedia.

Si está utilizando .NET 4.0, puede utilizar la respuesta anterior para Guid.Parse y Guid.TryParse. De lo contrario, puede hacer algo como esto:

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;
    }
}
Puede gencer
fuente
2

Según la respuesta aceptada, creé un método de extensión de la siguiente manera:

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;
}

Donde "MagicNumbers.defaultGuid" es simplemente "un Guid vacío" todo cero "00000000-0000-0000-0000-000000000000".

En mi caso, devolver ese valor como resultado de una conversión ToGuid no válida no fue un problema.

a4bike
fuente
2
¿Por qué usar MagicNumbers en lugar de Guid.Empty?
Mattumotu
1

Devolverá el Guid si es válido; de lo contrario, devolverá el Guid.

if (!Guid.TryParse(yourGuidString, out yourGuid)){
          yourGuid= Guid.Empty;
}
maníaco
fuente
1

si (MyGuid! = Guild.Empty)

{

// Gremio válido

}

else {

// Gremio no válido

}

Sameer Bahad
fuente
0

Usar la funcionalidad estándar del constructor 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
xjfw34
fuente
Tenga en cuenta que la pregunta se hizo para el lenguaje C # y la respuesta proporcionada está en VB.Net. Sería bueno mapearlo para C #.
Pimenta