C # Regex für Guid

Ich muss eine Zeichenfolge analysieren und um jeden Guid-Wert einfache Anführungszeichen setzen. Ich dachte, ich könnte einen Regex verwenden, um dies zu tun, aber ich bin nicht gerade ein Regex-Guru.

Gibt es einen guten Regex, um einen Guid zu identifizieren?

Meine zweite Frage ist, sobald ich einen gültigen regulären Ausdruck gefunden habe, von dem ich annehme, dass ich ihn verwenden würde, Regex.Replace(String, String, MatchEvaluator)aber ich bin mir der Syntax nicht ganz sicher. Vielleicht so etwas wie:

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

Eine Zeichenfolge, die ich zu analysieren versuche, sieht möglicherweise folgendermaßen aus:

"SELECT passwordco0_.PASSWORD_CONFIG_ID als PASSWORD1_46_0_, FROM PASSWORD_CONFIG passwordco0_ WHERE passwordco0_.PASSWORD_CONFIG_ID = baf04077-a3c0-454b-ac6f-9fec00b8e170;

Dieser ist recht einfach und erfordert keinen Delegierten, wie Sie sagen.

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

Dies entspricht den folgenden Stilen, die alle äquivalente und akzeptable Formate für eine GUID sind.

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

Update 1

@NonStatic weist in den Kommentaren darauf hin, dass der obige reguläre Ausdruck mit falsch positiven Ergebnissen übereinstimmt, die ein falsches schließendes Trennzeichen haben.

Dies kann durch Regex-Bedingungen vermieden werden, die weitgehend unterstützt werden.

Bedingungen werden von der JGsoft-Engine, Perl, PCRE, Python und dem .NET-Framework unterstützt. Ruby unterstützt sie ab Version 2.0. Sprachen wie Delphi, PHP und R, deren Regex-Funktionen auf PCRE basieren, unterstützen ebenfalls Bedingungen. (Quelle http://www.regular-expressions.info/conditional.html )

Der folgende reguläre Ausdruck stimmt überein

{123}
(123)
123

Und wird nicht passen

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

Regex:

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

Die Lösungen werden vereinfacht, um nur Zahlen zuzuordnen und klarer zu zeigen, was bei Bedarf erforderlich ist.

Die grundlegendste Regex lautet wie folgt:

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

oder Sie können es hier einfügen .

Hoffe das spart dir etwas Zeit.

Damit C # .Net eine Guid-Zeichenfolge aus dem angegebenen Text findet und ersetzt,

Verwenden Sie dieses RegEx:

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

Beispiel C # -Code:

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

Funktioniert sicher! Und es entspricht und ersetzt die folgenden Stile, die alle äquivalente und akzeptable Formate für eine GUID sind.

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

In .NET Framework 4 gibt es die System.Guid-Erweiterungsstruktur. Dazu gehören die neuen TryParse- und TryParseExact-Methoden zum Parsen der GUID. Hier ist ein Beispiel dafür.

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

In diesem Beispiel erstellen wir ein neues Guid-Objekt und nehmen auch eine Zeichenfolgenvariable mit ungültiger Guid. Danach verwenden wir die TryParse-Methode, um zu überprüfen, ob beide Variablen ein gültiges Guid-Format haben oder nicht. Anhand eines Beispiels können Sie sehen, dass die Zeichenfolgenvariable kein gültiges Guid-Format hat und die Meldung "InValid Guid" ausgibt. Wenn die Zeichenfolgenvariable eine gültige Guid hat, gibt dies in der TryParse-Methode true zurück.

Sie können den C # -Code einfach automatisch generieren, indem Sie Folgendes verwenden: http://regexhero.net/tester/ .

Es ist kostenlos.

So habe ich es gemacht:

Die Website generiert dann automatisch den .NET-Code:

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

Ich benutze ein einfacheres Regex-Muster

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