Comment valider le GUID est un GUID

Comment déterminer si une chaîne contient un GUID par rapport à une simple chaîne de nombres.

un GUID contiendra-t-il toujours au moins 1 caractère alpha?

Voyez si cela aide: -

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

Lorsque je teste simplement une chaîne pour voir s'il s'agit d'un GUID, je ne veux pas vraiment créer un objet Guid dont je n'ai pas besoin. Alors...

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

Et voici comment vous l'utilisez:

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

Un GUID est un nombre de 16 octets (128 bits), généralement représenté par une chaîne hexadécimale de 32 caractères. Un GUID (au format hexadécimal) n'a pas besoin de contenir de caractères alpha, bien que par hasard il le ferait probablement. Si vous ciblez un GUID au format hexadécimal, vous pouvez vérifier que la chaîne comporte 32 caractères (après avoir supprimé les tirets et les accolades) et ne contient que les lettres AF et les chiffres.

Il existe un certain style de présentation des GUID (placement de tirets) et des expressions régulières peuvent être utilisées pour vérifier cela, par exemple,

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

sur http://www.geekzilla.co.uk/view8AD536EF-BC0D-427F-9F15-3A1BC663848E.htm . Cela dit, il convient de souligner que le GUID est vraiment un nombre de 128 bits et peut être représenté de différentes manières.

Il n'y a aucune garantie qu'un GUID contienne des caractères alphabétiques. FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFFest un GUID valide ainsi 00000000-0000-0000-0000-000000000000et tout ce qui se trouve entre les deux.

Si vous utilisez .NET 4.0, vous pouvez utiliser la réponse ci-dessus pour Guid.Parse et Guid.TryParse. Sinon, vous pouvez faire quelque chose comme ceci:

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

Sur la base de la réponse acceptée, j'ai créé une méthode d'extension comme suit:

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

Où "MagicNumbers.defaultGuid" est juste "un Guid vide" tout zéro "00000000-0000-0000-0000-000000000000".

Dans mon cas, renvoyer cette valeur à la suite d'une conversion ToGuid invalide n'était pas un problème.

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

Il n'y a aucune garantie qu'un alpha sera réellement là.

Renverra le Guid s'il est valide, sinon il retournera Guid.

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

if (MonGuide! = Guilde.Vide)

{

// Guilde valide

}

autre {

// Guilde invalide

}

Utiliser la fonctionnalité standard du constructeur 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