整数区间及区间集合（C#实现）

         /// <summary>
         /// 整数区间类
         /// </summary>
         private class Interval
         {
             private int _start = , _end = ;
             public int Start
             {
                 get { return Math.Min(this._start, this._end); }
                 set { this._start = value; }
             }
             public int End
             {
                 get { return Math.Max(this._start, this._end); }
                 set { this._end = value; }
             }
             public bool Inside(int Value)
             {
                 return (Start <= Value && Value <= End);
             }
             /// <summary>
             /// 区间求并运算，此方法不修改当前实例的值。
             /// 若不可合并则返回null，否则返回新的区间。
             /// </summary>
             /// <param name="OtherInterval">另一个区间</param>
             /// <returns>新的区间实例</returns>
             public Interval Merge(Interval OtherInterval)
             {
                 if (this.Start - OtherInterval.End >  || OtherInterval.Start - this.End > )
                 {
                     return null;
                 }
                 else
                 {
                     return new Interval()
                     {
                         Start = Math.Min(this.Start, OtherInterval.Start),
                         End = Math.Max(this.End, OtherInterval.End)
                     };
                 }
             }
         }
         /// <summary>
         /// 区间集合类
         /// </summary>
         private class IntervalCollection
         {
             public List<Interval> Intervals = new List<Interval>();
             /// <summary>
             /// 将一个区间并入区间集合中
             /// </summary>
             /// <param name="Start">开始位置</param>
             /// <param name="End">结束位置</param>
             public void Add(int Start, int End)
             {
                 this.Add(new Interval() { Start = Start, End = End });
             }
             /// <summary>
             /// 将一个区间并入区间集合中
             /// </summary>
             /// <param name="NewInterval">需要并入的区间结构</param>
             public void Add(Interval NewInterval)
             {
                 Interval MergeInterval = null;
                 for (int i = ; i < this.Intervals.Count; i++)
                 {
                     MergeInterval = this.Intervals[i].Merge(NewInterval);
                     if (MergeInterval != null)
                     {
                         this.Intervals[i] = MergeInterval;
                         break;
                     }
                 }
                 if (MergeInterval == null)
                 {
                     Intervals.Add(NewInterval);
                 }
             }
             /// <summary>
             /// 检测区间集中是否包含有指定值
             /// </summary>
             /// <param name="Value">需要查询的数值</param>
             /// <returns>包含返回true，否则返回false</returns>
             public bool Inside(int Value)
             {
                 foreach (Interval Inter in Intervals)
                 {
                     if (Inter.Inside(Value) == true)
                     {
                         return true;
                     }
                 }
                 return false;
             }
             /// <summary>
             /// 将区间集的转换为字符串
             /// </summary>
             /// <typeparam name="T">转换类型</typeparam>
             /// <param name="CompleteSet">全集，当序列化后若长度过长则用以求取补集</param>
             /// <returns>返回转换后的字符串</returns>
             public string ToString<T>(string CompleteSet = null)
             {
                 StringBuilder Str = new StringBuilder("[");
                 foreach (Interval Inter in Intervals)
                 {
                     if (Inter.Start == Inter.End)
                     {
                         dynamic Vs = (object)Inter.Start;
                         Str.Append((T)Vs);
                     }
                     else if (Inter.End - Inter.Start == )
                     {
                         dynamic Vs = (object)Inter.Start;
                         dynamic Ve = (object)Inter.End;
                         Str.Append((T)Vs).Append((T)Ve);
                     }
                     else
                     {
                         dynamic Vs = (object)Inter.Start;
                         dynamic Ve = (object)Inter.End;
                         Str.AppendFormat("{0}-{1}", (T)Vs, (T)Ve);
                     }
                 }
                 Str.Append("]");
                 if (Str[] == '^')
                 {
                     Str = Str.Replace("^", "\\^", , );
                 }
                 // 求取补集以试图缩小代码长度
                 if (Str.Length >=  && CompleteSet != null)
                 {
                     StringBuilder Complement = new StringBuilder("[^");
                     foreach (char c in CompleteSet)
                     {
                         if (this.Inside(c) == false)
                         {
                             Complement.Append(c);
                         }
                     }
                     Complement.Append("]");
                     if (Complement.Length <= Str.Length)
                     {
                         return Complement.ToString();
                     }
                 }
                 return Str.ToString();
             }
         }