¿Cómo extraigo texto que se encuentra entre paréntesis (corchetes)?

Tengo un User name (sales) cadena User name (sales) y quiero extraer el texto entre los corchetes. ¿Cómo lo haría?

Sospecho que la subcadena, pero no sé cómo leer hasta el corchete de cierre, la longitud del texto variará.

Una forma muy simple de hacerlo es mediante el uso de expresiones regulares:

 Regex.Match("User name (sales)", @"\(([^)]*)\)").Groups[1].Value 

Como respuesta al (muy divertido) comentario, aquí está el mismo Regex con alguna explicación:

 \( # Escaped parenthesis, means "starts with a '(' character" ( # Parentheses in a regex mean "put (capture) the stuff # in between into the Groups array" [^)] # Any character that is not a ')' character * # Zero or more occurrences of the aforementioned "non ')' char" ) # Close the capturing group \) # "Ends with a ')' character" 

Si deseas mantenerte alejado de las expresiones regulares, la forma más sencilla en que puedo pensar es:

 string input = "User name (sales)"; string output = input.Split('(', ')')[1]; 

Suponiendo que solo tienes un par de paréntesis.

 string s = "User name (sales)"; int start = s.IndexOf("(") + 1; int end = s.IndexOf(")", start); string result = s.Substring(start, end - start); 

Usa esta función:

 public string GetSubstringByString(string a, string b, string c) { return c.Substring((c.IndexOf(a) + a.Length), (c.IndexOf(b) - c.IndexOf(a) - a.Length)); } 

y aquí está el uso:

 GetSubstringByString("(", ")", "User name (sales)") 

y el resultado sería:

 sales 

Las expresiones regulares pueden ser la mejor herramienta aquí. Si no está familiarizado con ellos, le recomiendo que instale Expresso , una gran pequeña herramienta de expresiones regulares.

Algo como:

 Regex regex = new Regex("\\((?\\w+)\\)"); string incomingValue = "Username (sales)"; string insideBrackets = null; Match match = regex.Match(incomingValue); if(match.Success) { insideBrackets = match.Groups["TextInsideBrackets"].Value; } 

Un regex tal vez? Creo que esto funcionaría …

 \(([az]+?)\) 
 string input = "User name (sales)"; string output = input.Substring(input.IndexOf('(') + 1, input.IndexOf(')') - input.IndexOf('(') - 1); 
 using System; using System.Text.RegularExpressions; private IEnumerable GetSubStrings(string input, string start, string end) { Regex r = new Regex(Regex.Escape(start) +`"(.*?)"` + Regex.Escape(end)); MatchCollection matches = r.Matches(input); foreach (Match match in matches) yield return match.Groups[1].Value; } 

Use una expresión regular:

 string test = "(test)"; string word = Regex.Match(test, @"\((\w+)\)").Groups[1].Value; Console.WriteLine(word); 
 input.Remove(input.IndexOf(')')).Substring(input.IndexOf('(') + 1); 

El método de regex es superior, creo, pero si quisieras usar la substring humilde

 string input= "my name is (Jayne C)"; int start = input.IndexOf("("); int stop = input.IndexOf(")"); string output = input.Substring(start+1, stop - start - 1); 

o

 string input = "my name is (Jayne C)"; string output = input.Substring(input.IndexOf("(") +1, input.IndexOf(")")- input.IndexOf("(")- 1); 

Aquí hay una función legible de propósito general que evita el uso de expresiones regulares:

 // Returns the text between 'start' and 'end'. string ExtractBetween(string text, string start, string end) { int iStart = text.IndexOf(start); iStart = (iStart == -1) ? 0 : iStart + start.Length; int iEnd = text.LastIndexOf(end); if(iEnd == -1) { iEnd = text.Length; } int len = iEnd - iStart; return text.Substring(iStart, len); } 

Para llamarlo en su ejemplo particular, puede hacer:

 string result = ExtractBetween("User name (sales)", "(", ")"); 

Me encontré con esto mientras buscaba una solución para una implementación muy similar.

Aquí hay un fragmento de mi código real. Inicia subcadena desde el primer carácter (índice 0).

  string separator = "\n"; //line terminator string output; string input= "HowAreYou?\nLets go there!"; output = input.Substring(0, input.IndexOf(separator)); 

Estoy descubriendo que las expresiones regulares son extremadamente útiles pero muy difíciles de escribir. Entonces investigué y encontré esta herramienta que hace que escribirlos sea tan fácil.

No rehuir de ellos porque la syntax es difícil de entender. Ellos pueden ser tan poderosos.

Este código es más rápido que la mayoría de las soluciones aquí (si no todas), empaquetado como método de extensión String , no admite anidamiento recursivo:

 public static string GetNestedString(this string str, char start, char end) { int s = -1; int i = -1; while (++i < str.Length) if (str[i] == start) { s = i; break; } int e = -1; while(++i < str.Length) if (str[i] == end) { e = i; break; } if (e > s) return str.Substring(s + 1, e - s - 1); return null; } 

Este es un poco más largo y más lento, pero maneja la anidación recursiva más agradablemente:

 public static string GetNestedString(this string str, char start, char end) { int s = -1; int i = -1; while (++i < str.Length) if (str[i] == start) { s = i; break; } int e = -1; int depth = 0; while (++i < str.Length) if (str[i] == end) { e = i; if (depth == 0) break; else --depth; } else if (str[i] == start) ++depth; if (e > s) return str.Substring(s + 1, e - s - 1); return null; } 
 int start = input.IndexOf("(") + 1; int length = input.IndexOf(")") - start; output = input.Substring(start, length);