集合代理类的实现

【问题的提出】

以Windows系统的文件系统为例，文件系统对象目录（DirectoryInfo）或者文件（FileInfo）都派生自文件系统对象（FileSystemInfo），但在我们实际应用中，可能需要这样：

一个集合IList<FileSystemInfo>能完整的反应某一个目录下的所有的文件和文件夹，一个IList<DirectoryInfo>反应该文件夹下的所有子文件夹，一个IList<FileInfo>反应该文件夹下的所有文件，当我们对文件夹集合或者文件集合进行操作的时候，能动态的响应到所有子对象的集合上。

 

【问题分析】

在.net的类型定义里，虽然IList<>是一个泛型定义，而DirectoryInfo和FileInfo都是派生自FileSystemInfo，但IList<FileSystemInfo>和IList<FileInfo>与IList<DirectoryInfo>没有任何关系，也就是说，我们不能把一个IList<FileInfo>类型的集合对象或者IList<DirectoryInfo>类型的集合对象转换为IList<FileSystemInfo>类型，因此，简单的把实现需求变成了不可能。

 

【问题解决】

基于以上需求分析，决定定义一个集合代理类CollectionProxy<TSource, TBase>，该泛型类支持把TBase类型的集合对象转换为TSource类型的集合对象。

 

【代码实现】

1——

ICollectionEX接口定义

 

     ///   <summary>
     ///  扩展集合接口定义。本类接口定义等同于Collection实现的接口
     ///   </summary>
     ///   <typeparam name="T"></typeparam>
     public  interface ICollectionEx<T> : IList<T>, ICollection<T>, IEnumerable<T>, IList, ICollection, IEnumerable
    {
         ///   <summary>
         ///  新定义属性或方法，避免在使用的时候引起基类的歧义，从而能简单的使用本类来达到目的
         ///   </summary>
         new  int Count {  get; }
         ///   <summary>
         ///  新定义属性或方法，避免在使用的时候引起基类的歧义，从而能简单的使用本类来达到目的
         ///   </summary>
         new  void RemoveAt( int index);
         ///   <summary>
         ///  新定义属性或方法，避免在使用的时候引起基类的歧义，从而能简单的使用本类来达到目的
         ///   </summary>
         new  void Clear();
         ///   <summary>
         ///  新定义属性或方法，避免在使用的时候引起基类的歧义，从而能简单的使用本类来达到目的
         ///   </summary>
         new T  this[ int index] {  get;  set; }
         ///   <summary>
         ///  新定义属性或方法，避免在使用的时候引起基类的歧义，从而能简单的使用本类来达到目的
         ///   </summary>
         new  bool IsReadOnly {  get; }
    }

这个接口只是简单的把IList和ICollection两个集合（以及泛型集合）进行整合，考虑到IList与IList<>、ICollection与ICollection<>之间有方法、属性的冲突，因此，对冲突的属性和方法进行了重新定义，目的仅仅是为了避免在使用这个接口的时候出现歧义还需要再次进行转换

 

2——

CollectionProxy<T>集合的定义与实现

 

     public  class CollectionProxy<TData> : ICollection<TData>
    {
         private ICollection<TData> _baseCollection;

         protected ICollection<TData> BaseCollection
        {
             get
            {
                 return  this._baseCollection;
            }
        }

         public CollectionProxy(ICollection<TData> baseCollection)
        {
             if (baseCollection ==  null)
            {
                 throw  new ArgumentNullException( " baseCollection ");
            }
             this._baseCollection = baseCollection;
        }

         public  void Add(TData item)
        {
             this.AddItem(item);
        }

         protected  virtual  void AddItem(TData item) 
        {
             this.BaseCollection.Add(item);
        }


         public  void Clear()
        {
             this.ClearAll();
        }
         protected  virtual  void ClearAll() 
        {
             this.BaseCollection.Clear();
        }

         public  bool Contains(TData item)
        {
             return  this.ContainsItem(item);
        }
         protected  virtual  bool ContainsItem(TData item) 
        {
             return  this.BaseCollection.Contains(item);
        }
         public  void CopyTo(TData[] array,  int arrayIndex)
        {
             this.CopyItemTo(array, arrayIndex);
        }
         protected  virtual  void CopyItemTo(TData[] array,  int arrayIndex) 
        {
             this.BaseCollection.CopyTo(array, arrayIndex);
        }
         public  int Count
        {
             get
            {
                 return  this.BaseCollection.Count;
            }
        }

         public  bool IsReadOnly
        {
             get
            {
                 return  this.BaseCollection.IsReadOnly;
            }
        }

         public  bool Remove(TData item)
        {
           return   this.RemoveItem(item);
        }
         protected  virtual  bool RemoveItem(TData item) 
        {
             return  this.BaseCollection.Remove(item);
        }
         public IEnumerator<TData> GetEnumerator()
        {
             return  this.BaseCollection.GetEnumerator();
        }

         #region ICollection

         void ICollection<TData>.Add(TData item)
        {
             this.AddItem(item);
        }

         void ICollection<TData>.Clear()
        {
             this.ClearAll();
        }

         bool ICollection<TData>.Contains(TData item)
        {
             return  this.Contains(item);
        }

         void ICollection<TData>.CopyTo(TData[] array,  int arrayIndex)
        {
             this.CopyItemTo(array, arrayIndex);
        }

         int ICollection<TData>.Count
        {
             get
            {
                 return  this.Count;
            }
        }

         bool ICollection<TData>.IsReadOnly
        {
             get
            {
                 return  this.IsReadOnly;
            }
        }

         bool ICollection<TData>.Remove(TData item)
        {
             return  this.RemoveItem(item);
        }

         #endregion

         #region IEnumerable<TData>

        IEnumerator<TData> IEnumerable<TData>.GetEnumerator()
        {
             return  this.GetEnumerator();
        }

         #endregion

         #region IEnumerable

        IEnumerator IEnumerable.GetEnumerator()
        {
             return  this.GetEnumerator();
        }

         #endregion
    }

这个类是一个简单的ICollection<>泛型集合的代理类，目的就是实现一个可控的ICollection<>的集合对象。

3——

集合类CollectionExProxy<TData>

 

     public  class CollectionExProxy<TData> : CollectionProxy<TData>, ICollectionEx<TData>, INotifyPropertyChanged, INotifyCollectionChanged
    {
         #region 构造函数

         public CollectionExProxy(Collection<TData> baseCollection)
            :  base(baseCollection)
        {
        }

         protected  new Collection<TData> BaseCollection
        {
             get
            {
                 return  base.BaseCollection  as Collection<TData>;
            }
        }

         #endregion

         #region ICollectionEx<TData>

         int ICollectionEx<TData>.Count
        {
             get
            {
                 return ( this  as IList<TData>).Count;
            }
        }

         void ICollectionEx<TData>.RemoveAt( int index)
        {
            ( this  as IList<TData>).RemoveAt(index);
        }

         void ICollectionEx<TData>.Clear()
        {
            ( this  as IList<TData>).Clear();
        }

        TData ICollectionEx<TData>. this[ int index]
        {
             get
            {
                 return ( this  as IList<TData>)[index];
            }
             set
            {
                ( this  as IList<TData>)[index] = value;
            }
        }

         bool ICollectionEx<TData>.IsReadOnly
        {
             get
            {
                 return ( this  as IList<TData>).IsReadOnly;
            }
        }

         #endregion

         #region IList<TData>

         int IList<TData>.IndexOf(TData item)
        {
             return  this.BaseCollection.IndexOf(item);
        }

         void IList<TData>.Insert( int index, TData item)
        {
             this.BaseCollection.Insert(index, item);
        }

         void IList<TData>.RemoveAt( int index)
        {
             this.BaseCollection.RemoveAt(index);
        }

        TData IList<TData>. this[ int index]
        {
             get
            {
                 return  this.BaseCollection[index];
            }
             set
            {
                 this.BaseCollection[index] = value;
            }
        }

         #endregion

         #region IList

         int IList.Add( object value)
        {
             return ( this.BaseCollection  as IList).Add(value);
        }

         void IList.Clear()
        {
            ( this.BaseCollection  as IList).Clear();
        }

         bool IList.Contains( object value)
        {
             return ( this.BaseCollection  as IList).Contains(value);
        }

         int IList.IndexOf( object value)
        {
             return ( this.BaseCollection  as IList).IndexOf(value);
        }

         void IList.Insert( int index,  object value)
        {
            ( this.BaseCollection  as IList).Insert(index, value);
        }

         bool IList.IsFixedSize
        {
             get
            {
                 return ( this.BaseCollection  as IList).IsFixedSize;
            }
        }

         bool IList.IsReadOnly
        {
             get
            {
                 return ( this.BaseCollection  as IList).IsReadOnly;
            }
        }

         void IList.Remove( object value)
        {
            ( this.BaseCollection  as IList).Remove(value);
        }

         void IList.RemoveAt( int index)
        {
            ( this.BaseCollection  as IList).RemoveAt(index);
        }

         object IList. this[ int index]
        {
             get
            {
                 return ( this.BaseCollection  as IList)[index];
            }
             set
            {
                ( this.BaseCollection  as IList)[index] = value;
            }
        }

         #endregion

         #region ICollection

         void ICollection.CopyTo(Array array,  int index)
        {
            ( this.BaseCollection  as ICollection).CopyTo(array, index);
        }

         int ICollection.Count
        {
             get
            {
                 return ( this.BaseCollection  as ICollection).Count;
            }
        }

         bool ICollection.IsSynchronized
        {
             get
            {
                 return ( this.BaseCollection  as ICollection).IsSynchronized;
            }
        }

         object ICollection.SyncRoot
        {
             get
            {
                 return ( this.BaseCollection  as ICollection).SyncRoot;
            }
        }

         #endregion

         #region 事件处理

         event PropertyChangedEventHandler INotifyPropertyChanged.PropertyChanged
        {
            add
            {
                 if ( this.BaseCollection  is INotifyPropertyChanged)
                {
                    ( this.BaseCollection  as INotifyPropertyChanged).PropertyChanged += value;
                }
                 else
                {
                     throw  new InvalidOperationException( string.Format( " {0} is not implement interface {1}. ",  this.BaseCollection.GetType(),  typeof(INotifyPropertyChanged)));
                }
            }
            remove
            {
                 if ( this.BaseCollection  is INotifyPropertyChanged)
                {
                    ( this.BaseCollection  as INotifyPropertyChanged).PropertyChanged -= value;
                }
                 else
                {
                     throw  new InvalidOperationException( string.Format( " {0} is not implement interface {1}. ",  this.BaseCollection.GetType(),  typeof(INotifyPropertyChanged)));
                }
            }
        }

         event NotifyCollectionChangedEventHandler INotifyCollectionChanged.CollectionChanged
        {
            add
            {
                 if ( this.BaseCollection  is INotifyCollectionChanged)
                {
                    ( this.BaseCollection  as INotifyCollectionChanged).CollectionChanged += value;
                }
                 else
                {
                     throw  new InvalidOperationException( string.Format( " {0} is not implement interface {1}. ",  this.BaseCollection.GetType(),  typeof(INotifyCollectionChanged)));
                }
            }
            remove
            {
                 if ( this.BaseCollection  is INotifyCollectionChanged)
                {
                    ( this.BaseCollection  as INotifyCollectionChanged).CollectionChanged -= value;
                }
                 else
                {
                     throw  new InvalidOperationException( string.Format( " {0} is not implement interface {1}. ",  this.BaseCollection.GetType(),  typeof(INotifyCollectionChanged)));
                }
            }
        }

         #endregion
    }

这个类简单实现ICollectionEx<>这个接口，同时为便于对ObservableCollection<>的扩展，实现了INotifyPropertyChanged结合和INotifyCollectionChanged接口，代码都i很简单。

 

4——

CollectionProxy<TSource, TBase>类，这个类是目标，解决了需求中提到的问题。TSource和TBase之间可以没有任何的关系。TBase类型与TSource类型之间的转换，默认下是进行强制操作，其它情况下，可以通过在构造函数中传递两对象类型转换委托实现。具体代码如下：

 

     public  class CollectionProxy<TSource, TBase> : ICollectionEx<TSource>
    {
         #region 构造函数

         private ICollectionEx<TBase> _baseCollection;
        Func<TSource, TBase> _convertSourceToBaseHandler =  null;
        Func<TBase, TSource> _convertBaseToSourceHandler =  null;

         public CollectionProxy(Collection<TBase> baseCollection, Func<TSource, TBase> convertSourceToBaseHandler =  null, Func<TBase, TSource> convertBaseToSourceHandler =  null)
            :  this( new CollectionExProxy<TBase>(baseCollection), convertSourceToBaseHandler, convertBaseToSourceHandler)
        {
        }

         public CollectionProxy(ICollectionEx<TBase> baseCollection, Func<TSource, TBase> convertSourceToBaseHandler =  null, Func<TBase, TSource> convertBaseToSourceHandler =  null)
        {
             if (baseCollection ==  null)
            {
                 throw  new ArgumentNullException( " baseCollection ");
            }
             this._baseCollection = baseCollection;
            _convertSourceToBaseHandler = convertSourceToBaseHandler;
            _convertBaseToSourceHandler = convertBaseToSourceHandler;
        }

         #endregion

         #region 转换函数

         private TSource BaseToSourceHandler(TBase @base)
        {
             if ( this._convertBaseToSourceHandler !=  null)
            {
                 return  this._convertBaseToSourceHandler(@base);
            }
             return  this.BaseToSourceHandlerInternal(@base);
        }

         protected  virtual TSource BaseToSourceHandlerInternal(TBase @base)
        {
             return (TSource)( object)@base;
        }

         private TBase SourceToBaseHandler(TSource source)
        {
             if ( this._convertBaseToSourceHandler !=  null)
            {
                 return  this._convertSourceToBaseHandler(source);
            }
             return  this.SourceToBaseHandlerInternal(source);
        }

         protected  virtual TBase SourceToBaseHandlerInternal(TSource source)
        {
             return (TBase)( object)source;
        }

         #endregion

         #region 功能函数

         public  void Add(TSource item)
        {
             int count =  this.Count;
             this.InsertItem(count, item);
        }

         public  void Clear()
        {
             this.ClearItems();
        }

         protected  virtual  void ClearItems()
        {
             this.BaseCollection.Clear();
        }

         public  bool Contains(TSource item)
        {
             return  this.BaseCollection.Contains(SourceToBaseHandler(item));
        }

         public  void CopyTo(TSource[] array,  int index)
        {
             if (array ==  null)
            {
                 throw  new ArgumentNullException( " array ");
            }
            TBase[] tmp =  new TBase[array.Length];
             this.BaseCollection.CopyTo(tmp, index);
             for ( int i = index; i < index + ( this._baseCollection  as IList).Count; i++)
            {
                array[i] = BaseToSourceHandler(tmp[i]);
            }
        }

         public IEnumerator<TSource> GetEnumerator()
        {
             foreach ( var item  in  this._baseCollection)
            {
                 yield  return BaseToSourceHandler(item);
            }
        }

         public  int IndexOf(TSource item)
        {
             return  this.IndexOfItem(item);
        }

         protected  virtual  int IndexOfItem(TSource item)
        {
             return  this.BaseCollection.IndexOf(SourceToBaseHandler(item));
        }

         public  void Insert( int index, TSource item)
        {
             this.InsertItem(index, item);
        }

         protected  virtual  int InsertItem( int index, TSource item)
        {
             this.BaseCollection.Insert(index, SourceToBaseHandler(item));
             return index;
        }

         private  static  bool IsCompatibleObject( object value)
        {
             return ((value  is TSource) || ((value ==  null) && ( default(TSource) ==  null)));
        }

         public  bool Remove(TSource item)
        {
             int index =  this.IndexOf(item);
             if (index <  0)
            {
                 return  false;
            }
             this.RemoveItem(index);
             return  true;
        }

         public  void RemoveAt( int index)
        {
             this.RemoveItem(index);
        }

         protected  virtual  void RemoveItem( int index)
        {
             this.BaseCollection.RemoveAt(index);
        }

         protected  virtual  void SetItem( int index, TSource item)
        {
             this.BaseCollection[index] = SourceToBaseHandler(item);
        }

         public  int Count
        {
             get
            {
                 return  this.BaseCollection.Count;
            }
        }

         protected  virtual TSource GetValue( int index)
        {
             return BaseToSourceHandler( this.BaseCollection[index]);
        }

         public TSource  this[ int index]
        {
             get
            {
                 return  this.GetValue(index);
            }
             set
            {
                 this.SetItem(index, value);
            }
        }

         protected ICollectionEx<TBase> BaseCollection
        {
             get
            {
                 return  this._baseCollection;
            }
        }

         #endregion

         #region ICollectionEx<TSource>

         int ICollectionEx<TSource>.Count
        {
             get
            {
                 return ( this  as IList<TSource>).Count;
            }
        }

         void ICollectionEx<TSource>.RemoveAt( int index)
        {
            ( this  as IList<TSource>).RemoveAt(index);
        }

         void ICollectionEx<TSource>.Clear()
        {
            ( this  as IList<TSource>).Clear();
        }

        TSource ICollectionEx<TSource>. this[ int index]
        {
             get
            {
                 return ( this  as IList<TSource>)[index];
            }
             set
            {
                ( this  as IList<TSource>)[index] = value;
            }
        }

         bool ICollectionEx<TSource>.IsReadOnly
        {
             get
            {
                 return ( this  as IList<TSource>).IsReadOnly;
            }
        }

         #endregion

         #region IList<TSource>

         int IList<TSource>.IndexOf(TSource item)
        {
             return  this.IndexOf(item);
        }

         void IList<TSource>.Insert( int index, TSource item)
        {
             this.Insert(index, item);
        }

         void IList<TSource>.RemoveAt( int index)
        {
             this.RemoveAt(index);
        }

        TSource IList<TSource>. this[ int index]
        {
             get
            {
                 return  this[index];
            }
             set
            {
                 this[index] = value;
            }
        }

         #endregion

         #region ICollection<TSource>

         void ICollection<TSource>.Add(TSource item)
        {
             this.Add(item);
        }

         void ICollection<TSource>.Clear()
        {
             this.Clear();
        }

         bool ICollection<TSource>.Contains(TSource item)
        {
             return  this.Contains(item);
        }

         void ICollection<TSource>.CopyTo(TSource[] array,  int arrayIndex)
        {
             this.CopyTo(array, arrayIndex);
        }

         int ICollection<TSource>.Count
        {
             get
            {
                 return  this.Count;
            }
        }

         bool ICollection<TSource>.IsReadOnly
        {
             get
            {
                 return  this._baseCollection.IsReadOnly;
            }
        }

         bool ICollection<TSource>.Remove(TSource item)
        {
             return  this.Remove(item);
        }

         #endregion

         #region IEnumerable<TSource>

        IEnumerator<TSource> IEnumerable<TSource>.GetEnumerator()
        {
             return  this.GetEnumerator();
        }

         #endregion

         #region IEnumerable

        IEnumerator IEnumerable.GetEnumerator()
        {
             return  this.GetEnumerator();
        }

         #endregion

         #region IList

         int IList.Add( object value)
        {
             if (IsCompatibleObject(value))
            {
                 int index =  this.Count;
                 this.InsertItem(index, (TSource)value);
                 return index;
            }
             throw  new InvalidCastException();
        }

         void IList.Clear()
        {
             this.Clear();
        }

         bool IList.Contains( object value)
        {
             if (IsCompatibleObject(value))
            {
                 return  this.Contains((TSource)value);
            }
             return  false;
        }

         int IList.IndexOf( object value)
        {
             if (IsCompatibleObject(value))
            {
                 return  this.IndexOf((TSource)value);
            }
             return - 1;
        }

         void IList.Insert( int index,  object value)
        {
             if (IsCompatibleObject(value))
            {
                 this.Insert(index, (TSource)value);
            }
             else
            {
                 throw  new InvalidCastException();
            }
        }

         bool IList.IsFixedSize
        {
             get
            {
                 return  this.BaseCollection.IsFixedSize;
            }
        }

         bool IList.IsReadOnly
        {
             get
            {
                 return  this.BaseCollection.IsReadOnly;
            }
        }

         void IList.Remove( object value)
        {
             if (IsCompatibleObject(value))
            {
                 this.Remove((TSource)value);
            }
             else
            {
                 throw  new InvalidCastException();
            }
        }

         void IList.RemoveAt( int index)
        {
             this.RemoveAt(index);
        }

         object IList. this[ int index]
        {
             get
            {
                 return  this[index];
            }
             set
            {
                 if (IsCompatibleObject(value))
                {
                     this[index] = (TSource)value;
                }
                 else
                {
                     throw  new InvalidCastException();
                }
            }
        }

         #endregion

         #region ICollection

         void ICollection.CopyTo(Array array,  int index)
        {
            TSource[] tmp =  new TSource[array.Length];
             this.CopyTo(tmp, index);
             for ( int i = index; i < array.Length; i++)
            {
                array.SetValue(tmp[i], i);
            }
        }

         int ICollection.Count
        {
             get
            {
                 return  this.Count;
            }
        }

         bool ICollection.IsSynchronized
        {
             get
            {
                 return  this.BaseCollection.IsSynchronized;
            }
        }

         object ICollection.SyncRoot
        {
             get
            {
                 return  this.BaseCollection.SyncRoot;
            }
        }

         #endregion
    }

这个类在构造的时候

5——

一个对应的只读类ReadOnlyCollectionEx的实现

 

     public  class ReadOnlyCollectionEx<T> : ICollectionEx<T>
    {
         #region 构造函数

        [NonSerialized]
         private  object _syncRoot;
         private IList<T>[] _lists;

         public ReadOnlyCollectionEx(IList<T> list,  params IList<T>[] lists)
        {
             if (list ==  null)
            {
                 throw  new ArgumentNullException( " list ");
            }
             this._lists =  new IList<T>[lists.Length +  1];
            _lists[ 0] = list;
             for ( int i =  0; i < lists.Length; i++)
            {
                 if (lists[i] ==  null)
                {
                     throw  new ArgumentNullException( " lists ",  " 顺序号为 {0} 的对象为空。 ".FormatWith(i));
                }
                _lists[i +  1] = lists[ 0];
            }
        }

         #endregion

         #region 基本操作

        [TargetedPatchingOptOut( " Performance critical to inline across NGen image boundaries ")]
         public  bool Contains(T value)
        {
             return  this.ContainsInternal(value);
        }

         protected  virtual  bool ContainsInternal(T value)
        {
             return  this.IndexOf(value) >=  0;
        }

         public  void CopyTo(Array array,  int index)
        {
             if (array ==  null)
            {
                 throw  new ArgumentNullException( " array ");
            }
             if (array.Rank !=  1)
            {
                 throw  new ArgumentOutOfRangeException( " array ",  " 只支持一维数组。 ");
            }
             if (array.GetLowerBound( 0) !=  0)
            {
                 throw  new ArgumentOutOfRangeException( " array ",  " 只支持0基数组。 ");
            }
             if (index <  0)
            {
                 throw  new ArgumentOutOfRangeException( " index ",  " 不能为负数 ");
            }
             if ((array.Length - index) <  this.Count)
            {
                 throw  new ArgumentOutOfRangeException( " array, index ",  " 数组空间不足 ");
            }
             this.CopyToInternal(array, index);
        }

         protected  virtual  void CopyToInternal(Array array,  int index)
        {
             for ( int i =  0; i <  this.Count; i++)
            {
                array.SetValue( this[i], index + i);
            }
        }

         public  int IndexOf(T value)
        {
             return  this.IndexOfInternal(value);
        }

         protected  virtual  int IndexOfInternal(T value)
        {
             int index =  0;
             for ( int i =  0; i <  this._lists.Length; i++)
            {
                 int currentIndex =  this._lists[i].IndexOf(value);
                 if (currentIndex >=  0)
                {
                     return index + currentIndex;
                }
                 else
                {
                    index +=  this._lists[i].Count;
                }
            }
             return - 1;
        }

         public  int Count
        {
             get
            {
                 return  this.CountInternal;
            }
        }

         protected  virtual  int CountInternal
        {
            [TargetedPatchingOptOut( " Performance critical to inline across NGen image boundaries ")]
             get
            {
                 int count =  0;
                 for ( int i =  0; i <  this._lists.Length; i++)
                {
                    count += _lists[i].Count;
                }
                 return count;
            }
        }

         public T  this[ int index]
        {
             get
            {
                 if (index <  0)
                {
                     throw  new ArgumentOutOfRangeException( " index ");
                }
                 return  this.GetDataItem(index);
            }
        }

         protected  virtual T GetDataItem( int index)
        {
             int tmp = index;
             for ( int i =  0; i <  this._lists.Length; i++)
            {
                 if (tmp <  this._lists[i].Count)
                {
                     return  this._lists[i][tmp];
                }
                tmp -= _lists[i].Count;
            }
             throw  new ArgumentOutOfRangeException( " index ");
        }

         public IEnumerator<T> GetEnumerator()
        {
             return  this.GetEnumeratorInternal();
        }

         protected  virtual IEnumerator<T> GetEnumeratorInternal()
        {
             for ( int i =  0; i <  this._lists.Length; i++)
            {
                 for ( int j =  0; j <  this._lists[i].Count; j++)
                {
                     yield  return  this._lists[i][j];
                }
            }
        }

         private  static  bool IsCompatibleObject( object value)
        {
             return ((value  is T) || ((value ==  null) && ( default(T) ==  null)));
        }

         protected IList<T>[] Items
        {
             get
            {
                 return  this._lists;
            }
        }

         #endregion

         #region 获取枚举集合操作

        IEnumerator<T> IEnumerable<T>.GetEnumerator()
        {
             return  this.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
             return  this.GetEnumerator();
        }

         #endregion

         #region 禁止写操作

         void ICollection<T>.Add(T value)
        {
             throw  new NotImplementedException( " 只读集合，禁止操作对象。 ");
        }

         void ICollection<T>.Clear()
        {
             throw  new NotImplementedException( " 只读集合，禁止操作对象。 ");
        }

         bool ICollection<T>.Remove(T value)
        {
             throw  new NotImplementedException( " 只读集合，禁止操作对象。 ");
        }

         void IList<T>.Insert( int index, T value)
        {
             throw  new NotImplementedException( " 只读集合，禁止操作对象。 ");
        }

         void IList<T>.RemoveAt( int index)
        {
             throw  new NotImplementedException( " 只读集合，禁止操作对象。 ");
        }

         #endregion

         #region 接口其它实现

         void ICollection.CopyTo(Array array,  int index)
        {
             this.CopyTo(array, index);
        }

         void ICollection<T>.CopyTo(T[] array,  int index)
        {
             this.CopyTo(array, index);
        }

         int IList.Add( object value)
        {
             throw  new NotImplementedException( " 只读集合，禁止操作对象。 ");
        }

         void IList.Clear()
        {
             throw  new NotImplementedException( " 只读集合，禁止操作对象。 ");
        }

         bool IList.Contains( object value)
        {
             return (ReadOnlyCollectionEx<T>.IsCompatibleObject(value) &&  this.Contains((T)value));
        }

         int IList.IndexOf( object value)
        {
             if (IsCompatibleObject(value))
            {
                 return  this.IndexOf((T)value);
            }
             return - 1;
        }

         void IList.Insert( int index,  object value)
        {
             throw  new NotImplementedException( " 只读集合，禁止操作对象。 ");
        }

         void IList.Remove( object value)
        {
             throw  new NotImplementedException( " 只读集合，禁止操作对象。 ");
        }

         void IList.RemoveAt( int index)
        {
             throw  new NotImplementedException( " 只读集合，禁止操作对象。 ");
        }

         bool ICollection<T>.IsReadOnly
        {
             get
            {
                 return  true;
            }
        }

        T IList<T>. this[ int index]
        {
             get
            {
                 return  this[index];
            }
             set
            {
                 throw  new NotImplementedException( " 只读集合，禁止操作对象。 ");
            }
        }

         bool ICollection.IsSynchronized
        {
             get
            {
                 return  false;
            }
        }

         object ICollection.SyncRoot
        {
             get
            {
                 if ( this._syncRoot ==  null)
                {
                    ICollection list =  this._lists  as ICollection;
                     if (list !=  null)
                    {
                         this._syncRoot = list.SyncRoot;
                    }
                     else
                    {
                        Interlocked.CompareExchange< object>( ref  this._syncRoot,  new  object(),  null);
                    }
                }
                 return  this._syncRoot;
            }
        }

         bool IList.IsFixedSize
        {
             get
            {
                 return  true;
            }
        }

         bool IList.IsReadOnly
        {
             get
            {
                 return  true;
            }
        }

         object IList. this[ int index]
        {
            [TargetedPatchingOptOut( " Performance critical to inline across NGen image boundaries ")]
             get
            {
                 return  this[index];
            }
             set
            {
                 throw  new NotImplementedException( " 只读集合，禁止操作对象。 ");
            }
        }

         #endregion

         #region ICollectionEx<T>

         int ICollectionEx<T>.Count
        {
             get
            {
                 return ( this  as IList<T>).Count;
            }
        }

         void ICollectionEx<T>.RemoveAt( int index)
        {
            ( this  as IList<T>).RemoveAt(index);
        }

         void ICollectionEx<T>.Clear()
        {
            ( this  as IList<T>).Clear();
        }

        T ICollectionEx<T>. this[ int index]
        {
             get
            {
                 return ( this  as IList<T>)[index];
            }
             set
            {
                ( this  as IList<T>)[index] = value;
            }
        }

         bool ICollectionEx<T>.IsReadOnly
        {
             get
            {
                 return ( this  as IList<T>).IsReadOnly;
            }
        }

         #endregion

    }

这个类只是简单的实现ICollectionEx接口对象的只读化处理，与系统ReadOnlyCollection<>类不同的是，该类支持多个原始数据集合类的构造，可以把多个原始集合类集成为一个统一的集合类对外提供服务。

 

在输出数据集合的时候，该类默认按照集合的顺序逐个输出，也就是说，先按照集合排队，再按照子集合内部的顺序输出。基于LINQ的原因，集合的顺序可以任意排列。

 

 

【应用示例】

一个前面提到的文件系统的需求的实现：

 

         private Collection<FileSystemInfo> _foldersBase =  new Collection<FileSystemInfo>();
         private ICollectionEx<DirectoryInfo> _folders;
         public ICollectionEx<DirectoryInfo> Folders
        {
             get
            {
                 if ( this._folders ==  null)
                {
                     this._folders =  new CollectionProxy<DirectoryInfo, FileSystemInfo>(_foldersBase);
                }
                 return _folders;
            }
        }

         private Collection<FileSystemInfo> _filesBase =  new Collection<FileSystemInfo>();
         private ICollectionEx<FileInfo> _files;
         public ICollectionEx<FileInfo> Files
        {
             get
            {
                 if ( this._files ==  null)
                {
                     this._files =  new CollectionProxy<FileInfo, FileSystemInfo>(_filesBase);
                }
                 return _files;
            }
        }

         private ReadOnlyCollectionEx<FileSystemInfo> _children;
         public ReadOnlyCollectionEx<FileSystemInfo> Children
        {
             get
            {
                 if ( this._children ==  null)
                {
                     this._children =  new ReadOnlyCollectionEx<FileSystemInfo>(_foldersBase, _filesBase);
                }
                 return  this._children;
            }
        }