C # Regex para Guid

Preciso analisar uma string e adicionar aspas simples em torno de cada valor de Guid. Eu estava pensando que poderia usar um Regex para fazer isso, mas não sou exatamente um guru do Regex.

Existe um bom Regex para usar para identificar um Guid?

Minha segunda pergunta é: depois de encontrar uma regex válida, presumo que usaria, Regex.Replace(String, String, MatchEvaluator)mas não tenho certeza da sintaxe. Talvez algo como:

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

Uma string que estou tentando analisar pode ter a seguinte aparência:

"SELECT passwordco0_.PASSWORD_CONFIG_ID como PASSWORD1_46_0_, de PASSWORD_CONFIG passwordco0_ ONDE passwordco0_.PASSWORD_CONFIG_ID = baf04077-a3c0-454b-ac6f-9fec00b8e170; @ p0 = baf04077-a3c0-454b-ac6f-9fec00b8e170 [Tipo: Guid (0)]"

Este é bastante simples e não requer um delegado, como você diz.

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

Isso corresponde aos seguintes estilos, que são todos formatos equivalentes e aceitáveis ​​para um GUID.

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

Atualização 1

@NonStatic deixa claro nos comentários que a regex acima corresponderá a falsos positivos que possuem um delimitador de fechamento incorreto.

Isso pode ser evitado por condicionais regex que são amplamente suportados.

As condicionais são suportadas pelo mecanismo JGsoft, Perl, PCRE, Python e a estrutura .NET. Ruby oferece suporte a eles a partir da versão 2.0. Linguagens como Delphi, PHP e R que possuem recursos regex baseados em PCRE também suportam condicionais. (fonte http://www.regular-expressions.info/conditional.html )

A regex que segue corresponderá

{123}
(123)
123

E não vai combinar

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

Regex:

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

As soluções são simplificadas para combinar apenas números para mostrar de forma mais clara o que é necessário, se necessário.

O regex mais básico é o seguinte:

(^([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 você pode colá-lo aqui .

Espero que isso economize algum tempo.

Para C # .Net encontrar e substituir qualquer string de aparência de guid do texto fornecido,

Use este RegEx:

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

Exemplo de código 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
);

Certamente funciona! E ele corresponde e substitui os seguintes estilos, que são todos formatos equivalentes e aceitáveis ​​para um GUID.

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

No .NET Framework 4, há um aprimoramento da estrutura System.Guid, que inclui os novos métodos TryParse e TryParseExact para analisar o GUID. Aqui está um exemplo para isso.

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

Neste exemplo, criamos um novo objeto guid e também pegamos uma variável de string que tem guid inválido. Depois disso, usamos o método TryParse para validar se ambas as variáveis ​​têm formato guid válido ou não. Ao executar o exemplo, você pode ver que a variável string não tem um formato guid válido e dá a mensagem de "guid inválido". Se a variável de string tiver um guid válido, isso retornará verdadeiro no método TryParse.

Você pode gerar automaticamente o código C # usando: http://regexhero.net/tester/ .

É grátis.

Aqui está como eu fiz:

O site, então, gera automaticamente o código .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);

Eu uso um padrão regex mais fácil

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