Cómo validar GUID es un GUID

Question

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

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

Answer 1

Ver si estas ayudas: -

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

Answer 2

también se podría utilizar una expresión regular, echar un vistazo a este sitio y haz una búsqueda de guid http://regexlib.com

Answer 3

Un GUID es un número de 16 bytes (128 bits), normalmente representado por una cadena hexadecimal de 32 caracteres. Un GUID (en forma de hex) no necesita contener ningún caracter alfa, aunque por casualidad probablemente lo haga. Si se dirige a un GUID en formato hexadecimal, puede verificar que la cadena tenga 32 caracteres (después de eliminar los guiones y las llaves) y que solo tenga letras A-F y números.

Hay cierto estilo de GUID que presentan (DASH-colocación) y expresiones regulares se pueden utilizar para comprobar para 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 diferentes maneras.

Answer 4

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

No hay ninguna garantía de que un alfa será realmente allí.

Answer 5

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

Si está utilizando .NET 4.0, puede usar 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; 
    } 
} 

Answer 6

devolverá el Guid Guid si es válida, de lo contrario se volverá Guid.Empty

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

Answer 7

Sobre la base de 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 sólo "un vacío" todos cero Guid "00000000-0000-0000-0000-000000000000".

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

Answer 8

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

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

Y aquí es cómo lo usa:

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