Cómo validar GUID es un GUID

Cómo determinar si una cadena contiene un GUID o solo una cadena de números.

¿un GUID siempre contendrá al menos 1 carácter alfabético?

Vea si esto ayuda: -

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

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))
{
...
}

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.

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

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.

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

No hay garantía de que un alfa realmente esté allí.

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

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

si (MyGuid! = Guild.Empty)

{

// Gremio válido

}

else {

// Gremio no válido

}

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