博客园_海观尽头蜗作岸山登绝顶牛为峰

LINQ：是BUG还是~~~

2011-11-10T09:53:00Z

最近在使用SQL LINQ的时候遭遇一个问题：

【表结构】

两个表：A是主表，B是从表，同时，在A中又有一个字段记录最后一次操作的B表数据的主键，关系如图：

关系A->B是一对多，关系B->A是一对一。

【操作】

1——

建立B中的第一条数据

当A与B之间尚未有关联数据的时候，对表A进行更新操作没有异常。

2——

简单更新A

B中与A相关的数据只有一条，此时对A进行更新操作

3——

建立B中的第二条数据

【异常】

当操作在本地以桌面的形式运行的时候，以上三个步骤都能正常运行。

但当操作以WebService的形式运行的时候，2、3操作报告转换错误。

【疑惑】

假如这个操作是有问题的，为什么在桌面形式的应用中是OK的，而假如这个操作是OK的，又为什么在WebService的形式运行的时候抛出异常？

【项目】

功能以一个DLL的方式实现，然后分别通过加载WebService或Win32外壳的形式调用这个功能模块。

本文链接

集合代理类的实现

2011-11-05T03:29:00Z

【问题的提出】

以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;
            }
        }

本文链接

WPF对绑定到数据的树初始化选择项

2011-11-04T01:27:00Z

【需求】

1——

对一棵绑定到数据源的树，当初始化加载后，设置树的初始化选择对象。

比如：当我们实现对行业的选择树时，希望当打开这棵树的时候，树能自动把之前已经选择的或者系统默认的树标记为选择状态。

2——

数据源是一个动态加载的集合，即：当我们展开或选择某一个数据节点的时候，系统自动实现该数据节点下级子数据集合的加载

如Windows的文件系统，资源管理器不是一次性的把整个文件系统都加载在内存，而是当我们需要打开某一个文件夹的时候，文件系统才会去加载这个文件夹的下级文件信息。

【问题】

1——

当TreeViewItem被选择或展开后自动加载下级数据集合需要控制需要额外编写代码实现

2——

当TreeView绑定到数据的时候，封闭了开发人员直接使用TreeViewItem的可能，要操纵TreeViewItem需要通过特殊的手段来实现。

3——

WPF中的TreeView不可以通过设置SelectedItem（只读）来实现当前选择对象的设定。

【解决】

1——

可以通过路由事件跟踪，TreeViewItem的SelectedEvent和ExpandedEvent是可路由事件，因此通过在TreeView或其上级容器中跟踪这两个路由事件来达到目的：

    protected override void OnInitialized(EventArgs e)
    {
        this.AddHandler(TreeViewItem.ExpandedEvent, new RoutedEventHandler(TreeViewItemHandler));
        this.AddHandler(TreeViewItem.SelectedEvent, new RoutedEventHandler(TreeViewItemHandler));
        base.OnInitialized(e);
    }

    void TreeViewItemHandler(object sender, RoutedEventArgs e)
    {
        TreeViewItemEx item = e.OriginalSource as TreeViewItemEx;
        if (item != null && item.DataContext is FileFolder)
        {
            (item.DataContext as FileFolder).Load();
        }
    }

2——

如问题1的解决方案，当跟踪到TreeViewItem被选择或展开时，获取该TreeViewItem的DataContext（即数据对象）并执行数据的加载：

        TreeViewItemEx item = e.OriginalSource as TreeViewItemEx;
        if (item != null && item.DataContext is FileFolder)
        {
            (item.DataContext as FileFolder).Load();
        }

3——

因为SelectedItem是只读的，而且，TreeView也没有提供设置初始化选择项的功能，要达到目的就只能自己想办法了。

由于TreeView的树结构中没有提供直接访问树节点对象的支持，我们只能通过其对象集合Items属性来获取数据对象，在查阅相关资料后，找到了通过数据对象来获取对应的TreeViewItem的方法：

    public static TreeViewItemEx GetChildItem(ItemsControl container, object data)
    {
        if (container == null || data == null)
        {
            return null;
        }
        try
        {
            TreeViewItemEx result = container.ItemContainerGenerator.ContainerFromItem(data) as TreeViewItemEx;
            if (result != null)
            {
                return result;
            }
        }
        catch
        {
        }
        foreach (var item in container.Items)
        {
            if (item == null)
            {
                continue;
            }
            if (item is TreeViewItemEx && (item as TreeViewItemEx).DataContext != null && (item as TreeViewItemEx).DataContext.Equals(data))
            {
                return item as TreeViewItemEx;
            }
            if (item.Equals(data))
            {
                return container.ItemContainerGenerator.ContainerFromItem(item) as TreeViewItemEx;
            }
        }
        return null;
    }

【方案】

1——

要达到指定数据对象对应的TreeViewItem的选择，必须有一条从树的根节点到到目标节点的数据路径，这里定义这个数据路径为：LinkList<object> list，获取这个数据路径的方法为：

    public LinkedList<object> GetDataPathFromRoute(object dataItem)
    {
        LinkedList<object> list = new LinkedList<object>();
        this.GetDataPathFromRoute(list, dataItem);
        return list;
    }

    private void GetDataPathFromRoute(LinkedList<object> list, object dataItem)
    {
        if (dataItem == null)
        {
            return;
        }
        object parent = GetParentObject(dataItem);
        if (IsStopObject(dataItem))
        {
            if (dataItem == null)
            {
                return;
            }
            list.AddLast(dataItem);
            return;
        }
        this.GetDataPathFromRoute(list, parent);
        list.AddLast(dataItem);
    }

    private bool IsStopObject(object dataItem)
    {
        if (dataItem == null)
        {
            return true;
        }
        if (dataItem is string && string.IsNullOrEmpty(dataItem as string))
        {
            return true;
        }
        return this.Equals(dataItem);
    }

    private object GetParentObject(object dataItem)
    {
        if (dataItem is FileItemInfoBase)
        {
            return this.GetParentObject((dataItem as FileItemInfoBase).FileItem);
        }
        if (dataItem is FileInfo)
        {
            return (dataItem as FileInfo).Directory;
        }
        if (dataItem is DirectoryInfo)
        {
            if ((dataItem as DirectoryInfo).Root == dataItem)
            {
                return null;
            }
            return (dataItem as DirectoryInfo).Parent;
        }
        if (dataItem is string)
        {
            if (File.Exists(dataItem as string))
            {
                return new FileInfo(dataItem as string).Directory;
            }
            return new DirectoryInfo(dataItem as string).Parent;
        }
        return null;
    }

2——

数据路径树节点的展开：

    public object InitializeItem
    {
        set
        {
            LinkedList<object> list = GetDataPathFromRoute(value);
            if (list != null && list.First != null)
            {
                LinkedListNode<object> node = list.First;
                ItemsControl container = treeView;
                while (node != null)
                {
                    TreeViewItemEx item = GetChildItem(container, node);
                    if (item == null)
                    {
                        container = null;
                        return;
                    }
                    item.IsExpanded = true;
                    container = item;
                    node = node.Next;
                }
                if (container != null && container is TreeViewItem)
                {
                    (container as TreeViewItem).IsSelected = true;
                }
            }
        }
    }

在实际的运行中，这段代码并不可行，除非数据树（TreeView）的数据源是初始化全加载的（个人臆测，这个没验证过），因为当我们执行TreeViewItem的展开操作的时候，是正确的执行的下级数据集合的加载，但此时，没有办法通过前面的GetChildItem来获取目标的TreeViewItem对象，返回的始终是空。

经过分析，认为TreeViewItem的子对象的创建有一个延迟（跟初始化数据操作InitializeItem在同一个线程中），从而导致了即便数据加载了，而TreeViewItem的下级UI对象还没有创建而是空的。

3——

经过对TreeViewItem的各个事件（以及可重载函数=属性）进行跟踪，发现，当加载TreeViewItem的下级数据的时候，会触发ItemsSourceChanged事件，紧接着，会触发OnRender方法的执行，而且，OnRender方法执行后，下级TreeViewItem对象也就已经创建了，因此代码修改如下：

        private void setCurrPath_Click(object sender, RoutedEventArgs e)
        {
            if (Directory.Exists(this.rootPath.Text) && this.Folder != null)
            {
                DirectoryInfo dir = new DirectoryInfo(this.currPath.Text);
                LinkedList<object> list = this.Folder.GetDataPathFromRoute(dir);
                if (list.First != null)
                {
                    this.treeViewEx1.SetInitializeSelectedItem(list.First);
                }
            }
        }

TreeViewEx类的SetInitializeItem方法代码如下：

        public void SetInitializeSelectedItem(LinkedListNode<object> dataLink)
        {
            if (dataLink == null || dataLink.Value == null)
            {
                return;
            }
            TreeViewItemEx item = TreeViewItemEx.GetChildItem(this, dataLink.Value);
            if (item == null && this.Items.Count == 1)
            {
                item = TreeViewItemEx.GetChildItem(TreeViewItemEx.GetChildItem(this, this.Items[0]), dataLink.Value);
            }
            if (item != null)
            {
                if (dataLink.Next != null && dataLink.Next.Value != null)
                {
                    item.SetInitializeSelectedItem(dataLink.Next);
                }
                else
                {
                    item.IsSelected = true;
                }
            }
        }

TreeViewItemEx对应的代码如下：

        private bool _rendered = false;
        protected override void OnItemsSourceChanged(System.Collections.IEnumerable oldValue, System.Collections.IEnumerable newValue)
        {
            this._rendered = false;
            base.OnItemsSourceChanged(oldValue, newValue);
        }

        protected override void OnRender(DrawingContext drawingContext)
        {
            if (!_rendered)
            {
                this.SetInitializeSelectedItem();
                this._rendered = true;
            }
            base.OnRender(drawingContext);
        }

        protected override void OnSelected(RoutedEventArgs e)
        {
            this.IsExpanded = true;
            base.OnSelected(e);
        }

        private bool _mustInitializeSelectedItem = false;
        private LinkedListNode<object> _initializeSelectedItem = null;
        internal void SetInitializeSelectedItem(LinkedListNode<object> dataLink)
        {
            if (dataLink == null || dataLink.Value == null)
            {
                return;
            }
            this._mustInitializeSelectedItem = true;
            this._initializeSelectedItem = dataLink;
            if (this._rendered)
            {
                this.InitializeSelectedItem(false);
            }
        }

        private void InitializeSelectedItem(bool rendered)
        {
            TreeViewItemEx childItem = GetChildItem(this, this._initializeSelectedItem.Value);
            if (childItem != null)
            {
                if (!childItem.IsExpanded && this._initializeSelectedItem.Next != null && this._initializeSelectedItem.Next.Value != null)
                {
                    childItem.IsExpanded = true;
                    childItem.SetInitializeSelectedItem(this._initializeSelectedItem.Next);
                }
                else
                {
                    childItem.IsSelected = true;
                }
            }
            else
            {
                if (this.IsExpanded || rendered)
                {
                    this.IsSelected = true;
                }
                else
                {
                    this.IsExpanded = true;
                }
            }
        }

        private void SetInitializeSelectedItem()
        {
            if (!this._mustInitializeSelectedItem)
            {
                return;
            }
            _mustInitializeSelectedItem = false;
            this.InitializeSelectedItem(true);
        }

至此，需求已经达到。

【存在问题】

在以上的解决方案中，理论上，问题已经圆满的解决（甚至自以为是完美的解决了），但在实际使用中，却出现新的问题：

不稳定，有时能成功展开，达到目的（跟树的路径深度无关，不过，树的路径深度低的话，成功的可能性大）。

附参考代码程序。
/Files/Daview/WpfApplication1.zip

本文链接

SilverLight中的数据绑定

2010-05-06T02:54:00Z

需要执行个数据绑定，结果遇到问题，绑定失败，经实验，结果如下：1——只能对属性操作（PROPERTY），不能对字段（FIELD）操作。2——目标类必须是PUBLIC的，目标属性也必须是PUBLIC的。（这个问题很奇怪，不知道为什么，MS在SL中禁止通过REFLECTER机制来操纵PRIVATE的内容，而跨模块的时候，INTERNAL也不可以操作，只能操作PUBLIC的）3——不能使用匿名对象（这个问题其实第一和第二已经解释，匿名对象是私有类、内容是字段形式表示的）只是感觉，MS这样做，让数据操作会很麻烦，匿名类的强力应用在SL中就此打个折扣，BS下！不知道是否有其它的更好的解决方案。附带说下：

[请教]关于 .NET 应用的几个问题请教！！！（

2008-03-27T02:37:00Z

1—— 在.NET应用中，假如一个DLL想给多个应用程序共享，常规方案是注册到GAC，但这个方案很麻烦，需要注册，容易产生垃圾。（比如在ASP.NET中，如果更新注册到GAC中的DLL非常不方便，特别是大型网站使用负载均衡时代码同步）。问题：能否不注册到GAC也能让多个应用共享DLL？比如：某些项目可以把DLL放置到PROGRAMFILES文件夹的COMMON中来实现。 2—— 同问题1，在...

如何解决自定义控件构造被设计器删除？

2007-02-10T06:37:00Z

在WinForm下，通过通过UserControl派生的自定义控件，如果在宿主窗体的设计中做了修改，设计器会自动的把构造代码删除（即InitializeComponents中的创建对象代码），有好办法解决吗？实在没有时间查资料，哈哈。

遭遇品牌电脑的尴尬

2006-09-22T07:29:00Z

呵呵，这个品派是HAIER。前几天，去同学那，同学要我帮忙弄下电脑并重新安装系统。要完全重新安装系统当然要设置BIOS为从CDROM启动了，这个简单，哈哈，地球人都知道，不是地球人也知道了。设置好后，重新启动电脑，问题出来了：系统还是从硬盘启动，为什么？第一感觉就是BIOS的数据没有有效保存，但我明明是执行了保存操作的，怎么会这样呢？再进入BIOS，发现数据确实没有保存，于是再次设置后重新启动。这...

面对VS2005，我遇到了BUG？

2006-09-22T07:19:00Z

产品开发一直计划使用2005，终于能成行是件高兴的事情，但期间遇到几件怪事情：1——ICO编辑器无效。通过IDE编辑ICO文件，能编辑，也显示保存成功，但再打开，数据还是原来的，郁闷。现在要编辑ICO都是回到2003来处理。2——TRY-CATCH-FINALY的无奈。TRY的目的是为了捕获异常，或者为了调试，或者为了避免不必要、不确定的麻烦CATCH是为了处理TRY捕获的异常FINALY是为了进...

FOREACH的遍历

2006-09-15T07:46:00Z

在使用FOREACH对集合进行遍历的时候，要求被遍历的对象必须实现了IENUMABLE接口，而该接口的唯一成员方法GETENUMATOR返回实现了IENUMATOR接口的实例对象。检测IENUMATOR，发现有3个成员，分别是：CURRENT、MOVENEXT、RESET，CURRENT返回当前的成员对象；MOVENEXT把指针向下移动一个位置，如果存在实例成员则返回true，否则返回false，...

该死的微软，该死的文档，该死的ExecuteCommand

2006-09-15T02:45:00Z

写了个WinService，想通过控制界面对Service进行STOP、START之外的其它控制，比如执行相关命令。在使用ServiceController中，发现只有一个ExecuteCommand方法可以进行控制处理，而该死的ExecuteCommand只有一个int类型的参数可传递，该死！！！int就int吧，本人把32位int进行分段处理以实现传递复杂命令的需求。该死的ExecuteCom...

博客园_海观尽头蜗作岸 山登绝顶牛为峰

LINQ：是BUG还是~~~

集合代理类的实现

WPF对绑定到数据的树初始化选择项

SilverLight中的数据绑定

[请教]关于 .NET 应用的几个问题请教！！！（

如何解决 自定义控件 构造被设计器删除？

遭遇品牌电脑的尴尬

面对VS2005，我遇到了BUG？

FOREACH的遍历

该死的微软，该死的文档，该死的ExecuteCommand

博客园_海观尽头蜗作岸山登绝顶牛为峰

如何解决自定义控件构造被设计器删除？