Como validar o GUID é um GUID

Como determinar se uma string contém um GUID versus apenas uma string de números.

um GUID sempre conterá pelo menos 1 caractere alfa?

Veja se isso ajuda: -

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 estou apenas testando uma string para ver se é um GUID, realmente não quero criar um objeto Guid de que não preciso. Assim...

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

E aqui está como você o usa:

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

Um GUID é um número de 16 bytes (128 bits), normalmente representado por uma seqüência hexadecimal de 32 caracteres. Um GUID (em formato hexadecimal) não precisa conter nenhum caractere alfa, embora provavelmente contenha. Se você tem como alvo um GUID em formato hexadecimal, pode verificar se a string tem 32 caracteres (depois de retirar os traços e chaves) e tem apenas letras AF e números.

Há um certo estilo de apresentação de GUIDs (posicionamento do traço) e expressões regulares podem ser usadas para verificar isso, por exemplo,

@"^(\{{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 . Dito isso, deve-se enfatizar que o GUID é realmente um número de 128 bits e pode ser representado de várias maneiras diferentes.

Não há garantia de que um GUID contenha caracteres alfabéticos. FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFFé um GUID válido 00000000-0000-0000-0000-000000000000e qualquer coisa entre eles.

Se estiver usando o .NET 4.0, você pode usar a resposta acima para o Guid.Parse e Guid.ExperimenteParse. Caso contrário, você pode fazer algo assim:

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

Com base na resposta aceita, criei um método de extensão da seguinte forma:

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

Onde "MagicNumbers.defaultGuid" é apenas "um Guid vazio" totalmente zero "00000000-0000-0000-0000-000000000000".

No meu caso, retornar esse valor como resultado de uma conversão inválida de ToGuid não foi um problema.

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

Não há garantia de que um alfa realmente estará lá.

Retornará o Guid se for um Guid válido, senão retornará Guid.Empty

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

if (MyGuid! = Guild.Empty)

{

// Guilda válida

}

outro {

// Guilda inválida

}

Use a funcionalidade padrão do construtor 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