【代码片段】序列化和反序列化之集合

    /// <summary>
    /// 集合项
    /// </summary>
    [Serializable]
    public class LibCollectionItem : LibSerializationObject
    {
        private int _Index;
        private object _Owner;
        /// <summary>
        /// 序号
        /// </summary>
        [ReadOnly(true)]
        [Browsable(true)]
        public int Index
        {
            get
            {
                return this._Index;
            }
            set
            {
                this._Index = value;
            }
        }
        /// <summary>
        /// 父对象
        /// </summary>
        [Browsable(false)]
        public object Owner
        {
            get
            {
                return this._Owner;
            }
        }
        /// <summary>
        /// 构造函数
        /// </summary>
        public LibCollectionItem()
        {
            this._Index = -1;
            this._Owner = null;
        }
        /// <summary>
        /// 设置父对象
        /// </summary>
        /// <param name="owner">父对象</param>
        public void SetOwner(object owner)
        {
            this._Owner = owner;
        }

        #region 序列化相关方法成员
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="info"></param>
        /// <param name="context"></param>
        public LibCollectionItem(SerializationInfo info, StreamingContext context)
            : base(info, context)
        {
            this._Index = GetIntValue(info, "Index", -1);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="info"></param>
        /// <param name="context"></param>
        public override void GetObjectData(SerializationInfo info, StreamingContext context)
        {
            base.GetObjectData(info, context);
            info.AddValue("Index", this._Index);
        }
        #endregion
    }
    /// <summary>
    /// 集合类
    /// </summary>
    /// <typeparam name="T">集合项类型</typeparam>
    [Serializable]
    public class LibCollection<T> : CollectionBase where T : LibCollectionItem
    {
        private object _Owner;
        /// <summary>
        /// 父对象
        /// </summary>
        public object Owner
        {
            get
            {
                return this._Owner;
            }
        }
        /// <summary>
        /// 构造函数
        /// </summary>
        public LibCollection()
        {
        }
        /// <summary>
        /// 添加项
        /// </summary>
        /// <param name="item">项</param>
        /// <returns>返回序号</returns>
        public virtual int Add(T item)
        {
            int iIndex = base.InnerList.Add(item);
            item.Index = iIndex;

            return iIndex;
        }
        /// <summary>
        /// 设置父对象
        /// </summary>
        /// <param name="owner">父对象</param>
        public void SetOwner(object owner)
        {
            this._Owner = owner;
        }
        /// <summary>
        /// 集合属性
        /// </summary>
        /// <param name="index">序号</param>
        /// <returns>项</returns>
        public T this[int index]
        {
            get
            {
                return (T)base.InnerList[index];
            }
            set
            {
                base.InnerList[index] = value;
            }
        }
        /// <summary>
        /// 依据项返回对应序号
        /// </summary>
        /// <param name="item">项</param>
        /// <returns>序号</returns>
        public int IndexOf(T item)
        {
            return List.IndexOf(item);
        }
        /// <summary>
        /// 插入项
        /// </summary>
        /// <param name="index"></param>
        /// <param name="item"></param>
        public void Insert(int index, T item)
        {            
            List.Insert(index, item);
            for (int i = 0; i < List.Count; i++)
            {
                (List[i] as LibCollectionItem).Index = i;
            }
        }
        /// <summary>
        /// 判断是否包含项
        /// </summary>
        /// <param name="item">项</param>
        /// <returns>包含则返回TRUE，反之为FALSE</returns>
        public bool Contains(T item)
        {
            return List.Contains(item);
        }
        /// <summary>
        /// 新建项
        /// </summary>
        /// <returns>返回项</returns>
        public T Add()
        {
            T result = (T)Activator.CreateInstance(typeof(T));
            int iIndex = this.Add(result);
            result.Index = iIndex;

            return result;
        }
        /// <summary>
        /// 依据项删除项
        /// </summary>
        /// <param name="item">项</param>
        public void Delete(T item)
        {
            LibCollectionItem cItem = (LibCollectionItem)item;
            int index = this.IndexOf(item);
            this.Delete(index);
        }
        /// <summary>
        /// 依据序号删除项
        /// </summary>
        /// <param name="index">序号</param>
        public void Delete(int index)
        {
            List.RemoveAt(index);
        }
    }