C # Regex para Guid

Necesito analizar a través de 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ú Regex.

¿Hay un buen Regex para identificar a un Guid?

Mi segunda pregunta es que una vez que he encontrado una expresión regular válida Regex.Replace(String, String, MatchEvaluator) que usaría Regex.Replace(String, String, MatchEvaluator) pero no estoy seguro de la syntax. Tal vez algo así 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-9fec00b8e170; @ p0 = baf04077-a3c0-454b-ac6f-9fec00b8e170 [Tipo: Guid (0)]”

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

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

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 el punto en los comentarios de que la expresión regular anterior coincidirá con falsos positivos que tienen un delimitador de cierre incorrecto.

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

Conditionals son compatibles con el motor JGsoft, Perl, PCRE, Python y .NET Framework. Ruby los admite comenzando con la versión 2.0. Los lenguajes como Delphi, PHP y R que tienen características regex basadas en PCRE también admiten condicionales. (fuente http://www.regular-expressions.info/conditional.html )

La expresión regular que sigue 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 los números y mostrar de forma más clara lo que se necesita 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 podrías pegarlo aquí .

Espero que esto te ahorre algo de tiempo.

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

Es gratis.

Así es como lo hice:

enter image description here

El sitio web luego 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); 

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

  //Generate New GUID Guid objGuid = Guid.NewGuid(); //Take invalid guid format string strGUID = "aaa-aaaa"; Guid newGuid; if (Guid.TryParse(objGuid.ToString(), out newGuid) == true) { Response.Write(string.Format("
{0} is Valid GUID.", objGuid.ToString())); } else { Response.Write(string.Format("
{0} is InValid GUID.", objGuid.ToString())); } Guid newTmpGuid; if (Guid.TryParse(strGUID, out newTmpGuid) == true) { Response.Write(string.Format("
{0} is Valid GUID.", strGUID)); } else { Response.Write(string.Format("
{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 tienen un formato guid válido o no. Ejecutando el ejemplo, puede ver que la variable de cadena no tiene un formato de guía válido y muestra el mensaje “InValid guid”. Si la variable de cadena tiene un valor de guid válido, esto devolverá verdadero en el método TryParse.

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

Use este RegEx:

 [({]?[a-zA-Z0-9]{8}[-]?([a-zA-Z0-9]{4}[-]?){3}[a-zA-Z0-9]{12}[})]? 

Ejemplo de código C #:

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

Sin duda funciona! Y coincide y reemplaza los siguientes estilos, que son formatos equivalentes y aceptables para un GUID.

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