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

Tengo una cadena User name (sales)y quiero extraer el texto entre paréntesis, ¿cómo haría esto?

Sospecho de una subcadena, pero no puedo entender cómo leer hasta el corchete de cierre, la longitud del texto variará.

Si desea mantenerse alejado de las expresiones regulares, la forma más simple que se me ocurre es:

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

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

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

Como respuesta al comentario (muy divertido), 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"

Suponiendo que solo tiene 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);

Utiliza 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 la salida sería:

sales

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

Algo como:

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

string input = "User name (sales)";

string output = input.Substring(input.IndexOf('(') + 1, input.IndexOf(')') - input.IndexOf('(') - 1);

¿Una expresión regular tal vez? Creo que esto funcionaría ...

\(([a-z]+?)\)

using System;
using System.Text.RegularExpressions;

private IEnumerable<string> 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);

int start = input.IndexOf("(") + 1;
int length = input.IndexOf(")") - start;
output = input.Substring(start, length);

input.Remove(input.IndexOf(')')).Substring(input.IndexOf('(') + 1);

El regexmétodo es superior, creo, pero si querías usar el humildesubstring

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 uso 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 parece que las expresiones regulares son extremadamente útiles pero muy difíciles de escribir. Entonces, investigué un poco y encontré esta herramienta que hace que escribirlos sea tan fácil.

No se aleje de ellos porque la sintaxis es difícil de entender. Pueden ser muy poderosos.

Encontré esto mientras buscaba una solución para una implementación muy similar.

Aquí hay un fragmento de mi código real. Inicia la 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)); 

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 de cadena , no admite el 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 el anidamiento recursivo más bien:

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