实现了一个无限层的集合类!爽!

 /// <summary>
    /// 牛X的类!!
    /// </summary>
    public class yuan
    {
        private List<yuan> _cell;
        private List<string> _str;

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="zt">这里输入要解析的字符串</param>
        /// <param name="bq">这里输入标签数组,从外层向内层写</param>
        /// <param name="gs">这个参数请输入0</param>
        public yuan(string zt,string[]bq,int gs)
        {
            //最后一层只把str赋值
            if (bq.Length == gs + 1)
            {
                this._str = this.chuli(zt, bq[gs]);
                return;
            }
                //其他情况递归.
            else
            {
                this._str = this.chuli(zt, bq[gs]);
                this._cell = this.digui(_str, bq, gs + 1);
            }
            if (this.cell != null)
            {
                this.str = null;
            }
        }

        /// <summary>
        /// 最后一层的赋值方法.
        /// </summary>
        /// <param name="zt">解析的字符串</param>
        /// <param name="bq">标签</param>
        /// <returns>返回切好的字符串集合</returns>
        private List<string> chuli(string zt, string bq)
        {
            List<string> sreturn = new List<string>();
            int ibeg = 0;
            int iend = 0;
            string beg = "<" + bq + ">";//组成标签
            string end = "</" + bq + ">";
            //处理多标签情况  当重合的时候是解析到最后
            while (zt.IndexOf(beg, ibeg) != zt.LastIndexOf(beg))
            {
                ibeg = zt.IndexOf(beg, ibeg) + beg.Length;
                iend = zt.IndexOf(end, ibeg);
                sreturn.Add(zt.Substring(ibeg, iend - ibeg));
            }
            //处理最后一轮或者像页数一类只有一个返回值的情况
            ibeg = zt.IndexOf(beg, ibeg) + beg.Length;
            iend = zt.IndexOf(end, ibeg);
            sreturn.Add(zt.Substring(ibeg, iend - ibeg));
            return sreturn;
        }

        /// <summary>
        /// 递归的方法
        /// </summary>
        /// <param name="zt">字符串集合,每个类都要输入要切割的字符串</param>
        /// <param name="bq">标签数组</param>
        /// <param name="dijige">表示现在的标签</param>
        /// <returns>返回的是一个类的集合</returns>
        private List<yuan> digui(List<string>zt, string[] bq, int dijige)
        {
            //定义一个类集合用来返回
            List<yuan> yreturn = new List<yuan>();
            //用循环将集合里面所有的类赋值,递归.
            for (int i = 0; i < zt.Count; i++)
            {
                yuan item = new yuan(zt[i], bq, dijige);
                yreturn.Add(item);
            }
            return yreturn;
        }

        /// <summary>
        ///
        /// </summary>
        public List<yuan> cell
        {
            get
            {
                if (_cell == null)
                {
                    cell = new List<yuan>();
                }
                return _cell;
            }
            set
            {
               
                _cell = value;
            }
        }

        /// <summary>
        ///
        /// </summary>
        public List<string> str
        {
            get
            {
                if (_str == null)
                {
                    _str = new List<string>();
                }
                return _str;
            }
            set
            {
                _str = value;
            }
        }

        /// <summary>
        /// 输出的递归方法.
        /// </summary>
        /// <returns></returns>
        public string mypringt()
        {
            string myout = "";
            if (_cell == null)
            {
                for (int i = 0; i < _str.Count; i++)
                {
                    myout += "!";
                    myout += _str[i];
                }
            }
            else
            {
                for (int j = 0; j < _cell.Count; j++)
                {
                    myout = myout + _cell[j].mypringt();
                }
            }
            return myout;
        }
    }