Splitting a string on delimiter outside of quotes while returning item-by-item
You can simplify your logic a bit.  Once in a quote you don't need to check for anything until you either at the end of the string or find another quote. 

I also didn't use the ExtendedStringBuilder since I don't have that code and just used the StringBuilder class

From limited testing it returns the same as your function and from using Stopwatch class building a string of 10,000,000 random char it's a bit faster but nothing that couldn't be attributed to noise.  

First I would create another method to just read ahead.  It makes it easier to see if we equal the delimiter passed in 

private static IEnumerable&lt;char&gt; ReadNext(string str, int currentPosition, int count)
{
    for (var i = 0; i &lt; count; i++)
    {
        if (currentPosition + i &gt;= str.Length)
        {
            yield break;
        }
        else
        {
            yield return str[currentPosition + i];
        }
    }
}


I switch the for loop into a while so I can mess with the counter.  While you can change a counter in a for loop I generally frown on that as a developer I would not normally expect that.  With a while loop I would

public static IEnumerable&lt;string&gt; QuotedSplit2(string s, string delim)
{
    const char quote = '\"';

    var sb = new StringBuilder(s.Length);
    var counter = 0;
    while (counter &lt; s.Length)
    {
        // if starts with delmiter if so read ahead to see if matches
        if (delim[0] == s[counter] &amp;&amp; 
            delim.SequenceEqual(ReadNext(s, counter, delim.Length)))
        {
            yield return sb.ToString();
            sb.Clear();
            counter = counter + delim.Length; // Move the counter past the delimiter 
        }
        // if we hit a quote read until we hit another quote or end of string
        else if (s[counter] == quote)
        {
            sb.Append(s[counter++]);
            while (counter &lt; s.Length &amp;&amp; s[counter] != quote)
            {
                sb.Append(s[counter++]);
            }
            // if not end of string then we hit a quote add the quote
            if (counter &lt; s.Length)
            {
                sb.Append(s[counter++]);
            }
        }
        else
        {
            sb.Append(s[counter++]);
        }
    }

    if (sb.Length &gt; 0)
    {
        yield return sb.ToString();
    }
}


SequenceEqual isn't known to be fast but unless you have a large string you using as a delimiter I wouldn't worry about it.  If you do, then it might be worth changing the IEnumerable&lt;char&gt; into a string using String.Concat and comparing the string from String.Concat directly to the delim variable.  

Test

static void Main(string[] args)
{
    var random = new Random();
    var str = String.Concat(Enumerable.Range(1, 10000000).Select(_ =&gt; (char) random.Next(32, 122)));
    var timer = new Stopwatch();
    timer.Start();
    var result2 = QuotedSplit2(str, "1\\").ToArray();
    timer.Stop();
    Console.WriteLine(timer.ElapsedMilliseconds);
    timer.Reset();

    timer.Start();
    var result = QuotedSplit(str, "1\\").ToArray();
    timer.Stop();
    Console.WriteLine(timer.ElapsedMilliseconds);
    timer.Reset();

    Console.WriteLine(result2.SequenceEqual(result));
    Console.WriteLine(result2.Length);

    Console.ReadLine();
}