C # Regex pour Guid

J'ai besoin d'analyser une chaîne et d'ajouter des guillemets simples autour de chaque valeur Guid. Je pensais que je pourrais utiliser un Regex pour faire ça mais je ne suis pas exactement un gourou Regex.

Existe-t-il un bon Regex à utiliser pour identifier un Guid?

Ma deuxième question est une fois que j'ai trouvé une regex valide, je suppose que j'utiliserais Regex.Replace(String, String, MatchEvaluator)mais je ne suis pas tout à fait sûr de la syntaxe. Peut-être quelque chose comme:

return Regex.Replace(stringToFindMatch, GuidRegex, match =>
{
    return string.Format("'{0}'", match.Groups[0].ToString());
});

Une chaîne que j'essaie d'analyser peut ressembler à ceci:

"SELECT passwordco0_.PASSWORD_CONFIG_ID en tant que PASSWORD1_46_0_, FROM PASSWORD_CONFIG passwordco0_ WHERE passwordco0_.PASSWORD_CONFIG_ID = baf04077-a3c0-454b-ac6f-9fec00b8e170-ac6f-9fec00b8e170-ac6b-ac6f-9fec00b8e170; @ p08b-9fec00b8e170 (0)

Celui-ci est assez simple et ne nécessite pas de délégué comme vous le dites.

resultString = Regex.Replace(subjectString, 
     @"(?im)^[{(]?[0-9A-F]{8}[-]?(?:[0-9A-F]{4}[-]?){3}[0-9A-F]{12}[)}]?$", 
     "'$0'");

Cela correspond aux styles suivants, qui sont tous des formats équivalents et acceptables pour un GUID.

ca761232ed4211cebacd00aa0057b223
CA761232-ED42-11CE-BACD-00AA0057B223
{CA761232-ED42-11CE-BACD-00AA0057B223}
(CA761232-ED42-11CE-BACD-00AA0057B223)

Mise à jour 1

@NonStatic fait remarquer dans les commentaires que l'expression rationnelle ci-dessus correspondra aux faux positifs qui ont un délimiteur de fermeture incorrect.

Cela peut être évité par des conditions regex qui sont largement prises en charge.

Les conditions sont prises en charge par le moteur JGsoft, Perl, PCRE, Python et le framework .NET. Ruby les prend en charge à partir de la version 2.0. Les langages tels que Delphi, PHP et R qui ont des fonctionnalités regex basées sur PCRE prennent également en charge les conditions. (source http://www.regular-expressions.info/conditional.html )

La regex qui suit correspondra

{123}
(123)
123

Et ne correspondra pas

{123)
(123}
{123
(123
123}
123)

Regex:

^({)?(\()?\d+(?(1)})(?(2)\))$

Les solutions sont simplifiées pour ne faire correspondre que des nombres pour montrer de manière plus claire ce qui est requis si nécessaire.

La plupart des expressions régulières de base sont les suivantes:

(^([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})$) 

ou vous pouvez le coller ici .

J'espère que cela vous fera gagner du temps.

Pour que C # .Net trouve et remplace toute chaîne de recherche guid à partir du texte donné,

Utilisez ce RegEx:

[({]?[a-fA-F0-9]{8}[-]?([a-fA-F0-9]{4}[-]?){3}[a-fA-F0-9]{12}[})]?

Exemple de code C #:

var result = Regex.Replace(
      source, 
      @"[({]?[a-fA-F0-9]{8}[-]?([a-fA-F0-9]{4}[-]?){3}[a-fA-F0-9]{12}[})]?", 
      @"${ __UUID}", 
      RegexOptions.IgnoreCase
);

Fonctionne sûrement! Et il correspond et remplace les styles suivants, qui sont tous des formats équivalents et acceptables pour un GUID.

"aa761232bd4211cfaacd00aa0057b243" 
"AA761232-BD42-11CF-AACD-00AA0057B243" 
"{AA761232-BD42-11CF-AACD-00AA0057B243}" 
"(AA761232-BD42-11CF-AACD-00AA0057B243)" 

Dans .NET Framework 4, il y a une amélioration de la structure System.Guid, qui inclut les nouvelles méthodes TryParse et TryParseExact pour analyser le GUID. Voici un exemple pour cela.

    //Generate New GUID
    Guid objGuid = Guid.NewGuid();
    //Take invalid guid format
    string strGUID = "aaa-a-a-a-a";

    Guid newGuid;

    if (Guid.TryParse(objGuid.ToString(), out newGuid) == true)
    {
        Response.Write(string.Format("<br/>{0} is Valid GUID.", objGuid.ToString()));
    }
    else
    {
        Response.Write(string.Format("<br/>{0} is InValid GUID.", objGuid.ToString()));
    }


    Guid newTmpGuid;

    if (Guid.TryParse(strGUID, out newTmpGuid) == true)
    {
        Response.Write(string.Format("<br/>{0} is Valid GUID.", strGUID));
    }
    else
    {
        Response.Write(string.Format("<br/>{0} is InValid GUID.", strGUID));
    }

Dans cet exemple, nous créons un nouvel objet guid et prenons également une variable de chaîne dont le guid est invalide. Après cela, nous utilisons la méthode TryParse pour valider que les deux variables ont un format GUID valide ou non. En exécutant l'exemple, vous pouvez voir que la variable de chaîne n'a pas le format GUID valide et qu'elle donne le message "InValid guid". Si la variable de chaîne a un guid valide, cela retournera true dans la méthode TryParse.

Vous pouvez facilement générer automatiquement le code C # en utilisant: http://regexhero.net/tester/ .

C'est gratuit.

Voici comment je l'ai fait:

Le site Web génère ensuite automatiquement le code .NET:

string strRegex = @"\b[A-F0-9]{8}(?:-[A-F0-9]{4}){3}-[A-F0-9]{12}\b";
Regex myRegex = new Regex(strRegex, RegexOptions.None);
string strTargetString = @"     {CD73FAD2-E226-4715-B6FA-14EDF0764162}.Debug|x64.ActiveCfg =         Debug|x64";
string strReplace = @"""$0""";

return myRegex.Replace(strTargetString, strReplace);

J'utilise un modèle de regex plus simple

^[0-9A-Fa-f\-]{36}$