C#基礎知識整理基礎知識(17)ILiestインタフェース——汎用型
18073 ワード
ArrayListに値タイプを挿入すると箱詰め操作が開始され、値タイプを取り出すには次のように箱を取り外す必要があります.
パフォーマンスの消費をもたらします.梱包の詳細については次の記事を参照してください.これらの問題を解決するために、C#には汎用をサポートするIListインタフェースがありますが、詳細コードを見てみると、実は構造はIListと同じで、汎用を増やしただけです.
呼び出し:
コード:http://download.csdn.net/detail/yysyangyangyangshan/4787961
ArrayList myArrayList = new ArrayList();
myArrayList.Add(40);//
myArrayList.Add(80);//
Int32 a1 = (Int32)myArrayList[0];//
Int32 a2 = (Int32)myArrayList[1];//
パフォーマンスの消費をもたらします.梱包の詳細については次の記事を参照してください.これらの問題を解決するために、C#には汎用をサポートする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();
}
コード:http://download.csdn.net/detail/yysyangyangyangshan/4787961