这是一个非常简单的状态机，它的时间复杂度是O（n）。

public static IEnumerable<string> StringWalker(string input)
{
    bool inParens = false;
    StringBuilder buffer = new StringBuilder();
    List<string> result = new List<string>();

    foreach (var c in input)
    {
        if (c == '(')
        {
            if (inParens)
            {
                throw new Exception("Nested Parens not allowed");
            }
            inParens = true;
            buffer.Clear();
        }
        else if (inParens)
        {
            if (c == ')')
            {
                inParens = false;
                result.Add(buffer.ToString());
            }
            else
            {
                buffer.Append(c);
            }
        }
        else
        {
            result.Add(c.ToString());
        }
    }
    return result;
}

结果如下：

abc(de)(fgh)ijk:  ==>  (a) (b) (c) (de) (fgh) (i) (j) (k) 
(abc)de(f)gh(ijklm)nop:  ==>  (abc) (d) (e) (f) (g) (h) (ijklm) (n) (o) (p)

You can try using reguar expressions and Match all the items:

using System.Linq;
using System.Text.RegularExpressions;

...

string test = "(af)sd(abc)abc";

string[] testSplitted = Regex
  .Matches(test, @"\(.*?\)|.")
  .Cast<Match>()
  .Select(match => match.Value.Trim('(', ')'))
  .ToArray();

Pattern explained:

\(.*?\) - zero or more characters (aw few as possible) within (...)
  |       - OR
  .       - single character

More tests:

string[] tests = new string[] {
  "(ab)(bc)(ca)", 
  "abc", 
  "(abc)(abc)(abc)", "(zyx)bc" 
};

static string[] Perform(string value) => Regex
  .Matches(value, @"\(.*?\)|.")
  .Cast<Match>()
  .Select(match => match.Value.Trim('(', ')'))
  .ToArray();

string report = string.Join(Environment.NewLine, tests
  .Select(test => $"{test,15} => {string.Join(", ", Perform(test))}"));

Console.Write(report);

Output:

(ab)(bc)(ca) => ab, bc, ca
            abc => a, b, c
(abc)(abc)(abc) => abc, abc, abc
        (zyx)bc => zyx, b, c

Please, fiddle yourself