Jak wyodrębnić tekst między nawiasami okrągłymi (nawiasy okrągłe)?

Mam ciąg User name (sales)i chcę wyodrębnić tekst między nawiasami, jak mam to zrobić?

Podejrzewam ciąg podrzędny, ale nie potrafię czytać, dopóki nie zostanie zamknięty nawias, długość tekstu będzie się różnić.

Jeśli chcesz trzymać się z dala od wyrażeń regularnych, najprostszym sposobem, jaki mogę wymyślić, jest:

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

Bardzo prostym sposobem na to jest użycie wyrażeń regularnych:

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

W odpowiedzi na (bardzo zabawny) komentarz, oto ten sam Regex z wyjaśnieniem:

\(             # 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"

Zakładając, że masz tylko jedną parę nawiasów.

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

Użyj tej funkcji:

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

a oto użycie:

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

i wynik byłby:

sales

Wyrażenia regularne mogą być tutaj najlepszym narzędziem. Jeśli nie jesteś z nimi zaznajomiony, zalecamy zainstalowanie Expresso - świetnego małego narzędzia do wyrażania regularnego.

Coś jak:

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

Może regex? Myślę, że to zadział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;
}

Użyj wyrażenia regularnego:

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

regexMetoda jest lepsza myślę, ale jeśli chciał użyć pokornychsubstring

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

lub

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

Oto funkcja ogólnego przeznaczenia, która pozwala uniknąć wyrażeń regularnych:

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

Aby nazwać to w konkretnym przykładzie, możesz:

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

Uważam, że wyrażenia regularne są niezwykle przydatne, ale bardzo trudne do napisania. Przeprowadziłem badania i znalazłem to narzędzie, które sprawia, że ​​pisanie ich jest tak łatwe.

Nie wahaj się przed nimi, ponieważ trudno jest zrozumieć składnię. Mogą być tak potężni.

Natknąłem się na to, kiedy szukałem rozwiązania bardzo podobnej implementacji.

Oto fragment mojego faktycznego kodu. Rozpoczyna podciąg od pierwszego znaku (indeks 0).

 string separator = "\n";     //line terminator

 string output;
 string input= "HowAreYou?\nLets go there!";

 output = input.Substring(0, input.IndexOf(separator)); 

Ten kod jest szybszy niż większość dostępnych tutaj rozwiązań (jeśli nie wszystkie), spakowany jako metoda rozszerzenia String , nie obsługuje zagnieżdżania rekurencyjnego:

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

Ten jest trochę dłuższy i wolniejszy, ale ładniej radzi sobie z zagnieżdżaniem rekurencyjnym:

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