C # Regex para Guid

Necesito analizar una cadena y agregar comillas simples alrededor de cada valor de Guid. Estaba pensando que podría usar un Regex para hacer esto, pero no soy exactamente un gurú de Regex.

¿Existe una buena expresión regular para usar para identificar un Guid?

Mi segunda pregunta es una vez que he encontrado una expresión regular válida que supongo que usaría, Regex.Replace(String, String, MatchEvaluator)pero no estoy muy seguro de la sintaxis. Tal vez algo como:

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

Una cadena que estoy tratando de analizar puede verse así:

"SELECCIONE passwordco0_.PASSWORD_CONFIG_ID como PASSWORD1_46_0_, FROM PASSWORD_CONFIG passwordco0_ WHERE passwordco0_.PASSWORD_CONFIG_ID = baf04077-a3c0-454b-ac6f-9fec00b8eb3c; @ p040-877-a3c0-454b-ac6f-9fec00b8eb3c;

Este es bastante simple y no requiere un delegado como dices.

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

Esto coincide con los siguientes estilos, que son todos formatos equivalentes y aceptables para un GUID.

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

Actualización 1

@NonStatic señala en los comentarios que la expresión regular anterior coincidirá con falsos positivos que tienen un delimitador de cierre incorrecto.

Esto se puede evitar mediante los condicionales de expresiones regulares que son ampliamente compatibles.

Los condicionales son compatibles con el motor JGsoft, Perl, PCRE, Python y .NET framework. Ruby los admite a partir de la versión 2.0. Los lenguajes como Delphi, PHP y R que tienen funciones de expresiones regulares basadas en PCRE también admiten condicionales. (fuente http://www.regular-expressions.info/conditional.html )

La expresión regular que sigue a Will coincidirá

{123}
(123)
123

Y no coincidirá

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

Regex:

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

Las soluciones se simplifican para hacer coincidir solo números para mostrar de una manera más clara lo que se requiere si es necesario.

La expresión regular más básica es la siguiente:

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

o puedes pegarlo aquí .

Espero que esto te ahorre algo de tiempo.

Para que C # .Net encuentre y reemplace cualquier cadena que busque guid del texto dado,

Utilice esta expresión regular:

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

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

¡Seguro que funciona! Y coincide y reemplaza los siguientes estilos, que son todos formatos equivalentes y aceptables para un GUID.

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

En .NET Framework 4 hay una estructura mejorada System.Guid, que incluye nuevos métodos TryParse y TryParseExact para analizar GUID. Aquí hay un ejemplo de esto.

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

En este ejemplo, creamos un nuevo objeto guid y también tomamos una variable de cadena que tiene un guid no válido. Después de eso, usamos el método TryParse para validar que ambas variables tengan un formato guid válido o no. Al ejecutar el ejemplo, puede ver que la variable de cadena no tiene un formato de guid válido y da un mensaje de "guid no válido". Si la variable de cadena tiene un guid válido, esto devolverá verdadero en el método TryParse.

Puede autogenerar fácilmente el código C # usando: http://regexhero.net/tester/ .

Es gratis.

Así es como lo hice:

Luego, el sitio web genera automáticamente el 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);

Yo uso un patrón de expresiones regulares más fácil

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