五个类，解析单双引号

    public interface IBlock
    {
        string Quote();
        void Append(char c);
        bool ShouldAppendQuotedBlock(char c);
    }

    public abstract class NestedBlock : IBlock
    {
        private readonly NestedBlock parent;
        private readonly List<IBlock> blocks;
        private IBlock currentBlock;

        public NestedBlock(NestedBlock parent)
        {
            this.parent = parent;
            blocks = new List<IBlock>();
        }

        public virtual string Quote()
        {
            StringBuilder stringBuilder = new StringBuilder();
            foreach (IBlock block in blocks)
            {
                stringBuilder.Append(block.Quote());
            }
            return stringBuilder.ToString();
        }

        public abstract void Append(char c);
        public abstract bool ShouldAppendQuotedBlock(char c);

        protected NestedBlock Parent
        {
            get { return parent; }
        }

        protected IBlock CurrentBlock
        {
            get { return currentBlock; }
        }

        public void AppendBlock(IBlock block)
        {
            blocks.Add(block);
            currentBlock = block;
        }
    }

    public class QuotedBlock : NestedBlock
    {
        private readonly IQuoteStrategy quoteStrategy;
        private readonly char expectedQuote;

        public QuotedBlock(IQuoteStrategy quoteStrategy, char expectedQuote, NestedBlock parent) : base(parent)
        {
            this.quoteStrategy = quoteStrategy;
            this.expectedQuote = expectedQuote;
            AppendBlock(new RootBlock(quoteStrategy));
        }

        public override string Quote()
        {
            return expectedQuote + quoteStrategy.Quote(base.Quote()) + expectedQuote;
        }

        public override void Append(char c)
        {
            if (c == expectedQuote)
            {
                Parent.AppendBlock(new UnquotedBlock());
            }
            else
            {
                CurrentBlock.Append(c);
            }
        }

        public override bool ShouldAppendQuotedBlock(char c)
        {
            return false;
        }
    }

    public class UnquotedBlock : IBlock
    {
        private readonly StringBuilder stringBuilder = new StringBuilder();

        public string Quote()
        {
            return stringBuilder.ToString();
        }

        public void Append(char c)
        {
            stringBuilder.Append(c);
        }

        public bool ShouldAppendQuotedBlock(char c)
        {
            return IsQuotationMark(c);
        }

        private static bool IsQuotationMark(char c)
        {
            if (c == '"')
            {
                return true;
            }
            return c == '\'';
        }
    }

   public class RootBlock : NestedBlock
    {
        private readonly IQuoteStrategy quoteStrategy;

        public RootBlock(IQuoteStrategy quoteStrategy) : base(null)
        {
            this.quoteStrategy = quoteStrategy;
            AppendBlock(new UnquotedBlock());
        }

        public override void Append(char c)
        {
            if (CurrentBlock.ShouldAppendQuotedBlock(c))
            {
                AppendBlock(new QuotedBlock(quoteStrategy, c, this));
            }
            else
            {
                CurrentBlock.Append(c);
            }
        }

        public override bool ShouldAppendQuotedBlock(char c)
        {
            throw new ViScriptSystemException();
        }
    }