Cómo validar Guid en .net

Question

Por favor dígame cómo validar GUID en .net y es único para siempre?

Answer 1

Las guías son únicas 99.99999999999999999999999999999999% de las veces.

Depende de lo que signifique por validar?

código para determinar que una cadena GUID es en realidad un Guid, es as follows:

private static Regex isGuid = 
     new Regex(@"^(\{){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}$", RegexOptions.Compiled); 

internal static bool IsGuid(string candidate, out Guid output) 
{ 
    bool isValid = false; 
    output = Guid.Empty; 

    if(candidate != null) 
    { 

     if (isGuid.IsMatch(candidate)) 
     { 
      output=new Guid(candidate); 
      isValid = true; 
     } 
    } 

    return isValid; 
} 

Answer 2

Usted no puede validar la singularidad de GUID. Solo espera que se haya generado con una herramienta que produce 16 bytes únicos. En cuanto a la validación, el código simple podría trabajar (suponiendo que se trata de representación de cadena del GUID:

bool ValidateGuid(string theGuid) 
{ 
    try { Guid aG = new Guid(theGuid); } 
    catch { return false; } 

    return true; 
} 

Answer 3

Si usted está buscando una manera de determinar si es el formato del actual tipo .Net Guid, take a look at this article. Una expresión regular rápida es la que funciona.

Answer 4

2^128 es un número muy, muy grande. Es un billón de veces más grande que el número de picosegundos en la vida del universo. Demasiado grande por una oportunidad remota para validar, la respuesta está condenada a ser "42". Cuál es el punto de usarlos: no es necesario. Si te preocupa obtener duplicados, entonces te preocupas por el motivo equivocado. Las probabilidades de que tu máquina sea destruida por un meteoro acto son considerablemente más grandes.

Duck!

Answer 5

esta pregunta ya fue discutida en this post. Usted puede encontrar los detalles más interesantes

Answer 6

Aquí es una respuesta no-expresión regular que debe ser bastante rápido:

public static bool IsHex(this char c) 
{ 
    return ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')); 
} 

public static bool IsGuid(this string s) 
{ 
    // Length of a proper GUID, without any surrounding braces. 
    const int len_without_braces = 36; 

    // Delimiter for GUID data parts. 
    const char delim = '-'; 

    // Delimiter positions. 
    const int d_0 = 8; 
    const int d_1 = 13; 
    const int d_2 = 18; 
    const int d_3 = 23; 

    // Before Delimiter positions. 
    const int bd_0 = 7; 
    const int bd_1 = 12; 
    const int bd_2 = 17; 
    const int bd_3 = 22; 

    if (s == null) 
     return false; 

    if (s.Length != len_without_braces) 
     return false; 

    if (s[d_0] != delim || 
     s[d_1] != delim || 
     s[d_2] != delim || 
     s[d_3] != delim) 
     return false; 

    for (int i = 0; 
     i < s.Length; 
     i = i + (i == bd_0 || 
       i == bd_1 || 
       i == bd_2 || 
       i == bd_3 
       ? 2 : 1)) 
    { 
     if (!IsHex(s[i])) return false; 
    } 

    return true; 
} 

Answer 7

En .NET 4, se puede utilizar este método de extensión

public static class GuidExtensions 
    { 
     public static bool IsGuid(this string value) 
     { 
      Guid output; 
      return Guid.TryParse(value, out output); 
     } 
    }