C# CollectionBase源代码

最新推荐文章于 2023-12-06 14:46:24 发布
最新推荐文章于 2023-12-06 14:46:24 发布
阅读量689 收藏 1
点赞数 1
分类专栏： c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014596078/article/details/40594893
版权


namespace  System.Collections {
     using  System;
     using  System.Diagnostics.Contracts;
  
     // Useful base class for typed read/write collections where items derive from object
     [Serializable]
[System.Runtime.InteropServices.ComVisible( true )]
     public  abstract  class   CollectionBase : IList {
         ArrayList list;
 
         protected   CollectionBase() {
             list =  new   ArrayList();
         }
 
         protected   CollectionBase( int  capacity) {
             list =  new   ArrayList(capacity);
         }
  
 
         protected   ArrayList InnerList {
             get  {
                 if  (list ==  null )
                     list =  new   ArrayList();
                 return  list;
             }
         }
  
         protected   IList List {
             get  {  return  (IList) this ; }
         }
  
         [System.Runtime.InteropServices.ComVisible( false )]
         public  int   Capacity {
             get  {
                 return   InnerList.Capacity;
             }
             set  {
                 InnerList.Capacity = value;
             }
         }
 
  
         public  int  Count {
             get  {
                 return  list ==  null  ? 0 : list.Count;
             }
         }
 
         public   void   Clear() {
             OnClear();
             InnerList.Clear();
             OnClearComplete();
         }
  
         public   void   RemoveAt( int  index) {
             if  (index < 0 || index >= Count)
                 throw   new   ArgumentOutOfRangeException( "index" , Environment.GetResourceString( "ArgumentOutOfRange_Index" ));
             Contract.End ContractBlock();
             Object temp = InnerList[index];
             OnValidate(temp);
             OnRemove(index, temp);
             InnerList.RemoveAt(index);
             try  {
                 OnRemoveComplete(index, temp);
             }
             catch  {
                 InnerList.Insert(index, temp);
                 throw ;
             }
  
         }
  
         bool   IList.IsReadOnly {
             get  {  return   InnerList.IsReadOnly; }
         }
  
         bool   IList.IsFixedSize {
             get  {  return   InnerList.IsFixedSize; }
         }
 
         bool   ICollection.IsSynchronized {
             get  {  return   InnerList.IsSynchronized; }
         }
 
         Object ICollection.SyncRoot {
             get  {  return   InnerList.SyncRoot; }
         }
  
         void   ICollection.CopyTo(Array array,  int  index) {
             InnerList.CopyTo(array, index);
         }
 
         Object IList. this [ int  index] {
             get  {
                 if  (index < 0 || index >= Count)
                     throw  new  ArgumentOutOfRangeException( "index" , Environment.GetResourceString( "ArgumentOutOfRange_Index" ));
                 Contract.EndContractBlock();
                 return   InnerList[index];
             }
             set  {
                 if  (index < 0 || index >= Count)
                     throw   new   ArgumentOutOfRangeException( "index" , Environment.GetResourceString( "ArgumentOutOfRange_Index" ));
                 Contract.End ContractBlock();
                 OnValidate(value);
                 Object temp = InnerList[index];
                 OnSet(index, temp, value);
                 InnerList[index] = value;
                 try  {
                     OnSetComplete(index, temp, value);
                 }
                 catch  {
                     InnerList[index] = temp;
                     throw ;
                 }
             }
         }
  
         bool  IList.Contains(Object value) {
             return   InnerList.Contains(value);
         }
  
         int   IList.Add(Object value) {
              OnValidate(value);
              OnInsert(InnerList.Count, value);
             int   index = InnerList.Add(value);
             try  {
                 OnInsertComplete(index, value);
             }
             catch  {
                 InnerList.RemoveAt(index);
                 throw ;
             }
             return  index;
         }
  
 
         void   IList.Remove(Object value) {
              OnValidate(value);
             int   index = InnerList.IndexOf(value);
             if  (index < 0)  throw   new  ArgumentException(Environment.GetResourceString( "Arg_RemoveArgNotFound" ));
             OnRemove(index, value);
             InnerList.RemoveAt(index);
             try {
                 OnRemoveComplete(index, value);
             }
             catch  {
                 InnerList.Insert(index, value);
                 throw ;
             }
         }
  
         int  IList.IndexOf(Object value) {
             return  InnerList.IndexOf(value);
         }
 
         void  IList.Insert( int  index, Object value) {
             if  (index < 0 || index > Count)
                 throw  new  ArgumentOutOfRangeException( "index" , Environment.GetResourceString( "ArgumentOutOfRange_Index" ));
             Contract.EndContractBlock();
             OnValidate(value);
             OnInsert(index, value);
             InnerList.Insert(index, value);
             try  {
                 OnInsertComplete(index, value);
             }
             catch  {
                 InnerList.RemoveAt(index);
                 throw ;
             }
         }
  
         public  IEnumerator GetEnumerator() {
             return  InnerList.GetEnumerator();
         }
  
         protected  virtual  void  OnSet( int  index, Object oldValue, Object newValue) {
         }
  
         protected  virtual  void  OnInsert( int  index, Object value) {
         }
 
         protected  virtual  void   OnClear() {
         }
  
         protected  virtual  void  OnRemove( int  index, Object value) {
         }
  
         protected  virtual  void  OnValidate(Object value) {
             if  (value ==  null )  throw  new  ArgumentNullException( "value" );
             Contract.EndContractBlock();
         }
 
         protected  virtual  void  OnSetComplete( int  index, Object oldValue, Object newValue) {
         }
  
         protected  virtual  void  OnInsertComplete( int  index, Object value) {
         }
  
         protected  virtual  void  OnClearComplete() {
         }
 
         protected  virtual  void  OnRemoveComplete( int  index, Object value) {
         }
  
     }
 
}
namespace  System.Collections {
     using  System;
     using  System.Diagnostics.Contracts;
  
     // Useful base class for typed read/write collections where items derive from object
     [Serializable]
[System.Runtime.InteropServices.ComVisible( true )]
     public  abstract  class  CollectionBase : IList {
         ArrayList list;
 
         protected  CollectionBase() {
             list =  new  ArrayList();
         }
 
         protected  CollectionBase( int  capacity) {
             list =  new  ArrayList(capacity);
         }
  
 
         protected  ArrayList InnerList {
             get  {
                 if  (list ==  null )
                     list =  new  ArrayList();
                 return  list;
             }
         }
  
         protected  IList List {
             get  {  return  (IList) this ; }
         }
  
         [System.Runtime.InteropServices.ComVisible( false )]
         public  int  Capacity {
             get  {
                 return  InnerList.Capacity;
             }
             set  {
                 InnerList.Capacity = value;
             }
         }
 
  
         public  int  Count {
             get  {
                 return  list ==  null  ? 0 : list.Count;
             }
         }
 
         public  void  Clear() {
             OnClear();
             InnerList.Clear();
             OnClearComplete();
         }
  
         public  void  RemoveAt( int  index) {
             if  (index < 0 || index >= Count)
                 throw  new  ArgumentOutOfRangeException( "index" , Environment.GetResourceString( "ArgumentOutOfRange_Index" ));
             Contract.EndContractBlock();
             Object temp = InnerList[index];
             OnValidate(temp);
             OnRemove(index, temp);
             InnerList.RemoveAt(index);
             try  {
                 OnRemoveComplete(index, temp);
             }
             catch  {
                 InnerList.Insert(index, temp);
                 throw ;
             }
  
         }
  
         bool  IList.IsReadOnly {
             get  {  return  InnerList.IsReadOnly; }
         }
  
         bool  IList.IsFixedSize {
             get  {  return  InnerList.IsFixedSize; }
         }
 
         bool  ICollection.IsSynchronized {
             get  {  return  InnerList.IsSynchronized; }
         }
 
         Object ICollection.SyncRoot {
             get  {  return  InnerList.SyncRoot; }
         }
  
         void  ICollection.CopyTo(Array array,  int  index) {
             InnerList.CopyTo(array, index);
         }
 
         Object IList. this [ int  index] {
             get  {
                 if  (index < 0 || index >= Count)
                     throw  new  ArgumentOutOfRangeException( "index" , Environment.GetResourceString( "ArgumentOutOfRange_Index" ));
                 Contract.EndContractBlock();
                 return  InnerList[index];
             }
             set  {
                 if  (index < 0 || index >= Count)
                     throw  new  ArgumentOutOfRangeException( "index" , Environment.GetResourceString( "ArgumentOutOfRange_Index" ));
                 Contract.EndContractBlock();
                 OnValidate(value);
                 Object temp = InnerList[index];
                 OnSet(index, temp, value);
                 InnerList[index] = value;
                 try  {
                     OnSetComplete(index, temp, value);
                 }
                 catch  {
                     InnerList[index] = temp;
                     throw ;
                 }
             }
         }
  
         bool  IList.Contains(Object value) {
             return  InnerList.Contains(value);
         }
  
         int  IList.Add(Object value) {
             OnValidate(value);
             OnInsert(InnerList.Count, value);
             int  index = InnerList.Add(value);
             try  {
                 OnInsertComplete(index, value);
             }
             catch  {
                 InnerList.RemoveAt(index);
                 throw ;
             }
             return  index;
         }
  
 
         void  IList.Remove(Object value) {
             OnValidate(value);
             int  index = InnerList.IndexOf(value);
             if  (index < 0)  throw  new ArgumentException(Environment.GetResourceString( "Arg_RemoveArgNotFound" ));
             OnRemove(index, value);
             InnerList.RemoveAt(index);
             try {
                 OnRemoveComplete(index, value);
             }
             catch  {
                 InnerList.Insert(index, value);
                 throw ;
             }
         }
  
         int  IList.IndexOf(Object value) {
             return  InnerList.IndexOf(value);
         }
 
         void  IList.Insert( int  index, Object value) {
             if  (index < 0 || index > Count)
                 throw  new  ArgumentOutOfRangeException( "index" , Environment.GetResourceString( "ArgumentOutOfRange_Index" ));
             Contract.EndContractBlock();
             OnValidate(value);
             OnInsert(index, value);
             InnerList.Insert(index, value);
             try  {
                 OnInsertComplete(index, value);
             }
             catch  {
                 InnerList.RemoveAt(index);
                 throw ;
             }
         }
  
         public  IEnumerator GetEnumerator() {
             return  InnerList.GetEnumerator();
         }
  
         protected  virtual  void  OnSet( int  index, Object oldValue, Object newValue) {
         }
  
         protected  virtual  void  OnInsert( int  index, Object value) {
         }
 
         protected  virtual  void  OnClear() {
         }
  
         protected  virtual  void  OnRemove( int  index, Object value) {
         }
  
         protected  virtual  void  OnValidate(Object value) {
             if  (value ==  null )  throw  new  ArgumentNullException( "value" );
             Contract.EndContractBlock();
         }
 
         protected  virtual  void  OnSetComplete( int  index, Object oldValue, Object newValue) {
         }
  
         protected  virtual  void  OnInsertComplete( int  index, Object value) {
         }
  
         protected  virtual  void  OnClearComplete() {
         }
 
         protected  virtual  void  OnRemoveComplete( int  index, Object value) {
         }
  
     }
 
}
baldwinsun
关注
专栏目录
2022年最新C#入门教程详解
程序员ken的博客
03-06 3万+
C# 简介 C# 是一个面向对象的编程语言，它是由微软（Microsoft）开发的，由 Ecma 和 ISO 核准认可的。C# 是专为公共语言基础结构（CLI）设计的。CLI 由可执行代码和运行时环境组成，允许在不同的计算机平台和体系结构上使用各种高级语言。 C#的特点： 面向对象。 面向组件。 它产生高效率的程序。 它可以在多种计算机平台上编译。 .Net 框架的一部分。 C# 强大的编程功能 虽然 C# 的构想十分接近于传统高级语言 C 和 C++，是一门面向对象的编程语言，但是它与 Java 非
C#中解析Rss实现思路及通用类--源代码
02-27 2114
 Rss是 Web 2.0 时代的主要特征，那么有没有一种通用的方法来解析Rss呢？当然有了，呵呵。下面给出了一种思路，仅供参考！主要用到了几个类文件：Channel.cs 、ChannelCollection.cs 、 Feed.cs 、 Item.cs  、 ItemCollection.cs下面给出各个类的源文件：1、Channel.cs 类 using Sy
关于CollectionBase
weixin_34289454的博客
12-04 146
今天看了一下C#中接口的东西，发现对CollectionBase(为强类型集合提供抽象基类)中的具体实现原理不是很了解。经过查看一些资料，分析过后得到以下的初步认识。 system.Collections.CollectionBase类主要显示的实现ICollection和IList接口和IEnumerable接口。但只提供了一些要求的执行代码，特别是IList的Clear()和RemoveAt...
C# CollectionBase的应用
xiaolei1982致力于Web开发
03-31 2157
using System.Collections;using System;namespace abcd...{    public class DocumentCollection : CollectionBase    ...{        public DocumentCollection() ...{ }        public DocumentCollection(Docume
C# CollectionBase,ICloneeable
05-02 714
就目前我对CollectionBase的理解>public class Cards : CollectionBase继承此类可以对List进行相关操作 public void Add(Card newCard) { List.Add(newCard); //foreach (card card in list) //{
C#中的CollectionBase用法
weixin_30322405的博客
03-19 651
ColectionBase中有List方法，返回的是类本身 class A :CollectionBase { public void add(B b) { List.Add(b); } public void remove(B b) { List.Remove(...
java集合框架02——Collection架构与源码分析
weixin_34124577的博客
05-26 168
Collection是一个接口，它主要的两个分支是List和Set。如下图所示： List和Set都是接口，它们继承与Collection。List是有序的队列，可以用重复的元素；而Set是数学概念中的集合，不能有重复的元素。List和Set都有它们各自的实现类。 为了方便，我们抽象出AbstractCollection类来让其他类继承...
C#代码设计准则
liyan_1992的博客
11-10 332
##代码设计规范## ################################################################################### ##命名准则## #标识符 标识符中每个单词的首字母大写,不要使用下划线来区分词,或在标识符中的任何位置使用下划线 1.PascalCasing: 对于包含多个单词的所有公共成员、类型和命名空间名称,请使用PascalCasing 2.camelCasing: 使...
C#类库详解：NET框架关键类与功能概览
- 该命名空间集中了多种集合类，如`ArrayList`、`BitArray`用于存储布尔值，`CollectionBase`是所有集合类的基类，`DictionaryBase`提供键值对存储，`Hashtable`、`Queue`、`SortedList`和`Stack`是常见的数据结构...
《果壳中的C# C# 5.0 权威指南》 (01-08章) - 学习笔记
GATTACA2011
02-05 1343
《果壳中的C# C# 5.0 权威指南》 ========== ========== ========== [作者] (美) Joseph Albahari (美) Ben Albahari [译者] (中) 陈昇 管学理 曾少宁 杨庆川 [出版] 中国水利水电出版社 [版次] 2013年08月 第1版 [印次] 2013年08月 第1次 印刷 [定价] 118.00元 ========== =...
C#学习：Collection类的初体验
autumn20080101的专栏
10-15 334
C#学习：Collection类的初体验  (2012-08-28 16:42:07) 转载▼ 标签：  collectionbase   innerlist   数据结构与算法   it 分类： C# 在C#语言中定义一个Collection类最简单的方法就是把System.Collection库中的Co
小议CollectionBase类 C#集合类
qiwenchao的专栏
03-12 4940
今天看书时，对基于CollectionBase类的自定义集合有点迷惑，查了下MSDN，自己做了一些小测试，得出一些心得。 1.IEnumerator,功能：支持对非泛型集合的简单迭代，这个接口有两个方法（MoveNext,Reset），一个属性(Current)。为foreach语句提供了迭代的基础,参阅《C#入门经典》，foreach首先调用IEnumerator接口的MoveNext，判断索
C#中的collection类
autumn20080101的专栏
10-15 991
C#中的collection类 一：定义Collection类 在C#语言中定义一个Collection类最简单的方法就是把System.Collection库中的CollectionBase类作为基础类。 二：实现Collection类 Collection类中包括了很多方法和属性，这里介绍一下Add方法、Remove方法、Count方法和Clear方法。 代码如下
C#中的常用集合类型分析
小宇飞刀的BLOG
04-19 1390
一、C#集合类型概述 集合是.NET FCL(Framework Class Library)中很重要的一部分。所有的集合类都继承自IEnumerable。集合类总体可分为一下几类： 关联/非关联型集合 顺序/随机访问集合 顺序/无序集合 泛型/非泛型集合 线程安全集合 各集合类底层接口关系图 泛型与非泛型集合类的分析 泛型集合是类型安全的，基于固定的泛型T,运行时不需要像非泛...
C#泛型（详解）
最新发布
猪猪的博客
12-06 1675
介绍C# 入门经典第8版书中的第12章《泛型》
继承CollectionBase来扩展自定义的集合类型
weixin_30335353的博客
03-21 112
Introduction 很多时候我们在开发的过程中都要用到自定义集合类型.,CollectionBases此基类旨在使实施者创建强类型自定义集合变得更容易。实施者应扩展此基类，而不应创建自己的基类。所以我们在自定义集合类型的时候,不应该再创建自己的基类而应该扩展此基类.Content下面代码就是通过继承CollectionBase来扩展自定义的Collection.using...
C# 集合(Collection)
风中追风3zZ
06-13 2117
        集合(Collection)类是专门用于数据存储和检索的类.这些类提供了对栈(stack),队列(queue),列表(list)和哈希表(hash table)的支持。大多数集合类实现了相同的接口。        集合(Collection)类服务于不同的目的,如为元素动态分配内存,基于索引访问列表项等等.这些类创建 Object 类的对象的集合.在C#中,Object 类是所有数...
C#编程实践：遗传算法详解与实现
在给定的代码片段中，`Population` 类扮演了种群的角色，它继承自 `CollectionBase`，实现了 `ICloneable` 和 `IDisposable` 接口，以支持种群的复制和资源管理。`Population` 类包含一个 `IGeneticStrategy` 对象，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值