Regex C # per Guid

Devo analizzare una stringa e aggiungere virgolette singole attorno a ciascun valore Guid. Stavo pensando di poter usare un Regex per farlo, ma non sono esattamente un guru Regex.

Esiste un buon Regex da utilizzare per identificare un Guid?

La mia seconda domanda è una volta trovata una regex valida che presumo di utilizzare Regex.Replace(String, String, MatchEvaluator)ma non sono abbastanza sicuro della sintassi. Forse qualcosa come:

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

Una stringa che sto cercando di analizzare potrebbe essere simile a questa:

"SELEZIONA passwordco0_.PASSWORD_CONFIG_ID come PASSWORD1_46_0_, DA PASSWORD_CONFIG passwordco0_ WHERE passwordco0_.PASSWORD_CONFIG_ID = baf04077-a3c0-454b-ac6f-9fec00b8e170; @ p045e170;

Questo è abbastanza semplice e non richiede un delegato come dici tu.

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

Ciò corrisponde ai seguenti stili, che sono tutti formati equivalenti e accettabili per un GUID.

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

Aggiorna 1

@NonStatic sottolinea nei commenti che la regex di cui sopra corrisponderà a falsi positivi che hanno un delimitatore di chiusura errato.

Questo può essere evitato dalle espressioni regolari che sono ampiamente supportate.

I condizionali sono supportati dal motore JGsoft, Perl, PCRE, Python e .NET framework. Ruby li supporta a partire dalla versione 2.0. Linguaggi come Delphi, PHP e R che hanno funzionalità regex basate su PCRE supportano anche i condizionali. (fonte http://www.regular-expressions.info/conditional.html )

La regex che segue Will match

{123}
(123)
123

E non corrisponderà

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

regex:

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

Le soluzioni sono semplificate per abbinare solo numeri per mostrare in modo più chiaro ciò che è necessario se necessario.

La maggior parte delle espressioni regolari di base è la seguente:

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

oppure puoi incollarlo qui .

Spero che questo ti faccia risparmiare tempo.

Affinché C # .Net trovi e sostituisca qualsiasi stringa di ricerca guidata dal testo specificato,

Usa questa RegEx:

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

Codice C # di esempio:

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

Sicuramente funziona! E corrisponde e sostituisce i seguenti stili, che sono tutti formati equivalenti e accettabili per un GUID.

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

In .NET Framework 4 è presente un miglioramento della struttura System.Guid, che include nuovi metodi TryParse e TryParseExact per Parse GUID. Ecco un esempio per questo.

    //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 questo esempio creiamo un nuovo oggetto guid e prendiamo anche una variabile stringa che ha guid non valido. Dopodiché utilizziamo il metodo TryParse per verificare che entrambe le variabili abbiano o meno un formato guid valido. Eseguendo l'esempio puoi vedere che la variabile stringa non ha un formato guid valido e fornisce un messaggio di "guid non valido". Se la variabile stringa ha un guid valido, questo restituirà true nel metodo TryParse.

Puoi facilmente generare automaticamente il codice C # utilizzando: http://regexhero.net/tester/ .

È gratis.

Ecco come l'ho fatto:

Il sito Web quindi genera automaticamente il codice .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);

Uso un pattern regex più semplice

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