【.Net码农】List<T> 类

此文章由机器翻译。 将光标移到文章的句子上，以查看原文。  更多信息。

译文 原文

List<T> 类

.NET Framework 4.6 and 4.5

其他版本

表示可通过索引访问的对象的强类型列表。 提供用于对列表进行搜索、排序和操作的方法。

若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。

继承层次结构

System.Object 
   System.Collections.Generic.List<T>
     更多...

命名空间：   System.Collections.Generic
程序集：   mscorlib（在 mscorlib.dll 中）
  System.Collections（在 System.Collections.dll 中）

语法

C#

C++

F#

VB

[SerializableAttribute]
[DebuggerDisplayAttribute("Count = {Count}")]
public class List<T> : IList<T>, ICollection<T>, 
	IEnumerable<T>, IEnumerable, IList, ICollection, IReadOnlyList<T>, 
	IReadOnlyCollection<T>

类型参数

T

列表中元素的类型。

List<T> 类型公开以下成员。

构造函数

显示:  继承  保护

	名称	描述
	List<T>()	初始化 List<T> 类的新实例，该实例为空并且具有默认初始容量。
	List<T>(IEnumerable<T>)	初始化 List<T> 类的新实例，该实例包含从指定集合复制的元素并且具有足够的容量来容纳所复制的元素。
	List<T>(Int32)	初始化 List<T> 类的新实例，该实例为空并且具有指定的初始容量。

页首

属性

显示:  继承  保护

	名称	描述
	Capacity	获取或设置该内部数据结构在不调整大小的情况下能够容纳的元素总数。
	Count	获取 List<T> 中包含的元素数。
	Item	获取或设置指定索引处的元素。

页首

方法

显示:  继承  保护

	名称	描述
	Add	将对象添加到 List<T> 的结尾处。
	AddRange	将指定集合的元素添加到 List<T> 的末尾。
	AsReadOnly	返回当前集合的只读 IList<T> 包装器。
	BinarySearch(T)	使用默认的比较器在整个已排序的 List<T> 中搜索元素，并返回该元素从零开始的索引。
	BinarySearch(T, IComparer<T>)	使用指定的比较器在整个已排序的 List<T> 中搜索元素，并返回该元素从零开始的索引。
	BinarySearch(Int32, Int32, T, IComparer<T>)	使用指定的比较器在已排序 List<T> 的某个元素范围中搜索元素，并返回该元素从零开始的索引。
	Clear	从 List<T> 中移除所有元素。
	Contains	确定某元素是否在 List<T> 中。
	ConvertAll<TOutput>	将当前 List<T> 中的元素转换为另一种类型，并返回包含已转换元素的列表。
	CopyTo(T[])	从目标数组的开头开始，将整个 List<T> 复制到兼容的一维数组。
	CopyTo(T[], Int32)	从目标数组的指定索引处开始，将整个 List<T> 复制到兼容的一维数组。
	CopyTo(Int32, T[], Int32, Int32)	从目标数组的指定索引处开始，将元素的范围从 List<T> 复制到兼容的一维数组。
	Equals(Object)	确定指定的对象是否等于当前对象。 （继承自 Object。）
	Exists	确定 List<T> 是否包含与指定谓词定义的条件匹配的元素。
	Finalize	在垃圾回收将某一对象回收前允许该对象尝试释放资源并执行其他清理操作。 （继承自 Object。）
	Find	搜索与指定谓词所定义的条件相匹配的元素，并返回整个List<T> 中的第一个匹配元素。
	FindAll	检索与指定谓词定义的条件匹配的所有元素。
	FindIndex(Predicate<T>)	搜索与指定谓词所定义的条件相匹配的元素，并返回整个List<T> 中第一个匹配元素的从零开始的索引。
	FindIndex(Int32, Predicate<T>)	搜索与指定谓词所定义的条件相匹配的元素，并返回 List<T> 中从指定索引到最后一个元素的元素范围内第一个匹配项的从零开始的索引。
	FindIndex(Int32, Int32, Predicate<T>)	搜索与指定谓词所定义的条件相匹配的一个元素，并返回List<T> 中从指定的索引开始、包含指定元素个数的元素范围内第一个匹配项的从零开始的索引。
	FindLast	搜索与指定谓词所定义的条件相匹配的元素，并返回整个List<T> 中的最后一个匹配元素。
	FindLastIndex(Predicate<T>)	搜索与指定谓词所定义的条件相匹配的元素，并返回整个List<T> 中最后一个匹配元素的从零开始的索引。
	FindLastIndex(Int32, Predicate<T>)	搜索与由指定谓词定义的条件相匹配的元素，并返回 List<T> 中从第一个元素到指定索引的元素范围内最后一个匹配项的从零开始的索引。
	FindLastIndex(Int32, Int32, Predicate<T>)	搜索与指定谓词所定义的条件相匹配的元素，并返回 List<T> 中包含指定元素个数、到指定索引结束的元素范围内最后一个匹配项的从零开始的索引。
	ForEach	对 List<T> 的每个元素执行指定操作。
	GetEnumerator	返回循环访问 List<T> 的枚举数。
	GetHashCode	作为默认哈希函数。 （继承自 Object。）
	GetRange	在源 List<T> 中创建元素范围的浅表复制。
	GetType	获取当前实例的 Type。 （继承自 Object。）
	IndexOf(T)	搜索指定的对象，并返回整个 List<T> 中第一个匹配项的从零开始的索引。
	IndexOf(T, Int32)	搜索指定对象并返回 List<T> 中从指定索引到最后一个元素这部分元素中第一个匹配项的从零开始索引。
	IndexOf(T, Int32, Int32)	搜索指定对象并返回 List<T> 中从指定索引开始并包含指定元素数的这部分元素中第一个匹配项的从零开始索引。
	Insert	将元素插入 List<T> 的指定索引处。
	InsertRange	将集合中的元素插入 List<T> 的指定索引处。
	LastIndexOf(T)	搜索指定对象并返回整个 List<T> 中最后一个匹配项的从零开始索引。
	LastIndexOf(T, Int32)	搜索指定对象并返回 List<T> 中从第一个元素到指定索引这部分元素中最后一个匹配项的从零开始的索引。
	LastIndexOf(T, Int32, Int32)	搜索指定对象并返回 List<T> 中到指定索引为止包含指定元素数的这部分元素中最后一个匹配项的从零开始索引。
	MemberwiseClone	创建当前 Object 的浅表副本。 （继承自 Object。）
	Remove	从 List<T> 中移除特定对象的第一个匹配项。
	RemoveAll	移除与指定的谓词所定义的条件相匹配的所有元素。
	RemoveAt	移除 List<T> 的指定索引处的元素。
	RemoveRange	从 List<T> 中移除一系列元素。
	Reverse()	将整个 List<T> 中元素的顺序反转。
	Reverse(Int32, Int32)	将指定范围中元素的顺序反转。
	Sort()	使用默认比较器对整个 List<T> 中的元素进行排序。
	Sort(Comparison<T>)	使用指定的 System.Comparison<T>，对整个 List<T> 中的元素进行排序。
	Sort(IComparer<T>)	使用指定的比较器对整个 List<T> 中的元素进行排序。
	Sort(Int32, Int32, IComparer<T>)	使用指定的比较器对 List<T> 中某个范围内的元素进行排序。
	ToArray	将 List<T> 的元素复制到新数组中。
	ToString	返回表示当前对象的字符串。 （继承自 Object。）
	TrimExcess	将容量设置为 List<T> 中元素的实际数目（如果该数目小于某个阈值）。
	TrueForAll	确定 List<T> 中的每个元素是否都与指定谓词定义的条件匹配。

页首

扩展 方法

显示:  继承  保护

	名称	描述
	Aggregate<T>(Func<T, T, T>)	已重载。 对序列应用累加器函数。 （由 Enumerable定义。）
	Aggregate<T>(Func<T, T, T>)	已重载。 （由 Enumerable 定义。）
	Aggregate<T, TAccumulate>(TAccumulate, Func<TAccumulate, T, TAccumulate>)	已重载。 对序列应用累加器函数。 将指定的种子值用作累加器初始值。 （由 Enumerable 定义。）
	Aggregate<T, TAccumulate>(TAccumulate, Func<TAccumulate, T, TAccumulate>)	已重载。 （由 Enumerable 定义。）
	Aggregate<T, TAccumulate, TResult>(TAccumulate, Func<TAccumulate, T, TAccumulate>, Func<TAccumulate, TResult>)	已重载。 对序列应用累加器函数。 将指定的种子值用作累加器的初始值，并使用指定的函数选择结果值。 （由 Enumerable 定义。）
	Aggregate<T, TAccumulate, TResult>(TAccumulate, Func<TAccumulate, T, TAccumulate>, Func<TAccumulate, TResult>)	已重载。 （由 Enumerable 定义。）
	All<T>(Func<T, Boolean>)	已重载。 确定序列中的所有元素是否满足条件。（由 Enumerable 定义。）
	All<T>(Func<T, Boolean>)	已重载。 （由 Enumerable 定义。）
	Any<T>()	已重载。 确定序列是否包含任何元素。 （由Enumerable 定义。）
	Any<T>()	已重载。 （由 Enumerable 定义。）
	Any<T>(Func<T, Boolean>)	已重载。 确定序列中是否存在元素满足条件。 （由Enumerable 定义。）
	Any<T>(Func<T, Boolean>)	已重载。 （由 Enumerable 定义。）
	AsEnumerable<T>()	已重载。 返回类型为 IEnumerable<T> 的输入。（由 Enumerable 定义。）
	AsEnumerable<T>()	已重载。 （由 Enumerable 定义。）
	AsParallel()	已重载。 启用查询的并行化。 （由ParallelEnumerable 定义。）
	AsParallel()	已重载。 （由 ParallelEnumerable 定义。）
	AsParallel<T>()	已重载。 启用查询的并行化。 （由ParallelEnumerable 定义。）
	AsParallel<T>()	已重载。 （由 ParallelEnumerable 定义。）
	AsQueryable()	已重载。 将 IEnumerable 转换为 IQueryable。 （由Queryable 定义。）
	AsQueryable()	已重载。 （由 Queryable 定义。）
	AsQueryable<T>()	已重载。 将泛型 IEnumerable<T> 转换为泛型IQueryable<T>。 （由 Queryable 定义。）
	AsQueryable<T>()	已重载。 （由 Queryable 定义。）
	Average<T>(Func<T, Decimal>)	已重载。 计算 Decimal 值序列的平均值，该值可通过调用输入序列的每个元素的转换函数获取。 （由Enumerable 定义。）
	Average<T>(Func<T, Nullable<Decimal>>)	已重载。 计算可以为 null 的 Decimal 值序列的平均值，该值可通过调用输入序列的每个元素的转换函数获取。 （由 Enumerable 定义。）
	Average<T>(Func<T, Decimal>)	已重载。 （由 Enumerable 定义。）
	Average<T>(Func<T, Nullable<Decimal>>)	已重载。 （由 Enumerable 定义。）
	Average<T>(Func<T, Double>)	已重载。 计算 Double 值序列的平均值，该值可通过调用输入序列的每个元素的转换函数获取。 （由Enumerable 定义。）
	Average<T>(Func<T, Nullable<Double>>)	已重载。 计算可以为 null 的 Double 值序列的平均值，该值可通过调用输入序列的每个元素的转换函数获取。 （由 Enumerable 定义。）
	Average<T>(Func<T, Double>)	已重载。 （由 Enumerable 定义。）
	Average<T>(Func<T, Nullable<Double>>)	已重载。 （由 Enumerable 定义。）
	Average<T>(Func<T, Int32>)	已重载。 计算 Int32 值序列的平均值，该值可通过调用输入序列的每个元素的转换函数获取。 （由Enumerable 定义。）
	Average<T>(Func<T, Nullable<Int32>>)	已重载。 计算可以为 null 的 Int32 值序列的平均值，该值可通过调用输入序列的每个元素的转换函数获取。 （由 Enumerable 定义。）
	Average<T>(Func<T, Int64>)	已重载。 计算 Int64 值序列的平均值，该值可通过调用输入序列的每个元素的转换函数获取。 （由Enumerable 定义。）
	Average<T>(Func<T, Nullable<Int64>>)	已重载。 计算可以为 null 的 Int64 值序列的平均值，该值可通过调用输入序列的每个元素的转换函数获取。 （由 Enumerable 定义。）
	Average<T>(Func<T, Single>)	已重载。 计算 Single 值序列的平均值，该值可通过调用输入序列的每个元素的转换函数获取。 （由Enumerable 定义。）
	Average<T>(Func<T, Nullable<Single>>)	已重载。 计算可以为 null 的 Single 值序列的平均值，该值可通过调用输入序列的每个元素的转换函数获取。 （由 Enumerable 定义。）
	Average<T>(Func<T, Int32>)	已重载。 （由 Enumerable 定义。）
	Average<T>(Func<T, Int64>)	已重载。 （由 Enumerable 定义。）
	Average<T>(Func<T, Nullable<Int32>>)	已重载。 （由 Enumerable 定义。）
	Average<T>(Func<T, Nullable<Int64>>)	已重载。 （由 Enumerable 定义。）
	Average<T>(Func<T, Nullable<Single>>)	已重载。 （由 Enumerable 定义。）
	Average<T>(Func<T, Single>)	已重载。 （由 Enumerable 定义。）
	Cast<TResult>()	已重载。 将 IEnumerable 的元素强制转换为指定的类型。 （由 Enumerable 定义。）
	Cast<TResult>()	已重载。 （由 Enumerable 定义。）
	Concat<T>(IEnumerable<T>)	已重载。 连接两个序列。 （由 Enumerable 定义。）
	Concat<T>(IEnumerable<T>)	已重载。 （由 Enumerable 定义。）
	Contains<T>(T)	已重载。 通过使用默认的相等比较器确定序列是否包含指定的元素。 （由 Enumerable 定义。）
	Contains<T>(T)	已重载。 （由 Enumerable 定义。）
	Contains<T>(T, IEqualityComparer<T>)	已重载。 通过使用指定的 IEqualityComparer<T>确定序列是否包含指定的元素。 （由 Enumerable 定义。）
	Contains<T>(T, IEqualityComparer<T>)	已重载。 （由 Enumerable 定义。）
	Count<T>()	已重载。 返回序列中的元素数量。 （由 Enumerable定义。）
	Count<T>()	已重载。 （由 Enumerable 定义。）
	Count<T>(Func<T, Boolean>)	已重载。 返回一个数字，表示在指定的序列中满足条件的元素数量。 （由 Enumerable 定义。）
	Count<T>(Func<T, Boolean>)	已重载。 （由 Enumerable 定义。）
	DefaultIfEmpty<T>()	已重载。 返回指定序列的元素；如果序列为空，则返回单一实例集合中的类型参数的默认值。 （由Enumerable 定义。）
	DefaultIfEmpty<T>()	已重载。 （由 Enumerable 定义。）
	DefaultIfEmpty<T>(T)	已重载。 返回指定序列中的元素；如果序列为空，则返回单一实例集合中的指定值。 （由 Enumerable 定义。）
	DefaultIfEmpty<T>(T)	已重载。 （由 Enumerable 定义。）
	Distinct<T>()	已重载。 通过使用默认的相等比较器对值进行比较返回序列中的非重复元素。 （由 Enumerable 定义。）
	Distinct<T>()	已重载。 （由 Enumerable 定义。）
	Distinct<T>(IEqualityComparer<T>)	已重载。 通过使用指定的 IEqualityComparer<T>对值进行比较返回序列中的非重复元素。 （由Enumerable 定义。）
	Distinct<T>(IEqualityComparer<T>)	已重载。 （由 Enumerable 定义。）
	ElementAt<T>(Int32)	已重载。 返回序列中指定索引处的元素。 （由Enumerable 定义。）
	ElementAt<T>(Int32)	已重载。 （由 Enumerable 定义。）
	ElementAtOrDefault<T>(Int32)	已重载。 返回序列中指定索引处的元素；如果索引超出范围，则返回默认值。 （由 Enumerable 定义。）
	ElementAtOrDefault<T>(Int32)	已重载。 （由 Enumerable 定义。）
	Except<T>(IEnumerable<T>)	已重载。 通过使用默认的相等比较器对值进行比较生成两个序列的差集。 （由 Enumerable 定义。）
	Except<T>(IEnumerable<T>)	已重载。 （由 Enumerable 定义。）
	Except<T>(IEnumerable<T>, IEqualityComparer<T>)	已重载。 通过使用指定的 IEqualityComparer<T>对值进行比较产生两个序列的差集。 （由Enumerable 定义。）
	Except<T>(IEnumerable<T>, IEqualityComparer<T>)	已重载。 （由 Enumerable 定义。）
	First<T>()	已重载。 返回序列中的第一个元素。 （由Enumerable 定义。）
	First<T>()	已重载。 （由 Enumerable 定义。）
	First<T>(Func<T, Boolean>)	已重载。 返回序列中满足指定条件的第一个元素。（由 Enumerable 定义。）
	First<T>(Func<T, Boolean>)	已重载。 （由 Enumerable 定义。）
	FirstOrDefault<T>()	已重载。 返回序列中的第一个元素；如果序列中不包含任何元素，则返回默认值。 （由 Enumerable 定义。）
	FirstOrDefault<T>()	已重载。 （由 Enumerable 定义。）
	FirstOrDefault<T>(Func<T, Boolean>)	已重载。 返回序列中满足条件的第一个元素；如果未找到这样的元素，则返回默认值。 （由 Enumerable定义。）
	FirstOrDefault<T>(Func<T, Boolean>)	已重载。 （由 Enumerable 定义。）
	GroupBy<T, TKey>(Func<T, TKey>)	已重载。 根据指定的键选择器函数对序列中的元素进行分组。 （由 Enumerable 定义。）
	GroupBy<T, TKey>(Func<T, TKey>)	已重载。 （由 Enumerable 定义。）
	GroupBy<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>)	已重载。 根据指定的键选择器函数对序列中的元素进行分组，并使用指定的比较器对键进行比较。 （由Enumerable 定义。）
	GroupBy<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>)	已重载。 （由 Enumerable 定义。）
	GroupBy<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>)	已重载。 根据指定的键选择器函数对序列中的元素进行分组，并且通过使用指定的函数对每个组中的元素进行投影。 （由 Enumerable 定义。）
	GroupBy<T, TKey, TResult>(Func<T, TKey>, Func<TKey, IEnumerable<T>, TResult>)	已重载。 根据指定的键选择器函数对序列中的元素进行分组，并且从每个组及其键中创建结果值。 （由Enumerable 定义。）
	GroupBy<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>)	已重载。 （由 Enumerable 定义。）
	GroupBy<T, TKey, TResult>(Func<T, TKey>, Func<TKey, IEnumerable<T>, TResult>)	已重载。 （由 Enumerable 定义。）
	GroupBy<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>, IEqualityComparer<TKey>)	已重载。 根据键选择器函数对序列中的元素进行分组。 通过使用比较器对键进行比较，并且通过使用指定的函数对每个组的元素进行投影。 （由Enumerable 定义。）
	GroupBy<T, TKey, TResult>(Func<T, TKey>, Func<TKey, IEnumerable<T>, TResult>, IEqualityComparer<TKey>)	已重载。 根据指定的键选择器函数对序列中的元素进行分组，并且从每个组及其键中创建结果值。 通过使用指定的比较器对键进行比较。 （由 Enumerable 定义。）
	GroupBy<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>, IEqualityComparer<TKey>)	已重载。 （由 Enumerable 定义。）
	GroupBy<T, TKey, TResult>(Func<T, TKey>, Func<TKey, IEnumerable<T>, TResult>, IEqualityComparer<TKey>)	已重载。 （由 Enumerable 定义。）
	GroupBy<T, TKey, TElement, TResult>(Func<T, TKey>, Func<T, TElement>, Func<TKey, IEnumerable<TElement>, TResult>)	已重载。 根据指定的键选择器函数对序列中的元素进行分组，并且从每个组及其键中创建结果值。 通过使用指定的函数对每个组的元素进行投影。 （由Enumerable 定义。）
	GroupBy<T, TKey, TElement, TResult>(Func<T, TKey>, Func<T, TElement>, Func<TKey, IEnumerable<TElement>, TResult>)	已重载。 （由 Enumerable 定义。）
	GroupBy<T, TKey, TElement, TResult>(Func<T, TKey>, Func<T, TElement>, Func<TKey, IEnumerable<TElement>, TResult>, IEqualityComparer<TKey>)	已重载。 根据指定的键选择器函数对序列中的元素进行分组，并且从每个组及其键中创建结果值。 通过使用指定的比较器对键值进行比较，并且通过使用指定的函数对每个组的元素进行投影。 （由 Enumerable定义。）
	GroupBy<T, TKey, TElement, TResult>(Func<T, TKey>, Func<T, TElement>, Func<TKey, IEnumerable<TElement>, TResult>, IEqualityComparer<TKey>)	已重载。 （由 Enumerable 定义。）
	GroupJoin<T, TInner, TKey, TResult>(IEnumerable<TInner>, Func<T, TKey>, Func<TInner, TKey>, Func<T, IEnumerable<TInner>, TResult>)	已重载。 基于键相等对两个序列的元素进行关联并对结果进行分组。 使用默认的相等比较器对键进行比较。 （由 Enumerable 定义。）
	GroupJoin<T, TInner, TKey, TResult>(IEnumerable<TInner>, Func<T, TKey>, Func<TInner, TKey>, Func<T, IEnumerable<TInner>, TResult>)	已重载。 （由 Enumerable 定义。）
	GroupJoin<T, TInner, TKey, TResult>(IEnumerable<TInner>, Func<T, TKey>, Func<TInner, TKey>, Func<T, IEnumerable<TInner>, TResult>, IEqualityComparer<TKey>)	已重载。 基于键相等对两个序列的元素进行关联并对结果进行分组。 使用指定的 IEqualityComparer<T>对键进行比较。 （由 Enumerable 定义。）
	GroupJoin<T, TInner, TKey, TResult>(IEnumerable<TInner>, Func<T, TKey>, Func<TInner, TKey>, Func<T, IEnumerable<TInner>, TResult>, IEqualityComparer<TKey>)	已重载。 （由 Enumerable 定义。）
	Intersect<T>(IEnumerable<T>)	已重载。 通过使用默认的相等比较器对值进行比较生成两个序列的交集。 （由 Enumerable 定义。）
	Intersect<T>(IEnumerable<T>)	已重载。 （由 Enumerable 定义。）
	Intersect<T>(IEnumerable<T>, IEqualityComparer<T>)	已重载。 通过使用指定的 IEqualityComparer<T>对值进行比较以生成两个序列的交集。 （由Enumerable 定义。）
	Intersect<T>(IEnumerable<T>, IEqualityComparer<T>)	已重载。 （由 Enumerable 定义。）
	Join<T, TInner, TKey, TResult>(IEnumerable<TInner>, Func<T, TKey>, Func<TInner, TKey>, Func<T, TInner, TResult>)	已重载。 基于匹配键对两个序列的元素进行关联。使用默认的相等比较器对键进行比较。 （由Enumerable 定义。）
	Join<T, TInner, TKey, TResult>(IEnumerable<TInner>, Func<T, TKey>, Func<TInner, TKey>, Func<T, TInner, TResult>)	已重载。 （由 Enumerable 定义。）
	Join<T, TInner, TKey, TResult>(IEnumerable<TInner>, Func<T, TKey>, Func<TInner, TKey>, Func<T, TInner, TResult>, IEqualityComparer<TKey>)	已重载。 基于匹配键对两个序列的元素进行关联。使用指定的 IEqualityComparer<T> 对键进行比较。（由 Enumerable 定义。）
	Join<T, TInner, TKey, TResult>(IEnumerable<TInner>, Func<T, TKey>, Func<TInner, TKey>, Func<T, TInner, TResult>, IEqualityComparer<TKey>)	已重载。 （由 Enumerable 定义。）
	Last<T>()	已重载。 返回序列的最后一个元素。 （由Enumerable 定义。）
	Last<T>()	已重载。 （由 Enumerable 定义。）
	Last<T>(Func<T, Boolean>)	已重载。 返回序列中满足指定条件的最后一个元素。（由 Enumerable 定义。）
	Last<T>(Func<T, Boolean>)	已重载。 （由 Enumerable 定义。）
	LastOrDefault<T>()	已重载。 返回序列中的最后一个元素；如果序列中不包含任何元素，则返回默认值。 （由 Enumerable 定义。）
	LastOrDefault<T>()	已重载。 （由 Enumerable 定义。）
	LastOrDefault<T>(Func<T, Boolean>)	已重载。 返回序列中满足条件的最后一个元素；如果未找到这样的元素，则返回默认值。 （由Enumerable 定义。）
	LastOrDefault<T>(Func<T, Boolean>)	已重载。 （由 Enumerable 定义。）
	LongCount<T>()	已重载。 返回一个 Int64，表示序列中的元素的总数量。 （由 Enumerable 定义。）
	LongCount<T>()	已重载。 （由 Enumerable 定义。）
	LongCount<T>(Func<T, Boolean>)	已重载。 返回一个 Int64，表示序列中满足条件的元素的数量。 （由 Enumerable 定义。）
	LongCount<T>(Func<T, Boolean>)	已重载。 （由 Enumerable 定义。）
	Max<T>()	已重载。 返回泛型序列中的最大值。 （由Enumerable 定义。）
	Max<T>()	已重载。 （由 Enumerable 定义。）
	Max<T>(Func<T, Decimal>)	已重载。 调用序列的每个元素上的转换函数并返回最大 Decimal 值。 （由 Enumerable 定义。）
	Max<T>(Func<T, Nullable<Decimal>>)	已重载。 调用序列的每个元素上的转换函数并返回可空 Decimal 的最大值。 （由 Enumerable 定义。）
	Max<T>(Func<T, Decimal>)	已重载。 （由 Enumerable 定义。）
	Max<T>(Func<T, Nullable<Decimal>>)	已重载。 （由 Enumerable 定义。）
	Max<T>(Func<T, Double>)	已重载。 调用序列的每个元素上的转换函数并返回最大 Double 值。 （由 Enumerable 定义。）
	Max<T>(Func<T, Nullable<Double>>)	已重载。 调用序列的每个元素上的转换函数并返回可空 Double 的最大值。 （由 Enumerable 定义。）
	Max<T>(Func<T, Double>)	已重载。 （由 Enumerable 定义。）
	Max<T>(Func<T, Nullable<Double>>)	已重载。 （由 Enumerable 定义。）
	Max<T>(Func<T, Int32>)	已重载。 调用序列的每个元素上的转换函数并返回最大 Int32 值。 （由 Enumerable 定义。）
	Max<T>(Func<T, Nullable<Int32>>)	已重载。 调用序列的每个元素上的转换函数并返回可空 Int32 的最大值。 （由 Enumerable 定义。）
	Max<T>(Func<T, Int64>)	已重载。 调用序列的每个元素上的转换函数并返回最大 Int64 值。 （由 Enumerable 定义。）
	Max<T>(Func<T, Nullable<Int64>>)	已重载。 调用序列的每个元素上的转换函数并返回可空 Int64 的最大值。 （由 Enumerable 定义。）
	Max<T>(Func<T, Single>)	已重载。 调用序列的每个元素上的转换函数并返回最大 Single 值。 （由 Enumerable 定义。）
	Max<T>(Func<T, Nullable<Single>>)	已重载。 调用序列的每个元素上的转换函数并返回可空 Single 的最大值。 （由 Enumerable 定义。）
	Max<T>(Func<T, Int32>)	已重载。 （由 Enumerable 定义。）
	Max<T>(Func<T, Int64>)	已重载。 （由 Enumerable 定义。）
	Max<T>(Func<T, Nullable<Int32>>)	已重载。 （由 Enumerable 定义。）
	Max<T>(Func<T, Nullable<Int64>>)	已重载。 （由 Enumerable 定义。）
	Max<T>(Func<T, Nullable<Single>>)	已重载。 （由 Enumerable 定义。）
	Max<T>(Func<T, Single>)	已重载。 （由 Enumerable 定义。）
	Max<T, TResult>(Func<T, TResult>)	已重载。 调用泛型序列的每个元素上的转换函数并返回最大结果值。 （由 Enumerable 定义。）
	Max<T, TResult>(Func<T, TResult>)	已重载。 （由 Enumerable 定义。）
	Min<T>()	已重载。 返回泛型序列中的最小值。 （由Enumerable 定义。）
	Min<T>()	已重载。 （由 Enumerable 定义。）
	Min<T>(Func<T, Decimal>)	已重载。 调用序列的每个元素上的转换函数并返回最小 Decimal 值。 （由 Enumerable 定义。）
	Min<T>(Func<T, Nullable<Decimal>>)	已重载。 调用序列的每个元素上的转换函数并返回可空 Decimal 的最小值。 （由 Enumerable 定义。）
	Min<T>(Func<T, Decimal>)	已重载。 （由 Enumerable 定义。）
	Min<T>(Func<T, Nullable<Decimal>>)	已重载。 （由 Enumerable 定义。）
	Min<T>(Func<T, Double>)	已重载。 调用序列的每个元素上的转换函数并返回最小 Double 值。 （由 Enumerable 定义。）
	Min<T>(Func<T, Nullable<Double>>)	已重载。 调用序列的每个元素上的转换函数并返回可空 Double 的最小值。 （由 Enumerable 定义。）
	Min<T>(Func<T, Double>)	已重载。 （由 Enumerable 定义。）
	Min<T>(Func<T, Nullable<Double>>)	已重载。 （由 Enumerable 定义。）
	Min<T>(Func<T, Int32>)	已重载。 调用序列的每个元素上的转换函数并返回最小 Int32 值。 （由 Enumerable 定义。）
	Min<T>(Func<T, Nullable<Int32>>)	已重载。 调用序列的每个元素上的转换函数并返回可空 Int32 的最小值。 （由 Enumerable 定义。）
	Min<T>(Func<T, Int64>)	已重载。 调用序列的每个元素上的转换函数并返回最小 Int64 值。 （由 Enumerable 定义。）
	Min<T>(Func<T, Nullable<Int64>>)	已重载。 调用序列的每个元素上的转换函数并返回可空 Int64 的最小值。 （由 Enumerable 定义。）
	Min<T>(Func<T, Single>)	已重载。 调用序列的每个元素上的转换函数并返回最小 Single 值。 （由 Enumerable 定义。）
	Min<T>(Func<T, Nullable<Single>>)	已重载。 调用序列的每个元素上的转换函数并返回可空 Single 的最小值。 （由 Enumerable 定义。）
	Min<T>(Func<T, Int32>)	已重载。 （由 Enumerable 定义。）
	Min<T>(Func<T, Int64>)	已重载。 （由 Enumerable 定义。）
	Min<T>(Func<T, Nullable<Int32>>)	已重载。 （由 Enumerable 定义。）
	Min<T>(Func<T, Nullable<Int64>>)	已重载。 （由 Enumerable 定义。）
	Min<T>(Func<T, Nullable<Single>>)	已重载。 （由 Enumerable 定义。）
	Min<T>(Func<T, Single>)	已重载。 （由 Enumerable 定义。）
	Min<T, TResult>(Func<T, TResult>)	已重载。 调用泛型序列的每个元素上的转换函数并返回最小结果值。 （由 Enumerable 定义。）
	Min<T, TResult>(Func<T, TResult>)	已重载。 （由 Enumerable 定义。）
	OfType<TResult>()	已重载。 根据指定类型筛选 IEnumerable 的元素。（由 Enumerable 定义。）
	OfType<TResult>()	已重载。 （由 Enumerable 定义。）
	OrderBy<T, TKey>(Func<T, TKey>)	已重载。 根据键按升序对序列的元素排序。 （由Enumerable 定义。）
	OrderBy<T, TKey>(Func<T, TKey>)	已重载。 （由 Enumerable 定义。）
	OrderBy<T, TKey>(Func<T, TKey>, IComparer<TKey>)	已重载。 使用指定的比较器按升序对序列的元素排序。 （由 Enumerable 定义。）
	OrderBy<T, TKey>(Func<T, TKey>, IComparer<TKey>)	已重载。 （由 Enumerable 定义。）
	OrderByDescending<T, TKey>(Func<T, TKey>)	已重载。 根据键按降序对序列的元素排序。 （由Enumerable 定义。）
	OrderByDescending<T, TKey>(Func<T, TKey>)	已重载。 （由 Enumerable 定义。）
	OrderByDescending<T, TKey>(Func<T, TKey>, IComparer<TKey>)	已重载。 使用指定的比较器按降序对序列的元素排序。 （由 Enumerable 定义。）
	OrderByDescending<T, TKey>(Func<T, TKey>, IComparer<TKey>)	已重载。 （由 Enumerable 定义。）
	Reverse<T>()	已重载。 反转序列中元素的顺序。 （由 Enumerable定义。）
	Reverse<T>()	已重载。 （由 Enumerable 定义。）
	Select<T, TResult>(Func<T, TResult>)	已重载。 将序列中的每个元素投影到新表中。 （由Enumerable 定义。）
	Select<T, TResult>(Func<T, Int32, TResult>)	已重载。 通过合并元素的索引将序列的每个元素投影到新表中。 （由 Enumerable 定义。）
	Select<T, TResult>(Func<T, TResult>)	已重载。 （由 Enumerable 定义。）
	Select<T, TResult>(Func<T, Int32, TResult>)	已重载。 （由 Enumerable 定义。）
	SelectMany<T, TResult>(Func<T, IEnumerable<TResult>>)	已重载。 将序列的每个元素投影到 IEnumerable<T>并将结果序列合并为一个序列。 （由 Enumerable 定义。）
	SelectMany<T, TResult>(Func<T, Int32, IEnumerable<TResult>>)	已重载。 将序列的每个元素投影到IEnumerable<T>，并将结果序列合并为一个序列。每个源元素的索引用于该元素的投影表。 （由Enumerable 定义。）
	SelectMany<T, TResult>(Func<T, IEnumerable<TResult>>)	已重载。 （由 Enumerable 定义。）
	SelectMany<T, TResult>(Func<T, Int32, IEnumerable<TResult>>)	已重载。 （由 Enumerable 定义。）
	SelectMany<T, TCollection, TResult>(Func<T, Int32, IEnumerable<TCollection>>, Func<T, TCollection, TResult>)	已重载。 将序列的每个元素投影到IEnumerable<T>，并将结果序列合并为一个序列，并对其中每个元素调用结果选择器函数。 每个源元素的索引用于该元素的中间投影表。 （由 Enumerable定义。）
	SelectMany<T, TCollection, TResult>(Func<T, IEnumerable<TCollection>>, Func<T, TCollection, TResult>)	已重载。 将序列的每个元素投影到IEnumerable<T>，并将结果序列合并为一个序列，并对其中每个元素调用结果选择器函数。 （由Enumerable 定义。）
	SelectMany<T, TCollection, TResult>(Func<T, IEnumerable<TCollection>>, Func<T, TCollection, TResult>)	已重载。 （由 Enumerable 定义。）
	SelectMany<T, TCollection, TResult>(Func<T, Int32, IEnumerable<TCollection>>, Func<T, TCollection, TResult>)	已重载。 （由 Enumerable 定义。）
	SequenceEqual<T>(IEnumerable<T>)	已重载。 通过使用相应类型的默认相等比较器对序列的元素进行比较，以确定两个序列是否相等。 （由Enumerable 定义。）
	SequenceEqual<T>(IEnumerable<T>)	已重载。 （由 Enumerable 定义。）
	SequenceEqual<T>(IEnumerable<T>, IEqualityComparer<T>)	已重载。 使用指定的 IEqualityComparer<T> 对两个序列的元素进行比较，以确定序列是否相等。 （由Enumerable 定义。）
	SequenceEqual<T>(IEnumerable<T>, IEqualityComparer<T>)	已重载。 （由 Enumerable 定义。）
	Single<T>()	已重载。 返回序列的唯一元素；如果该序列并非恰好包含一个元素，则会引发异常。 （由 Enumerable 定义。）
	Single<T>()	已重载。 （由 Enumerable 定义。）
	Single<T>(Func<T, Boolean>)	已重载。 返回序列中满足指定条件的唯一元素；如果有多个这样的元素存在，则会引发异常。 （由Enumerable 定义。）
	Single<T>(Func<T, Boolean>)	已重载。 （由 Enumerable 定义。）
	SingleOrDefault<T>()	已重载。 返回序列中的唯一元素；如果该序列为空，则返回默认值；如果该序列包含多个元素，此方法将引发异常。 （由 Enumerable 定义。）
	SingleOrDefault<T>()	已重载。 （由 Enumerable 定义。）
	SingleOrDefault<T>(Func<T, Boolean>)	已重载。 返回序列中满足指定条件的唯一元素；如果这类元素不存在，则返回默认值；如果有多个元素满足该条件，此方法将引发异常。 （由 Enumerable 定义。）
	SingleOrDefault<T>(Func<T, Boolean>)	已重载。 （由 Enumerable 定义。）
	Skip<T>(Int32)	已重载。 跳过序列中指定数量的元素，然后返回剩余的元素。 （由 Enumerable 定义。）
	Skip<T>(Int32)	已重载。 （由 Enumerable 定义。）
	SkipWhile<T>(Func<T, Boolean>)	已重载。 只要满足指定的条件，就跳过序列中的元素，然后返回剩余元素。 （由 Enumerable 定义。）
	SkipWhile<T>(Func<T, Boolean>)	已重载。 （由 Enumerable 定义。）
	SkipWhile<T>(Func<T, Int32, Boolean>)	已重载。 只要满足指定的条件，就跳过序列中的元素，然后返回剩余元素。 将在谓词函数的逻辑中使用元素的索引。 （由 Enumerable 定义。）
	SkipWhile<T>(Func<T, Int32, Boolean>)	已重载。 （由 Enumerable 定义。）
	Sum<T>(Func<T, Decimal>)	已重载。 计算 Decimal 值序列的和，这些值是通过对输入序列中的每个元素调用转换函数得来的。 （由Enumerable 定义。）
	Sum<T>(Func<T, Nullable<Decimal>>)	已重载。 计算可以为 null 的 Decimal 值序列的和，这些值是通过对输入序列中的每个元素调用转换函数得来的。 （由 Enumerable 定义。）
	Sum<T>(Func<T, Decimal>)	已重载。 （由 Enumerable 定义。）
	Sum<T>(Func<T, Nullable<Decimal>>)	已重载。 （由 Enumerable 定义。）
	Sum<T>(Func<T, Double>)	已重载。 计算 Double 值序列的和，这些值是通过对输入序列中的每个元素调用转换函数得来的。 （由Enumerable 定义。）
	Sum<T>(Func<T, Nullable<Double>>)	已重载。 计算可以为 null 的 Double 值序列的和，这些值是通过对输入序列中的每个元素调用转换函数得来的。 （由 Enumerable 定义。）
	Sum<T>(Func<T, Double>)	已重载。 （由 Enumerable 定义。）
	Sum<T>(Func<T, Nullable<Double>>)	已重载。 （由 Enumerable 定义。）
	Sum<T>(Func<T, Int32>)	已重载。 计算 Int32 值序列的和，这些值是通过对输入序列中的每个元素调用转换函数得来的。 （由Enumerable 定义。）
	Sum<T>(Func<T, Nullable<Int32>>)	已重载。 计算可以为 null 的 Int32 值序列的和，这些值是通过对输入序列中的每个元素调用转换函数得来的。 （由 Enumerable 定义。）
	Sum<T>(Func<T, Int64>)	已重载。 计算 Int64 值序列的和，这些值是通过对输入序列中的每个元素调用转换函数得来的。 （由Enumerable 定义。）
	Sum<T>(Func<T, Nullable<Int64>>)	已重载。 计算可以为 null 的 Int64 值序列的和，这些值是通过对输入序列中的每个元素调用转换函数得来的。 （由 Enumerable 定义。）
	Sum<T>(Func<T, Single>)	已重载。 计算 Single 值序列的和，这些值是通过对输入序列中的每个元素调用转换函数得来的。 （由Enumerable 定义。）
	Sum<T>(Func<T, Nullable<Single>>)	已重载。 计算可以为 null 的 Single 值序列的和，这些值是通过对输入序列中的每个元素调用转换函数得来的。 （由 Enumerable 定义。）
	Sum<T>(Func<T, Int32>)	已重载。 （由 Enumerable 定义。）
	Sum<T>(Func<T, Int64>)	已重载。 （由 Enumerable 定义。）
	Sum<T>(Func<T, Nullable<Int32>>)	已重载。 （由 Enumerable 定义。）
	Sum<T>(Func<T, Nullable<Int64>>)	已重载。 （由 Enumerable 定义。）
	Sum<T>(Func<T, Nullable<Single>>)	已重载。 （由 Enumerable 定义。）
	Sum<T>(Func<T, Single>)	已重载。 （由 Enumerable 定义。）
	Take<T>(Int32)	已重载。 从序列的开头返回指定数量的连续元素。（由 Enumerable 定义。）
	Take<T>(Int32)	已重载。 （由 Enumerable 定义。）
	TakeWhile<T>(Func<T, Boolean>)	已重载。 只要满足指定的条件，就会返回序列的元素。 （由 Enumerable 定义。）
	TakeWhile<T>(Func<T, Boolean>)	已重载。 （由 Enumerable 定义。）
	TakeWhile<T>(Func<T, Int32, Boolean>)	已重载。 只要满足指定的条件，就会返回序列的元素。 将在谓词函数的逻辑中使用元素的索引。 （由Enumerable 定义。）
	TakeWhile<T>(Func<T, Int32, Boolean>)	已重载。 （由 Enumerable 定义。）
	ToArray<T>()	已重载。 从 IEnumerable<T> 创建一个数组。 （由Enumerable 定义。）
	ToArray<T>()	已重载。 （由 Enumerable 定义。）
	ToDictionary<T, TKey>(Func<T, TKey>)	已重载。 根据指定的键选择器函数，从IEnumerable<T> 创建一个 Dictionary<TKey, TValue>。 （由 Enumerable 定义。）
	ToDictionary<T, TKey>(Func<T, TKey>)	已重载。 （由 Enumerable 定义。）
	ToDictionary<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>)	已重载。 根据指定的键选择器函数和键比较器，从IEnumerable<T> 创建一个 Dictionary<TKey, TValue>。 （由 Enumerable 定义。）
	ToDictionary<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>)	已重载。 （由 Enumerable 定义。）
	ToDictionary<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>)	已重载。 根据指定的键选择器和元素选择器函数，从IEnumerable<T> 创建一个 Dictionary<TKey, TValue>。 （由 Enumerable 定义。）
	ToDictionary<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>)	已重载。 （由 Enumerable 定义。）
	ToDictionary<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>, IEqualityComparer<TKey>)	已重载。 根据指定的键选择器函数、比较器和元素选择器函数从 IEnumerable<T> 创建一个Dictionary<TKey, TValue>。 （由 Enumerable 定义。）
	ToDictionary<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>, IEqualityComparer<TKey>)	已重载。 （由 Enumerable 定义。）
	ToList<T>()	已重载。 从 IEnumerable<T> 创建一个 List<T>。（由 Enumerable 定义。）
	ToList<T>()	已重载。 （由 Enumerable 定义。）
	ToLookup<T, TKey>(Func<T, TKey>)	已重载。 根据指定的键选择器函数，从IEnumerable<T> 创建一个 Lookup<TKey, TElement>。 （由 Enumerable 定义。）
	ToLookup<T, TKey>(Func<T, TKey>)	已重载。 （由 Enumerable 定义。）
	ToLookup<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>)	已重载。 根据指定的键选择器函数和键比较器，从IEnumerable<T> 创建一个 Lookup<TKey, TElement>。 （由 Enumerable 定义。）
	ToLookup<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>)	已重载。 （由 Enumerable 定义。）
	ToLookup<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>)	已重载。 根据指定的键选择器和元素选择器函数，从IEnumerable<T> 创建一个 Lookup<TKey, TElement>。 （由 Enumerable 定义。）
	ToLookup<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>)	已重载。 （由 Enumerable 定义。）
	ToLookup<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>, IEqualityComparer<TKey>)	已重载。 根据指定的键选择器函数、比较器和元素选择器函数，从 IEnumerable<T> 创建一个Lookup<TKey, TElement>。 （由 Enumerable 定义。）
	ToLookup<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>, IEqualityComparer<TKey>)	已重载。 （由 Enumerable 定义。）
	Union<T>(IEnumerable<T>)	已重载。 通过使用默认的相等比较器生成两个序列的并集。 （由 Enumerable 定义。）
	Union<T>(IEnumerable<T>)	已重载。 （由 Enumerable 定义。）
	Union<T>(IEnumerable<T>, IEqualityComparer<T>)	已重载。 通过使用指定的 IEqualityComparer<T>生成两个序列的并集。 （由 Enumerable 定义。）
	Union<T>(IEnumerable<T>, IEqualityComparer<T>)	已重载。 （由 Enumerable 定义。）
	Where<T>(Func<T, Boolean>)	已重载。 基于谓词筛选值序列。 （由 Enumerable定义。）
	Where<T>(Func<T, Boolean>)	已重载。 （由 Enumerable 定义。）
	Where<T>(Func<T, Int32, Boolean>)	已重载。 基于谓词筛选值序列。 将在谓词函数的逻辑中使用每个元素的索引。 （由 Enumerable 定义。）
	Where<T>(Func<T, Int32, Boolean>)	已重载。 （由 Enumerable 定义。）
	Zip<T, TSecond, TResult>(IEnumerable<TSecond>, Func<T, TSecond, TResult>)	已重载。 将指定函数应用于两个序列的对应元素，以生成结果序列。 （由 Enumerable 定义。）
	Zip<T, TSecond, TResult>(IEnumerable<TSecond>, Func<T, TSecond, TResult>)	已重载。 （由 Enumerable 定义。）

页首

显式 接口 实现

显示:  继承  保护

	名称	描述
	ICollection.CopyTo	从特定的 ICollection 索引处开始，将 Array 的元素复制到一个 Array 中。
	ICollection<T>.IsReadOnly	获取一个值，该值指示 ICollection<T> 是否为只读。
	ICollection.IsSynchronized	获取一个值，该值指示是否同步对 ICollection 的访问（线程安全）。
	ICollection.SyncRoot	获取可用于同步对 ICollection 的访问的对象。
	IEnumerable<T>.GetEnumerator	返回循环访问集合的枚举数。
	IEnumerable.GetEnumerator	返回循环访问集合的枚举数。
	IList.Add	将某项添加到 IList 中。
	IList.Contains	确定 IList 是否包含特定值。
	IList.IndexOf	确定 IList 中特定项的索引。
	IList.Insert	在 IList 中的指定索引处插入一个项。
	IList.IsFixedSize	获取一个值，该值指示 IList 是否具有固定大小。
	IList.IsReadOnly	获取一个值，该值指示 IList 是否为只读。
	IList.Item	获取或设置指定索引处的元素。
	IList.Remove	从 IList 中移除特定对象的第一个匹配项。

页首

备注

说明
若要查看此类型的.NET Framework 源代码，请参阅 Reference Source。 您可以浏览联机的源代码、 下载供脱机查看参考资料和调试 ； 在单步执行 （包括修补程序和更新） 的源see instructions.

List<T> 类是等效的泛型 ArrayList 类。 它实现了 IList<T> 泛型接口的使用的数组作为动态增加其大小所需。

您可以将项目添加到 List<T> 使用 Add 或 AddRange 方法。

List<T> 类使用相等比较器和排序的比较器。

• 方法 （如 Contains, ，IndexOf, ，LastIndexOf, ，和 Remove 相等比较器用于列表元素。 类型的默认值相等比较器 T 按如下方式确定。 如果类型 T 实现 IEquatable<T> 泛型接口，则相等比较器都是 Equals(T) 方法，该接口 ； 否则，默认的相等比较是 Object.Equals(Object)。

• 方法 （如 BinarySearch 和 Sort 列表元素用于排序的比较器。 类型的默认比较器 T 按如下方式确定。 如果类型 T 实现 IComparable<T> 泛型接口，则默认比较器都是 CompareTo(T) 方法，该接口 ； 否则为如果类型 T实现非泛型 IComparable 接口，则默认比较器是 CompareTo(Object) 该接口的方法。 如果类型 T 实现两个接口，则没有默认的比较器，并且必须显式提供的比较器或比较委托。

List<T> 不保证进行排序。 您必须对进行排序 List<T> 在执行操作前 （如 BinarySearch) 需要 List<T> 进行排序。

可以使用一个整数索引访问此集合中的元素。 在此集合中的索引是从零开始的。

对于非常大的 List<T> 对象，您可通过在运行时环境中将 enabledgcAllowVeryLargeObjects 配置元素的 特性设置为 true，将最大容量增加到 20 亿元素。

List<T> 接受 null 为有效的值为引用类型，并允许重复的元素。

不可变的版本 List<T> 类，请参阅 ImmutableList。

性能注意事项

在决定是否使用 List<T> 或 ArrayList 类，这两种具有类似的功能，请记住， List<T> 类在大多数情况下更好地执行，并且是类型安全。 如果引用类型用于类型 T 的 List<T> 类，在两个类的行为是完全相同。 但是，如果值类型用于类型 T, ，您需要考虑实现和装箱问题。

如果值类型用于类型 T, ，编译器将生成的一种实现 List<T> 专门针对该值类型的类。 这意味着一个列表元素的List<T> 对象不具有进行装箱就可以使用该元素，并且在创建大约 500 个列表元素后保存未装箱列表元素的内存大于用来生成的类实现的内存。

请确保用于类型的值类型 T 实现 IEquatable<T> 泛型接口。 如果不是，方法 （如 Contains 必须调用Object.Equals(Object) 方法，框受影响的列表元素。 如果值类型实现 IComparable 接口，并且您拥有源代码，还实现 IComparable<T> 泛型接口，以防止 BinarySearch 和 Sort 中装箱列表元素的方法。 如果不拥有的源代码，将传递 IComparer<T> 对象传递给 BinarySearch 和 Sort 方法

它为您带来益处，若要使用的特定于类型的实现是 List<T> 类而不是使用 ArrayList 类或自己编写强类型化的包装集合。 原因是您的实现必须执行什么.NET Framework 为您做，而公共语言运行时可以共享 Microsoft 中间语言代码和元数据，您的实现不能。

F # 注意事项

列表 < T > 类很少用在 F # 代码。 相反， 列表 (F#), ，哪些是固定不变，单向链接列表是通常首选。 F # 列表提供了有序的、 不可变的一系列值，并且提供的支持 List 模块 在函数式风格开发中使用。 当使用 F # 中，列表 < T > 类通常由所引用 ResizeArray < ' T > 类型缩写，以避免命名冲突使用 F # 列表

示例

下面的示例演示如何添加、 删除和插入在一个简单的业务对象 List<T>。

C#

F#

VB

using System;
using System.Collections.Generic;
// Simple business object. A PartId is used to identify the type of part 
// but the part name can change. 
public class Part : IEquatable<Part>
    {
        public string PartName { get; set; }

        public int PartId { get; set; }

        public override string ToString()
        {
            return "ID: " + PartId + "   Name: " + PartName;
        }
        public override bool Equals(object obj)
        {
            if (obj == null) return false;
            Part objAsPart = obj as Part;
            if (objAsPart == null) return false;
            else return Equals(objAsPart);
        }
        public override int GetHashCode()
        {
            return PartId;
        }
        public bool Equals(Part other)
        {
            if (other == null) return false;
            return (this.PartId.Equals(other.PartId));
        }
    // Should also override == and != operators.

    }
public class Example
{
    public static void Main()
    {
        // Create a list of parts.
        List<Part> parts = new List<Part>();

        // Add parts to the list.
        parts.Add(new Part() {PartName="crank arm", PartId=1234});
        parts.Add(new Part() { PartName = "chain ring", PartId = 1334 });
        parts.Add(new Part() { PartName = "regular seat", PartId = 1434 });
         parts.Add(new Part() { PartName = "banana seat", PartId = 1444 });
        parts.Add(new Part() { PartName = "cassette", PartId = 1534 });
        parts.Add(new Part() { PartName = "shift lever", PartId = 1634 }); ;

        // Write out the parts in the list. This will call the overridden ToString method
        // in the Part class.
        Console.WriteLine();
        foreach (Part aPart in parts)
        {
            Console.WriteLine(aPart);
        }


        // Check the list for part #1734. This calls the IEquitable.Equals method
        // of the Part class, which checks the PartId for equality.
        Console.WriteLine("\nContains(\"1734\"): {0}",
        parts.Contains(new Part {PartId=1734, PartName="" }));

        // Insert a new item at position 2.
        Console.WriteLine("\nInsert(2, \"1834\")");
        parts.Insert(2, new Part() { PartName = "brake lever", PartId = 1834 });


        //Console.WriteLine();
        foreach (Part aPart in parts)
        {
            Console.WriteLine(aPart);
        }

        Console.WriteLine("\nParts[3]: {0}", parts[3]);

        Console.WriteLine("\nRemove(\"1534\")");

        // This will remove part 1534 even though the PartName is different,
        // because the Equals method only checks PartId for equality.
        parts.Remove(new Part(){PartId=1534, PartName="cogs"});

        Console.WriteLine();
        foreach (Part aPart in parts)
        {
            Console.WriteLine(aPart);
        }
        Console.WriteLine("\nRemoveAt(3)");
        // This will remove the part at index 3.
        parts.RemoveAt(3);

        Console.WriteLine();
        foreach (Part aPart in parts)
        {
            Console.WriteLine(aPart);
        }

            /*

             ID: 1234   Name: crank arm
             ID: 1334   Name: chain ring
             ID: 1434   Name: regular seat
             ID: 1444   Name: banana seat
             ID: 1534   Name: cassette
             ID: 1634   Name: shift lever

             Contains("1734"): False

             Insert(2, "1834")
             ID: 1234   Name: crank arm
             ID: 1334   Name: chain ring
             ID: 1834   Name: brake lever
             ID: 1434   Name: regular seat
             ID: 1444   Name: banana seat
             ID: 1534   Name: cassette
             ID: 1634   Name: shift lever

             Parts[3]: ID: 1434   Name: regular seat

             Remove("1534")

             ID: 1234   Name: crank arm
             ID: 1334   Name: chain ring
             ID: 1834   Name: brake lever
             ID: 1434   Name: regular seat
             ID: 1444   Name: banana seat
             ID: 1634   Name: shift lever

             RemoveAt(3)

             ID: 1234   Name: crank arm
             ID: 1334   Name: chain ring
             ID: 1834   Name: brake lever
             ID: 1444   Name: banana seat
             ID: 1634   Name: shift lever


         */

    }
}

下面的示例演示几个属性和方法的 List<T> 字符串类型的泛型类。 （有关的示例 List<T> 的复杂类型，请参阅Contains 方法。）

默认构造函数用于创建具有默认容量的字符串的列表。 Capacity 显示属性，然后 Add 方法用于将添加多个项。 会列出各项，与 Capacity 属性显示同样，与 Count 属性，以显示具有已增加容量，根据需要。

Contains 方法用于在列表中，项是否存在测试 Insert 方法用于插入一个新项在列表中，然后再次显示该列表的内容。

默认值 Item 属性 （C# 中为索引器） 用来检索项， Remove 方法用于删除更早版本，添加的重复项的第一个实例，然后再次显示内容。 Remove 方法始终可以删除它遇到的第一个实例。

TrimExcess 方法用于减少容量以匹配计数，与 Capacity 和 Count 属性将显示。 如果未使用的容量已经小于 10%的总容量，列表将不进行调整。

最后， Clear 方法用于从列表中，移除所有项和 Capacity 和 Count 属性将显示。

C#

C++

F#

VB

using System;
using System.Collections.Generic;

public class Example
{
    public static void Main()
    {
        List<string> dinosaurs = new List<string>();

        Console.WriteLine("\nCapacity: {0}", dinosaurs.Capacity);

        dinosaurs.Add("Tyrannosaurus");
        dinosaurs.Add("Amargasaurus");
        dinosaurs.Add("Mamenchisaurus");
        dinosaurs.Add("Deinonychus");
        dinosaurs.Add("Compsognathus");
        Console.WriteLine();
        foreach(string dinosaur in dinosaurs)
        {
            Console.WriteLine(dinosaur);
        }

        Console.WriteLine("\nCapacity: {0}", dinosaurs.Capacity);
        Console.WriteLine("Count: {0}", dinosaurs.Count);

        Console.WriteLine("\nContains(\"Deinonychus\"): {0}",
            dinosaurs.Contains("Deinonychus"));

        Console.WriteLine("\nInsert(2, \"Compsognathus\")");
        dinosaurs.Insert(2, "Compsognathus");

        Console.WriteLine();
        foreach(string dinosaur in dinosaurs)
        {
            Console.WriteLine(dinosaur);
        }

        // Shows accessing the list using the Item property.
        Console.WriteLine("\ndinosaurs[3]: {0}", dinosaurs[3]);

        Console.WriteLine("\nRemove(\"Compsognathus\")");
        dinosaurs.Remove("Compsognathus");

        Console.WriteLine();
        foreach(string dinosaur in dinosaurs)
        {
            Console.WriteLine(dinosaur);
        }

        dinosaurs.TrimExcess();
        Console.WriteLine("\nTrimExcess()");
        Console.WriteLine("Capacity: {0}", dinosaurs.Capacity);
        Console.WriteLine("Count: {0}", dinosaurs.Count);

        dinosaurs.Clear();
        Console.WriteLine("\nClear()");
        Console.WriteLine("Capacity: {0}", dinosaurs.Capacity);
        Console.WriteLine("Count: {0}", dinosaurs.Count);
    }
}

/* This code example produces the following output:

Capacity: 0

Tyrannosaurus
Amargasaurus
Mamenchisaurus
Deinonychus
Compsognathus

Capacity: 8
Count: 5

Contains("Deinonychus"): True

Insert(2, "Compsognathus")

Tyrannosaurus
Amargasaurus
Compsognathus
Mamenchisaurus
Deinonychus
Compsognathus

dinosaurs[3]: Mamenchisaurus

Remove("Compsognathus")

Tyrannosaurus
Amargasaurus
Mamenchisaurus
Deinonychus
Compsognathus

TrimExcess()
Capacity: 5
Count: 5

Clear()
Capacity: 5
Count: 0
 */

版本信息

.NET Framework

受以下版本支持：4.6、4.5、4、3.5、3.0、2.0

.NET Framework Client Profile

受以下版本支持：4、3.5 SP1

适用于 Windows Phone 应用的 .NET

受以下版本支持：Windows Phone 8.1、Windows Phone Silverlight 8

可移植类库

受以下版本支持：可移植类库

适用于 Windows 应用商店应用的 .NET

受以下版本支持：

平台

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008（不支持服务器核心角色）, Windows Server 2008 R2（支持带 SP1 或更高版本的服务器核心角色；不支持 Itanium）

.NET Framework 并非支持每个平台的所有版本。有关支持的版本的列表，请参阅  .NET Framework 系统要求。

线程安全

公共静态 （Shared 在 Visual Basic 中） 是线程安全的此类型的成员。 但不保证所有实例成员都是线程安全的。

则可以安全地执行多个读取的操作 List<T>, ，但如果在读取时修改该集合，可能会出现问题。 若要确保线程安全，一种读取过程中锁定集合，或写操作。 若要启用访问集合以进行读取和写入的多个线程，您必须实现自己的同步。 具有内置同步的集合，请参阅中的类 System.Collections.Concurrent 命名空间。 本质上是线程 – 安全的替代方法，请参阅 ImmutableList 类。

请参阅

参考

System.Collections.Generic 命名空间

IList

ImmutableList

其他资源

在集合中执行不区分区域性的字符串操作

迭代器（C# 和 Visual Basic）

继承层次结构

System.Object
   System.Collections.Generic.List<T>
     System.Data.Services.ExpandSegmentCollection
     System.Workflow.Activities.OperationParameterInfoCollection
     System.Workflow.Activities.WorkflowRoleCollection
     System.Workflow.ComponentModel.ActivityCollection
     System.Workflow.ComponentModel.Design.ActivityDesignerGlyphCollection
     System.Workflow.Runtime.Tracking.ActivityTrackingLocationCollection
     System.Workflow.Runtime.Tracking.ActivityTrackPointCollection
     System.Workflow.Runtime.Tracking.ExtractCollection
     System.Workflow.Runtime.Tracking.TrackingAnnotationCollection
     System.Workflow.Runtime.Tracking.TrackingConditionCollection
     System.Workflow.Runtime.Tracking.UserTrackingLocationCollection
     System.Workflow.Runtime.Tracking.UserTrackPointCollection
     System.Workflow.Runtime.Tracking.WorkflowTrackPointCollection