C# 기본 지식 정리 기본 지식(17) ILiest 인터페이스 - 제네릭

ArrayList에 값 유형을 삽입하면 boxing 작업이 트리거되고 값 유형을 검색하려면

ArrayList myArrayList = new ArrayList();

myArrayList.Add(40);//装箱

myArrayList.Add(80);//装箱

Int32 a1 = (Int32)myArrayList[0];//拆箱

Int32 a2 = (Int32)myArrayList[1];//拆箱

와 같이 unboxing이 필요하므로 성능 소모가 발생합니다. 포장에 대한 자세한 설명은 다음 글을 참고하세요.
이러한 문제를 해결하기 위해 C#에는 제네릭을 지원하는 IList 인터페이스가 있습니다. 실제로 구조는 IList와 동일하지만 제네릭이 추가되어 있습니다.

/// <summary>
   /// 泛型集合类
   /// </summary>
   /// <typeparam name="T"></typeparam>
   public class List<T> : IList<T>, IList
   {
       /// <summary>
       /// 泛型迭代器
       /// </summary>
       /// <typeparam name="T"></typeparam>
       public struct Enumertor<T> : IEnumerator, IEnumerator<T>
       {
           //迭代索引
           private int index;

           //迭代器所属的集合对象引用
           private List<T> list;

           public Enumertor(List<T> container)
           {
               this.list = container;

               this.index = -1;
           }

           public void Dispose()
           {
           }

          /// <summary>
          /// 显示实现IEnumerator的Current属性
          /// </summary>
           object IEnumerator.Current
           {
               get
               {
                   return list[index];
               }
           }

           /// <summary>
           /// 实现IEnumerator<T>的Current属性
           /// </summary>
           public T Current
           {
               get
               {
                   return list[index];
               }
           }

           /// <summary>
           /// 迭代器指示到下一个数据位置
           /// </summary>
           /// <returns></returns>
           public bool MoveNext()
           {
               if (this.index < list.Count)
               {
                   ++this.index;
               }

               return this.index < list.Count;
           }

           public void Reset()
           {
               this.index = -1;
           }
       }

       /// <summary>
       /// 保存数据的数组，T类型则体现了泛型的作用。
       /// </summary>
       private T[] array;

       /// <summary>
       /// 当前集合的长度
       /// </summary>
       private int count;

       /// <summary>
       /// 默认构造函数
       /// </summary>
       public List()
           : this(1)
       {

       }

       public List(int capacity)
       {
           if (capacity < 0)
           {
               throw new Exception("集合初始长度不能小于0");
           }

           if (capacity == 0)
           {
               capacity = 1;
           }

           this.array = new T[capacity];
       }

       /// <summary>
       /// 集合长度
       /// </summary>
       public int Count
       {
           get
           {
               return this.count;
           }
       }

       /// <summary>
       /// 集合实际长度
       /// </summary>
       public int Capacity
       {
           get
           {
               return this.array.Length;
           }
       }

       /// <summary>
       /// 是否固定大小
       /// </summary>
       public bool IsFixedSize
       {
           get
           {
               return false;
           }
       }

       /// <summary>
       /// 是否只读
       /// </summary>
       public bool IsReadOnly
       {
           get
           {
               return false;
           }
       }

       /// <summary>
       /// 是否可同属性
       /// </summary>
       public bool IsSynchronized
       {
           get
           {
               return false;
           }
       }

       /// <summary>
       /// 同步对象
       /// </summary>
       public object SyncRoot
       {
           get
           {
               return null;
           }
       }

       /// <summary>
       /// 长度不够时，重新分配长度足够的数组
       /// </summary>
       /// <returns></returns>
       private T[] GetNewArray()
       {
           return new T[(this.array.Length + 1) * 2];
       }

       /// <summary>
       /// 实现IList<T>Add方法
       /// </summary>
       /// <param name="value"></param>
       public void Add(T value)
       {
           int newCount = this.count + 1;

           if (this.array.Length < newCount)
           {
               T[] newArray = GetNewArray();

               Array.Copy(this.array, newArray, this.count);

               this.array = newArray;
           }

           this.array[this.count] = value;

           this.count = newCount;
       }

       /// <summary>
       /// 向集合末尾添加对象
       /// </summary>
       /// <param name="value"></param>
       /// <returns></returns>
        int IList.Add(object value)
       {
           ((IList<T>)this).Add((T)value);

           return this.count - 1;
       }

       /// <summary>
       /// 实现IList<T>索引器
       /// </summary>
       /// <param name="index"></param>
       /// <returns></returns>
       public T this[int index]
       {
           get
           {
               if (index < 0 || index >= this.count)
               {
                   throw new ArgumentOutOfRangeException("index");
               }

               return this.array[index];
           }

           set
           {
               if (index < 0 || index >= this.count)
               {
                   throw new ArgumentOutOfRangeException("index");
               }

               this.array[index] = value;
           }
       }

       /// <summary>
       /// 显示实现IList接口的索引器
       /// </summary>
       /// <param name="index"></param>
       /// <returns></returns>
       object IList.this[int index]
       {
           get
           {
               return ((IList<T>)this)[index];
           }

           set
           {
               ((IList<T>)this)[index] = (T)value;
           }
       }

       /// <summary>
       /// 删除集合中的元素
       /// </summary>
       /// <param name="index"></param>
       /// <param name="count"></param>
       public void RemoveRange(int index, int count)
       {
           if (index < 0)
           {
               throw new ArgumentOutOfRangeException("index");
           }

           int removeIndex = index + count;

           if (count < 0 || removeIndex > this.count)
           {
               throw new ArgumentOutOfRangeException("index");
           }

           Array.Copy(this.array, index + 1, this.array, index + count - 1, this.count - removeIndex);

           this.count -= count;
       }

       /// <summary>
       /// 实现IList<T>接口的indexOf方法
       /// </summary>
       /// <param name="value"></param>
       /// <returns></returns>
       public int IndexOf(T value)
       {
           int index = 0;

           if (value == null)
           {
               while (index < this.count)
               {
                   if (this.array[index] == null)
                   {
                       return index;
                   }

                   ++index;
               }
           }
           else
           {
               while (index < this.count)
               {
                   if (value.Equals(this.array[index]))
                   {
                       return index;
                   }

                   ++index;
               }
           }
           return -1;
       }

       /// <summary>
       /// 显示实现IList接口的IndexOf方法
       /// </summary>
       /// <param name="value"></param>
       /// <returns></returns>
        int IList.IndexOf(object value)
       {
           return ((IList<T>)this).IndexOf((T)value);
       }

       /// <summary>
       /// 查找对应数组项
       /// </summary>
       /// <param name="o"></param>
       /// <param name="compar"></param>
       /// <returns></returns>
       public int IndexOf(object o, IComparer compar)
       {
           int index = 0;

           while (index < this.count)
           {
               if (compar.Compare(this.array[index], o) == 0)
               {
                   return index;
               }

               ++index;
           }

           return -1;
       }

       /// <summary>
       /// 实现IList<T>接口的Remove方法
       /// </summary>
       /// <param name="value"></param>
       /// <returns></returns>
       public bool Remove(T value)
       {
           int index = this.IndexOf(value);

           if (index >= 0)
           {
               this.RemoveRange(index, 1);

               return true;
           }

           return false;
       }

       /// <summary>
       /// 显示实现IList接口的Remove方法，此处显示实现
       /// </summary>
       /// <param name="value"></param>
       void IList.Remove(object value)
       {
           ((IList<T>)this).Remove((T)value);
       }

       /// <summary>
       /// 从集合指定位置删除对象的引用
       /// </summary>
       /// <param name="index"></param>
       public void RemoveAt(int index)
       {
           RemoveRange(index, 1);
       }

       /// <summary>
       /// 弹出集合的最后一个元素
       /// </summary>
       /// <returns></returns>
       public object PopBack()
       {
           object o = this.array[this.count - 1];

           RemoveAt(this.count - 1);

           return o;
       }

       /// <summary>
       /// 弹出集合第一个对象
       /// </summary>
       /// <returns></returns>
       public object PopFront()
       {
           object o = this.array[0];

           RemoveAt(0);

           return o;
       }

       /// <summary>
       /// 实现IList<T>接口的Insert方法
       /// </summary>
       /// <param name="index"></param>
       /// <param name="value"></param>
       public void Insert(int index, T value)
       {
           if (index >= this.count)
           {
               throw new ArgumentOutOfRangeException("index");
           }

           int newCount = this.count + 1;

           if (this.array.Length < newCount)
           {
               T[] newArray = GetNewArray();

               Array.Copy(this.array, newArray, index);

               newArray[index] = value;

               Array.Copy(this.array, index, newArray, index + 1, this.count - index);

               this.array = newArray;
           }
           else
           {
               Array.Copy(this.array, index, this.array, index + 1, this.count - index);

               this.array[index] = value;
           }

           this.count = newCount;
       }

       /// <summary>
       /// 显示实现IList接口的Insert方法
       /// </summary>
       /// <param name="index"></param>
       /// <param name="value"></param>
       void IList.Insert(int index, object value)
       {
           ((IList<T>)this).Insert(index, (T)value);
       }

       /// <summary>
       /// 实现IList<T>接口的Contains方法
       /// </summary>
       /// <param name="value"></param>
       /// <returns></returns>
       public bool Contains(T value)
       {
           return this.IndexOf(value) >= 0;
       }

       /// <summary>
       /// 显示实现IList<T>接口的Contains方法
       /// </summary>
       /// <param name="value"></param>
       /// <returns></returns>
       bool IList.Contains(object value)
       {
           return ((IList<T>)this).IndexOf((T)value) >= 0;
       }

       /// <summary>
       /// 将集合压缩为实际长度
       /// </summary>
       public void TrimToSize()
       {
           if (this.array.Length > this.count)
           {
               T[] newArray = null;

               if (this.count > 0)
               {
                   newArray = new T[this.count];

                   Array.Copy(this.array, newArray, this.count);
               }
               else
               {
                   newArray = new T[1];
               }

               this.array = newArray;
           }
       }

       /// <summary>
       /// 清空集合
       /// </summary>
       public void Clear()
       {
           this.count = 0;
       }

       /// <summary>
       /// 实现IEnumerable接口的GetEnumerator方法
       /// </summary>
       /// <returns></returns>
       public IEnumerator<T> GetEnumerator()
       {
           Enumertor<T> ator = new Enumertor<T>(this);

           return ator;
       }

       /// <summary>
       /// 显示实现IEnumerable接口的GetEnumerator方法
       /// </summary>
       /// <returns></returns>
       IEnumerator IEnumerable.GetEnumerator()
       {
           return ((IEnumerable<T>)this).GetEnumerator();
       }

       /// <summary>
       /// 实现ICollection<T>接口的CopyTo方法
       /// </summary>
       /// <param name="array"></param>
       /// <param name="index"></param>
       public void CopyTo(T[] array, int index)
       {
           Array.Copy(this.array, 0, array, index, this.count);
       }

       /// <summary>
       /// 显示实现实现ICollection<T>接口的CopyTo方法
       /// </summary>
       /// <param name="array"></param>
       /// <param name="index"></param>
       void ICollection.CopyTo(Array array, int index)
       {
           Array.Copy(this.array, 0, array, index, this.count);
       }
   }

전화:

static void Main(string[] args)
       {
           //由于已经指定了int，因此加入值类型不会有装箱拆箱操作。
           List<int> tList = new List<int>();

           tList.Add(25);

           tList.Add(30);

           foreach (int n in tList)
           {
               Console.WriteLine(n);
           }

           Console.ReadLine();
       }

위는 C#의 기본 지식 내용입니다. (17) ILiest 인터페이스 - Generics에 대한 자세한 내용은 주의하시기 바랍니다. PHP 중국어 넷(www.php.cn)!