c#部分总结

最新推荐文章于 2021-11-20 14:58:12 发布

原创最新推荐文章于 2021-11-20 14:58:12 发布 · 510 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#c#

判断

if...else

if(boolean_expression)

{

/* 如果布尔表达式为真将执行的语句 */

}

else

{

/* 如果布尔表达式为假将执行的语句 */

}

switch 语句

switch(expression)

{

case constant-expression :

statement(s);

break;

case constant-expression :

statement(s) ;

break;

/* 可以有任意数量的 case 语句 */

default : /* 可选的 */

statement(s);

break;

}

switch 语句必须遵循下面的规则：

switch 语句中的 expression 必须是一个整型或枚举类型，或者是一个 class 类型，其中 class 有一个单一的转换函数将其转换为整型或枚举类型。

C# 不允许从一个开关部分继续执行到下一个开关部分。如果 case 语句中有处理语句，则必须包含 break 或其他跳转语句。

如果要使 C# 支持从一个 case 标签显式贯穿到另一个 case 标签，可以使用 goto 一个 switch-case 或 goto default。

？：运算符

? 表达式的值是由 Exp1 决定的。如果 Exp1 为真，则计算 Exp2 的值，结果即为整个 ? 表达式的值。如果 Exp1 为假，则计算 Exp3 的值，结果即为整个 ? 表达式的值。

输入输出

Console.WriteLine()

Console.ReadLine()

Console.ReadKey()

类型转换

1 ToBoolean

如果可能的话，把类型转换为布尔型。

2 ToByte

把类型转换为字节类型。

3 ToChar

如果可能的话，把类型转换为单个 Unicode 字符类型。

4 ToDateTime

把类型（整数或字符串类型）转换为日期-时间结构。

5 ToDecimal

把浮点型或整数类型转换为十进制类型。

6 ToDouble

把类型转换为双精度浮点型。

7 ToInt16

把类型转换为 16 位整数类型。

8 ToInt32

把类型转换为 32 位整数类型。

9 ToInt64

把类型转换为 64 位整数类型。

10 ToSbyte

把类型转换为有符号字节类型。

11 ToSingle

把类型转换为小浮点数类型。

12 ToString

把类型转换为字符串类型。

13 ToType

把类型转换为指定类型。

14 ToUInt16

把类型转换为 16 位无符号整数类型。

15 ToUInt32

把类型转换为 32 位无符号整数类型。

16 ToUInt64

把类型转换为 64 位无符号整数类型。

常量

整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数：0x 或 0X 表示十六进制，0 表示八进制，没有前缀则表示十进制。整数常量也可以有后缀，可以是 U 和 L 的组合，其中，U 和 L 分别表示 unsigned 和 long。后缀可以是大写或者小写，多个后缀以任意顺序进行组合。

循环

while()

do ...while()

{

statement(s);

}while( condition );

for

for ( init; condition; increment )

{

statement(s);

}

该语句可以留空，只要在条件后有一个分号出现即可。

foreach

foreach (int j in n )

封装

Internal 访问修饰符

Internal 访问说明符允许一个类将其成员变量和成员函数暴露给当前程序中的其他函数和对象。换句话说，带有 internal 访问修饰符的任何成员可以被定义在该成员所定义的应用程序内的任何类或方法访问。

using System;

namespace RectangleApplication

{

class Rectangle

{

//成员变量

internal double length;

internal double width;

double GetArea()

{

return length * width;

}

public void Display()

{

Console.WriteLine("长度： {0}", length);

Console.WriteLine("宽度： {0}", width);

Console.WriteLine("面积： {0}", GetArea());

}

}//end class Rectangle

class ExecuteRectangle

{

static void Main(string[] args)

{

Rectangle r = new Rectangle();

r.length = 4.5;

r.width = 3.5;

r.Display();

Console.ReadLine();

}

定义方法&调用方法

using System;


namespace CalculatorApplication
{
   class NumberManipulator
   {
      public int FindMax(int num1, int num2)
      {
         /* 局部变量声明 */
         int result;


         if (num1 > num2)
            result = num1;
         else
            result = num2;


         return result;
      }
      static void Main(string[] args)
      {
         /* 局部变量定义 */
         int a = 100;
         int b = 200;
         int ret;
         NumberManipulator n = new NumberManipulator();


         //调用 FindMax 方法
         ret = n.FindMax(a, b);
         Console.WriteLine("最大值是： {0}", ret );
         Console.ReadLine();
      }
   }
}

参数

按值传递参数，实参和形参使用的是两个不同内存中的值。所以，当形参的值发生改变时，不会影响实参的值

按引用传递参数，引用参数表示与提供给方法的实际参数具有相同的内存位置。

按输出传递参数，可以使用输出参数来从函数中返回两个值。输出参数会把方法输出的数据赋给自己。提供给输出参数的变量不需要赋值。当需要从一个参数没有指定初始值的方法中返回值时，输出参数特别有用。

using System;

namespace CalculatorApplication

{

class NumberManipulator

{

public void getValues(out int x, out int y )

{

Console.WriteLine("请输入第一个值： ");

x = Convert.ToInt32(Console.ReadLine());

Console.WriteLine("请输入第二个值： ");

y = Convert.ToInt32(Console.ReadLine());

}

static void Main(string[] args)

{

NumberManipulator n = new NumberManipulator();

/* 局部变量定义 */

int a , b;

/* 调用函数来获取值 */

n.getValues(out a, out b);

Console.WriteLine("在方法调用之后，a 的值： {0}", a);

Console.WriteLine("在方法调用之后，b 的值： {0}", b);

Console.ReadLine();

}

声明一个 nullable 类型（可空类型）

< data_type> ? <variable_name> = null;

Null 合并运算符（ ?? ）

Null 合并运算符把操作数类型隐式转换为另一个可空（或不可空）的值类型的操作数的类型。

如果第一个操作数的值为 null，则运算符返回第二个操作数的值，否则返回第一个操作数的值。

using System;

namespace CalculatorApplication

{

class NullablesAtShow

{

static void Main(string[] args)

{

double? num1 = null;

double? num2 = 3.14157;

double num3;

num3 = num1 ?? 5.34;

Console.WriteLine("num3 的值： {0}", num3);

num3 = num2 ?? 5.34;

Console.WriteLine("num3 的值： {0}", num3);

Console.ReadLine();

}

num3 的值： 5.34

num3 的值： 3.14157

声明数组

double[] balance;

初始化数组

声明一个数组不会在内存中初始化数组。

double[] balance = new double[10];

赋值给数组

double[] balance = new double[10];

balance[0] = 4500.0;

double[] balance = { 2340.0, 4523.69, 3421.0};

int [] marks = new int[5] { 99, 98, 92, 97, 95};

int [] marks = new int[] { 99, 98, 92, 97, 95};

int[] score = marks; //目标和源会指向相同的内存位置

声明多维数组

int [ , , ] m;

Array 类的属性

IsFixedSize

获取一个值，该值指示数组是否带有固定大小。

2 IsReadOnly

获取一个值，该值指示数组是否只读。

3 Length

获取一个 32 位整数，该值表示所有维度的数组中的元素总数。

4 LongLength

获取一个 64 位整数，该值表示所有维度的数组中的元素总数。

5 Rank

获取数组的秩（维度）。

Array 类的方法

1 Clear

根据元素的类型，设置数组中某个范围的元素为零、为 false 或者为 null。

2 Copy(Array, Array, Int32)

从数组的第一个元素开始复制某个范围的元素到另一个数组的第一个元素位置。长度由一个 32 位整数指定。

3 CopyTo(Array, Int32)

从当前的一维数组中复制所有的元素到一个指定的一维数组的指定索引位置。索引由一个 32 位整数指定。

4 GetLength

获取一个 32 位整数，该值表示指定维度的数组中的元素总数。

5 GetLongLength

获取一个 64 位整数，该值表示指定维度的数组中的元素总数。

6 GetLowerBound

获取数组中指定维度的下界。

7 GetType

获取当前实例的类型。从对象（Object）继承。

8 GetUpperBound

获取数组中指定维度的上界。

9 GetValue(Int32)

获取一维数组中指定位置的值。索引由一个 32 位整数指定。

10 IndexOf(Array, Object)

搜索指定的对象，返回整个一维数组中第一次出现的索引。

11 Reverse(Array)

逆转整个一维数组中元素的顺序。

12 SetValue(Object, Int32)

给一维数组中指定位置的元素设置值。索引由一个 32 位整数指定。

13 Sort(Array)

使用数组的每个元素的 IComparable 实现来排序整个一维数组中的元素。

14 ToString

返回一个表示当前对象的字符串。从对象（Object）继承。

using System;

namespace ArrayApplication

{

class MyArray

{

static void Main(string[] args)

{

int[] list = { 34, 72, 13, 44, 25, 30, 10 };

int[] temp = list;

Console.Write("原始数组： ");

foreach (int i in list)

{

Console.Write(i + " ");

}

Console.WriteLine();

// 逆转数组

Array.Reverse(temp);

Console.Write("逆转数组： ");

foreach (int i in temp)

{

Console.Write(i + " ");

}

Console.WriteLine();

// 排序数组

Array.Sort(list);

Console.Write("排序数组： ");

foreach (int i in list)

{

Console.Write(i + " ");

}

Console.WriteLine();

Console.ReadKey();

}

String 对象

通过给 String 变量指定一个字符串

通过使用 String 类构造函数

通过使用字符串串联运算符（ + ）

通过检索属性或调用一个返回字符串的方法

通过格式化方法来转换一个值或对象为它的字符串表示形式

using System;


namespace StringApplication
{
    class Program
    {
        static void Main(string[] args)
        {
           //字符串，字符串连接
            string fname, lname;
            fname = "Rowan";
            lname = "Atkinson";


            string fullname = fname + lname;
            Console.WriteLine("Full Name: {0}", fullname);


            //通过使用 string 构造函数
            char[] letters = { 'H', 'e', 'l', 'l','o' };
            string greetings = new string(letters);
            Console.WriteLine("Greetings: {0}", greetings);


            //方法返回字符串
            string[] sarray = { "Hello", "From", "Tutorials", "Point" };
            string message = String.Join(" ", sarray);
            Console.WriteLine("Message: {0}", message);


            //用于转化值的格式化方法
            DateTime waiting = new DateTime(2012, 10, 10, 17, 58, 1);
            string chat = String.Format("Message sent at {0:t} on {0:D}",
            waiting);
            Console.WriteLine("Message: {0}", chat);
            Console.ReadKey() ;
        }
    }
}

String 类的属性

1 Chars

在当前 String 对象中获取 Char 对象的指定位置。

2 Length

在当前的 String 对象中获取字符数。

String 类的方法

String 类有许多方法用于 string 对象的操作。下面的表格提供了一些最常用的方法：

1 public static int Compare( string strA, string strB )

比较两个指定的 string 对象，并返回一个表示它们在排列顺序中相对位置的整数。该方法区分大小写。

2 public static int Compare( string strA, string strB, bool ignoreCase )

比较两个指定的 string 对象，并返回一个表示它们在排列顺序中相对位置的整数。但是，如果布尔参数为真时，该方法不区分大小写。

3 public static string Concat( string str0, string str1 )

连接两个 string 对象。

4 public static string Concat( string str0, string str1, string str2 )

连接三个 string 对象。

5 public static string Concat( string str0, string str1, string str2, string str3 )

连接四个 string 对象。

6 public bool Contains( string value )

返回一个表示指定 string 对象是否出现在字符串中的值。

7 public static string Copy( string str )

创建一个与指定字符串具有相同值的新的 String 对象。

8 public void CopyTo( int sourceIndex, char[] destination, int destinationIndex, int count )

从 string 对象的指定位置开始复制指定数量的字符到 Unicode 字符数组中的指定位置。

9 public bool EndsWith( string value )

判断 string 对象的结尾是否匹配指定的字符串。

10 public bool Equals( string value )

判断当前的 string 对象是否与指定的 string 对象具有相同的值。

11 public static bool Equals( string a, string b )

判断两个指定的 string 对象是否具有相同的值。

12 public static string Format( string format, Object arg0 )

把指定字符串中一个或多个格式项替换为指定对象的字符串表示形式。

13 public int IndexOf( char value )

返回指定 Unicode 字符在当前字符串中第一次出现的索引，索引从 0 开始。

14 public int IndexOf( string value )

返回指定字符串在该实例中第一次出现的索引，索引从 0 开始。

15 public int IndexOf( char value, int startIndex )

返回指定 Unicode 字符从该字符串中指定字符位置开始搜索第一次出现的索引，索引从 0 开始。

16 public int IndexOf( string value, int startIndex )

返回指定字符串从该实例中指定字符位置开始搜索第一次出现的索引，索引从 0 开始。

17 public int IndexOfAny( char[] anyOf )

返回某一个指定的 Unicode 字符数组中任意字符在该实例中第一次出现的索引，索引从 0 开始。

18 public int IndexOfAny( char[] anyOf, int startIndex )

返回某一个指定的 Unicode 字符数组中任意字符从该实例中指定字符位置开始搜索第一次出现的索引，索引从 0 开始。

19 public string Insert( int startIndex, string value )

返回一个新的字符串，其中，指定的字符串被插入在当前 string 对象的指定索引位置。

20 public static bool IsNullOrEmpty( string value )

指示指定的字符串是否为 null 或者是否为一个空的字符串。

21 public static string Join( string separator, params string[] value )

连接一个字符串数组中的所有元素，使用指定的分隔符分隔每个元素。

22 public static string Join( string separator, string[] value, int startIndex, int count )

连接接一个字符串数组中的指定位置开始的指定元素，使用指定的分隔符分隔每个元素。

23 public int LastIndexOf( char value )

返回指定 Unicode 字符在当前 string 对象中最后一次出现的索引位置，索引从 0 开始。

24 public int LastIndexOf( string value )

返回指定字符串在当前 string 对象中最后一次出现的索引位置，索引从 0 开始。

25 public string Remove( int startIndex )

移除当前实例中的所有字符，从指定位置开始，一直到最后一个位置为止，并返回字符串。

26 public string Remove( int startIndex, int count )

从当前字符串的指定位置开始移除指定数量的字符，并返回字符串。

27 public string Replace( char oldChar, char newChar )

把当前 string 对象中，所有指定的 Unicode 字符替换为另一个指定的 Unicode 字符，并返回新的字符串。

28 public string Replace( string oldValue, string newValue )

把当前 string 对象中，所有指定的字符串替换为另一个指定的字符串，并返回新的字符串。

29 public string[] Split( params char[] separator )

返回一个字符串数组，包含当前的 string 对象中的子字符串，子字符串是使用指定的 Unicode 字符数组中的元素进行分隔的。

30 public string[] Split( char[] separator, int count )

返回一个字符串数组，包含当前的 string 对象中的子字符串，子字符串是使用指定的 Unicode 字符数组中的元素进行分隔的。int 参数指定要返回的子字符串的最大数目。

31 public bool StartsWith( string value )

判断字符串实例的开头是否匹配指定的字符串。

32 public char[] ToCharArray()

返回一个带有当前 string 对象中所有字符的 Unicode 字符数组。

33 public char[] ToCharArray( int startIndex, int length )

返回一个带有当前 string 对象中所有字符的 Unicode 字符数组，从指定的索引开始，直到指定的长度为止。

34 public string ToLower()

把字符串转换为小写并返回。

35 public string ToUpper()

把字符串转换为大写并返回。

36 public string Trim()

移除当前 String 对象中的所有前导空白字符和后置空白字符。

属性

Count 获取 Hashtable 中包含的键值对个数。

IsFixedSize 获取一个值，表示 Hashtable 是否具有固定大小。

IsReadOnly 获取一个值，表示 Hashtable 是否只读。

Item 获取或设置与指定的键相关的值。

Keys 获取一个 ICollection，包含 Hashtable 中的键。

Values 获取一个 ICollection，包含 Hashtable 中的值。

下表列出了 Hashtable 类的一些常用的方法：

方法名

1 public virtual void Add( object key, object value );

向 Hashtable 添加一个带有指定的键和值的元素。

2 public virtual void Clear();

从 Hashtable 中移除所有的元素。

3 public virtual bool ContainsKey( object key );

判断 Hashtable 是否包含指定的键。

4 public virtual bool ContainsValue( object value );

判断 Hashtable 是否包含指定的值。

5 public virtual void Remove( object key );

从 Hashtable 中移除带有指定的键的元素。

using System;

using System.Collections;

namespace CollectionsApplication

{

class Program

{

static void Main(string[] args)

{

Hashtable ht = new Hashtable();

ht.Add("001", "Zara Ali");

ht.Add("002", "Abida Rehman");

ht.Add("003", "Joe Holzner");

ht.Add("004", "Mausam Benazir Nur");

ht.Add("005", "M. Amlan");

ht.Add("006", "M. Arif");

ht.Add("007", "Ritesh Saikia");

if (ht.ContainsValue("Nuha Ali"))

{

Console.WriteLine("This student name is already in the list");

}

else

{

ht.Add("008", "Nuha Ali");

}

// 获取键的集合

ICollection key = ht.Keys;

foreach (string k in key)

{

Console.WriteLine(k + ": " + ht[k]);

}

Console.ReadKey();

}

堆栈（Stack）代表了一个后进先出的对象集合

Stack 类属性

Count 获取 Stack 中包含的元素个数。

Stack 类的方法

1 public virtual void Clear();

从 Stack 中移除所有的元素。

2 public virtual bool Contains( object obj );

判断某个元素是否在 Stack 中。

3 public virtual object Peek();

返回在 Stack 的顶部的对象，但不移除它。

4 public virtual object Pop();

移除并返回在 Stack 的顶部的对象。

5 public virtual void Push( object obj );

向 Stack 的顶部添加一个对象。

6 public virtual object[] ToArray();

复制 Stack 到一个新的数组中。

using System;

using System.Collections;

namespace CollectionsApplication

{

class Program

{

static void Main(string[] args)

{

Stack st = new Stack();

st.Push('A');

st.Push('M');

st.Push('G');

st.Push('W');

Console.WriteLine("Current stack: ");

foreach (char c in st)

{

Console.Write(c + " ");

}

Console.WriteLine();

st.Push('V');

st.Push('H');

Console.WriteLine("The next poppable value in stack: {0}", st.Peek());

Console.WriteLine("Current stack: ");

foreach (char c in st)

{

Console.Write(c + " ");

}

Console.WriteLine();

Console.WriteLine("Removing values ");

st.Pop();

Console.WriteLine("Current stack: ");

foreach (char c in st)

{

Console.Write(c + " ");

}

属性

Capacity 获取或设置 ArrayList 可以包含的元素个数。
Count 获取 ArrayList 中实际包含的元素个数。
IsFixedSize 获取一个值，表示 ArrayList 是否具有固定大小。
IsReadOnly 获取一个值，表示 ArrayList 是否只读。
Item 获取或设置指定索引处的元素。

方法

1 public virtual int Add( object value );在 ArrayList 的末尾添加一个对象。

2 public virtual void AddRange( ICollection c );在 ArrayList 的末尾添加 ICollection 的元素。

3 public virtual void Clear();从 ArrayList 中移除所有的元素。

4 public virtual bool Contains( object item );判断某个元素是否在 ArrayList 中。

5 public virtual ArrayList GetRange( int index, int count );返回一个 ArrayList，表示源 ArrayList 中元素的子集。

6 public virtual int IndexOf(object);返回某个值在 ArrayList 中第一次出现的索引，索引从零开始。

7 public virtual void Insert( int index, object value );在 ArrayList 的指定索引处，插入一个元素。

8 public virtual void InsertRange( int index, ICollection c );在 ArrayList 的指定索引处，插入某个集合的元素。

9 public virtual void Remove( object obj );从 ArrayList 中移除第一次出现的指定对象。

10 public virtual void RemoveAt( int index );移除 ArrayList 的指定索引处的元素。

11 public virtual void RemoveRange( int index, int count );从 ArrayList 中移除某个范围的元素。

12 public virtual void Reverse();逆转 ArrayList 中元素的顺序。

13 public virtual void SetRange( int index, ICollection c );复制某个集合的元素到 ArrayList 中某个范围的元素上。

14 public virtual void Sort();对 ArrayList 中的元素进行排序。

15 public virtual void TrimToSize();设置容量为 ArrayList 中元素的实际个数。

using System;

using System.Collections;

namespace CollectionApplication

{

class Program

{

static void Main(string[] args)

{

ArrayList al = new ArrayList();

Console.WriteLine("Adding some numbers:");

al.Add(45);

al.Add(78);

al.Add(33);

al.Add(56);

al.Add(12);

al.Add(23);

al.Add(9);

Console.WriteLine("Capacity: {0} ", al.Capacity);

Console.WriteLine("Count: {0}", al.Count);

Console.Write("Content: ");

foreach (int i in al)

{

Console.Write(i + " ");

}

Console.WriteLine();

Console.Write("Sorted Content: ");

al.Sort();

foreach (int i in al)

{

Console.Write(i + " ");

}

Console.WriteLine();

Console.ReadKey();

}

属性

Count 获取 Queue 中包含的元素个数。

方法

1 public virtual void Clear();从 Queue 中移除所有的元素。
2 public virtual bool Contains( object obj );判断某个元素是否在 Queue 中。
3 public virtual object Dequeue();移除并返回在 Queue 的开头的对象。
4 public virtual void Enqueue( object obj );向 Queue 的末尾添加一个对象。
5 public virtual object[] ToArray();复制 Queue 到一个新的数组中。
6 public virtual void TrimToSize();设置容量为 Queue 中元素的实际个数。

using System;

using System.Collections;

namespace CollectionsApplication

{

class Program

{

static void Main(string[] args)

{

Queue q = new Queue();

q.Enqueue('A');

q.Enqueue('M');

q.Enqueue('G');

q.Enqueue('W');

Console.WriteLine("Current queue: ");

foreach (char c in q)

Console.Write(c + " ");

Console.WriteLine();

q.Enqueue('V');

q.Enqueue('H');

Console.WriteLine("Current queue: ");

foreach (char c in q)

Console.Write(c + " ");

Console.WriteLine();

Console.WriteLine("Removing some values ");

char ch = (char)q.Dequeue();

Console.WriteLine("The removed value: {0}", ch);

ch = (char)q.Dequeue();

Console.WriteLine("The removed value: {0}", ch);

Console.ReadKey();

}

属性

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

方法

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

Dictionary<[key], [value]>

属性

Comparer 获取用于确定字典中的键是否相等的 IEqualityComparer<T>。
Count 获取包含在 Dictionary<TKey, TValue> 中的键/值对的数目。
Item[TKey] 获取或设置与指定的键关联的值。
Keys 获得一个包含 Dictionary<TKey, TValue> 中的键的集合。
Values 获得一个包含 Dictionary<TKey, TValue> 中的值的集合。

方法

Add(TKey, TValue) 指定的键和值添加到字典中。
Clear() 将所有键和值从 Dictionary<TKey, TValue> 中移除。
ContainsKey(TKey) 确定是否 Dictionary<TKey, TValue> 包含指定键。
ContainsValue(TValue) 确定 Dictionary<TKey, TValue> 是否包含特定值。
Equals(Object) 确定指定的对象是否等于当前对象。（继承自 Object。）
Finalize() 在垃圾回收将某一对象回收前允许该对象尝试释放资源并执行其他清理操作。继承自 object。）
GetEnumerator() 返回循环访问 Dictionary<TKey, TValue> 的枚举数。
GetHashCode() 作为默认哈希函数。（继承自 Object。）
GetObjectData(SerializationInfo, StreamingContext) 实现 ystem.Runtime.Serialization.ISerializable 接口，并返回序列化 Dictionary<TKey, TValue> 实例所需的数据。
GetType() 获取当前实例的 Type。（继承自 Object。）
MemberwiseClone() 创建当前 Object 的浅表副本。（继承自 Object。）
OnDeserialization(Object) 实现 System.Runtime.Serialization.ISerializable 接口，并在完成反序列化之后引发反序列化事件。
Remove(TKey) 将带有指定键的值从 Dictionary<TKey, TValue> 中移除。

C#中数组、ArrayList和List三者的区别