c#--foreach遍历的用法与split的用法

一、

foreach循环用于列举出集合中所有的元素，foreach语句中的表达式由关键字in隔开的两个项组成。in右边的项是集合名，in左边的项是变量名，用来存放该集合中的每个元素。
该循环的运行过程如下：每一次循环时，从集合中取出一个新的元素值。放到只读变量中去，如果括号中的整个表达式返回值为true，foreach块中的语句就能够执行。一旦集合中的元素都已经被访问到，整个表达式的值为false，控制流程就转入到foreach块后面的执行语句。

foreach语句经常与数组一起使用，下面实例将通过foreach语句读取数组的值并进行显示。

数组的属性：Array.Length数组的容量。利用这个属性，我们可以取得数组对象允许存储的容量值，也就是数组的长度、元素个数,这个比较好理解，数组还有其他的属性，比如数组的维数等，属性的用法比较简单，学会一种，其他的格式基本一致，这里我们就不举例了。
当数组的维数、容量较多时，C#提供了foreach语句，专门用来读取集合/数组中的所有元素，我们把这种功能叫做遍历。语法书写如下：

遍历数组：foreach（type objName in collection/Array）
这段语句会逐一检查数组中的所存储的变量值，并且一一将其取出，其中的type是你所要读取的数组对象将要存储在objName变量的数据类型，而objName是定义了一个type类型的变量名，代表每一次从集合和数组（collection/Array）中取得的元素，collection/Array则是所要存取的数组对象。用这种方法只需写一个foreach就可以遍历出除交错数组以外的所有维数的数组。
注： objName的数据类型type必须与collection/Array对象的类型相同或比它大。
下面我们举一个用foreach和for遍历规则数组的例子，其中涉及到了一个数组得到维数的方法，比较foreach在一次性遍历规则数组上的优势。

 1   int[,,] a = new int[2, 2, 2] { {{ 1, 2 }, { 3,4}},{{ 5, 6 }, { 7,8}} };//定义一个2行2列2纵深的3维数组a
 2             for (int i = 0; i < a.GetLength (0) ;i++ )   //用Array.GetLength(n)得到数组[0,1,,,n]上的维数的元素数，0代表行，1列，n代表此数组是n+1维
 3             {
 4                 for (int j = 0; j < a.GetLength(1); j++)
 5                 {
 6                     for (int z = 0; z < a.GetLength(2);z++ )//2代表得到纵深上的元素数，如果数组有n维就得写n个for循环
 7                     {
 8                         Console.WriteLine(a[i,j,z]);
 9                     }
10                 }
11             }
12 用foreach循环一次性遍历a数组
13           int[,,] a = new int[2, 2, 2] { {{ 1, 2 }, { 3,4}},{{ 5, 6 }, { 7,8}} };//定义一个2行2列2纵深的3维数组a
14                       foreach(int i in a)
15                       {
16                           Console .WriteLine (i);
17                       }

这两种代码执行的结果是一样的都是每行一个元素，共8行，元素分别是1 2 3 4 5 6 7 8
下面我们再做个例子，是一个利用for和foreach循环做的存取数组元素的例子，首先提示用户输入学生的个数，然后把学生个数作为存储学生姓名的数组names的元素个数，采用for循环按照数组的索引i从0位开始循环输出“输入学生姓名”的提示，并把用户输入的学生姓名按照其在数组的索引方式names[i]存储在names数组中，for循环次数的最大值（即索引的最大值）通过数组属性.Length得到，我们说过容量与索引之间的关系是index=Array.Length-1,本题即i的最大<names.Length,存储后，提示“输出学生姓名”，再用foreach循环一次性遍历names数组中存储的每个元素（学生的姓名），一个一个的把它赋值给name元素，然后输出到控制台上。
必须注意的是，借助foreach，只能一一取得数组中的元素，并不能利用这种语句改变数组所存储的元素。

 1 using System;
 2 class Program
 3 {
 4 static void Main()
 5 {
 6    int count;
 7    Console.WriteLine("输入要登记的学生数");
 8    count = int.Parse(Console.ReadLine());
 9    string[]names = new string[count];
10    for (int i = 0; i < names.Length; i++)
11    {
12     Console.WriteLine("请输入第{0}个学生的姓名", i + 1);
13     names[i] = Console.ReadLine();
14    }
15    Console.WriteLine("已登记的学生如下");
16    foreach (string name in names)
17    {
18     Console.WriteLine("{0}", name);
19    }
20    Console.ReadKey();
21 }
22 }

View Code

C#中遍历各类数据集合的方法，这里自己做下总结：

 1 1.枚举类型
 2             //遍历枚举类型Sample的各个枚举名称
 3             foreach (string sp in Enum.GetNames(typeof(Sample)))
 4             {
 5                 ary.Add(sp);
 6             }
 7             //遍历枚举类型Sample的各个枚举值
 8             foreach (string sp in Enum.GetValues(typeof(Sample)))
 9             {
10                 ary.Add(sp);
11             }
12  
13 2.遍历ArrayList(Queue、Stack)
14 这里以string为例，当然ArrayList中的元素可以是任何数据类型，遍历时须确认ArrayList中的元素都是同一数据类型。
15             //遍历元素为string类型的队列
16             foreach (string text in arraylist)
17             {
18                 ary.Add(text);
19             }
20 此外遍历Queue队列和Stack堆栈的方式与ArrayList基本相同， 都可以使用foreach来循环遍历，只不过一个是先进先出另一个是先进后出罢了。
21  
22 3.Winform窗体中的控件
23             //遍历寻找主窗体中的控件，并将符合条件的控件从窗体上去除
24             foreach (Control ctl in this.Controls)
25             {
26                 //获取并判断控件类型或控件名称
27                 if (ctl.GetType().Name.Equals("ListBox") || ctl.Name.Equals("listBox1"))
28                     this.Controls.Remove(ctl);
29             }
30  
31 4.HashTable哈希表
32 DictionaryEntry类需要引用System.Collections
33             //遍历完整哈希表中的键和值
34             foreach (DictionaryEntry item in hashTable)
35             {
36                 ary.Add("哈希键："+item.Key+",哈希值："+item.Value.ToString());
37             }
38  此外还可以单独遍历哈希表中的键或值。
39             //只遍历哈希表中的键
40             foreach (string key in hashTable.Keys)
41             {
42                 ary.Add("哈希键：" + key);
43             }
44 
45             //只遍历哈希表中的值
46             foreach (string value in hashTable.Values)
47             {
48                 ary.Add("哈希值：" + value);
49             }
50  
51 5.遍历DataSet和DataTable中的行和列
52             //遍历DataSet中的表
53             foreach (DataTable dt in dataSet.Tables)
54             {
55                 ary.Add("表名：" + dt.TableName.ToString());
56 
57             }
58             //遍历DataSet中默认第一个表中的行
59             foreach (DataRow dr in dataSet.Tables[0].Rows)
60             {
61                 //获取行中某个字段（列）的数据
62                 ary.Add(dr["ID"].ToString());
63             }
64             //遍历DataSet中默认第一个表中的列
65             foreach (DataColumn col in dataSet.Tables[0].Columns)
66             {
67                 ary.Add("列名："+col.ColumnName);
68             }
69 DataTable遍历行和列的方法和DataSet类似，只是将dataSet.Tables[0]换成具体某张表就可以了。
70 另外还可以对DataTable表进行SQL查询，然后再对查询结果进行遍历。
71             //遍历DataSet中表SELECT执行查询条件后的结果
72             foreach (DataRow dr in dataSet.Tables[0].Select(" MONTH>6 AND MONTH<12 "))
73             {
74                 //获取行中某个字段（列）的数据
75                 ary.Add(dr["ID"].ToString());
76             }
77  
78 6.遍历DataGridView中的行
79             //遍历DataGridView中的行
80             foreach (DataGridViewRow dr in dataGridView1.Rows)
81             {
82                 //获取行中某个字段（列）的数据
83                 ary.Add(dr.Cells["ID"].ToString());
84             }
85

View Code

7.遍历ListBOX和ComboBox中的item
一般foreach遍历只能遍历到ListBOX和ComboBox里item的名称,完整遍历需要在绑定item的时候添加的item数据是个二元属性自定义类的对象,将对象中一个属性的名称作为DisplayMember(item名)，另一个作为DisplayValue(item值)。这样在遍历的时候就可以把ListBOX和ComboBox中的item的名称和值全部获取出来了。
循环语句是编程的基本语句，在C#中除了沿用C语言的循环语句外，还提供了foreach语句来实现循环。那么我要说的就是，在循环操作中尽量使用foreach语句来实现。
为了来更好地说明为什么要提倡使用foreach，用如下三种不同方式来编写循环语句。

 1 int[] nArray = new int[100];
 2  
 3         // Use "foreach" to loop array
 4         foreach( int i in nArray )
 5             Debug.WriteLine( i.ToString() );
 6  
 7         // Use "for" to loop array
 8         for( int i = 0; i < nArray.Length; i++ )
 9             Debug.WriteLine( nArray[i].ToString() );
10  
11         // Another way using "for" to loop array
12         int nLength = nArray.Length;
13         for( int i = 0; i < nLength; i++ )
14             Debug.WriteLine( nArray[i].ToString() );
15

很明显，foreach语句很简洁，但是它的优点不仅仅在于此，它的效率也是最高的。可能很多人认为最后一种的效率会更高，因为表面上看着不用每次访问引用类型的属性。可是它却是三者当中，效率最低的。因为C#是强类型检查，那么对于数组访问的时候，要对索引的有效值进行判断，那么对于最后一种代码实际产生的效果如同下面的代码一样。

1   // Another way using "for" to loop array
2         int nLength = nArray.Length;
3         for( int i = 0; i < nLength; i++ )
4         {
5             if( i < nArray.Length )
6                 Debug.WriteLine( nArray[i].ToString() );
7             else
8                 throw new IndexOutOfRangeException();
9         }

（书中这里有些出入，经过网友sozdream的提示，在1.1环境下发现最后一种方法是最快的，前两者的速度基本相等；通过Dissambly查看最后一种循环方法所产生的代码，并没有产生类似于文章所说的那种索引检查。不过还是不建议使用最后一种，因为此方法对索引的判断有些脱节，尤其是当循环中数组尺寸发生变化的时候，索引有效检查无法及时进行）
foreach语句除了简洁和高效外，还有很多优点，接下来一一列举。
第一个就是不用考虑数组起始索引是几，很多人可能从其他语言转到C#的，那么原先语言的起始索引可能不是1，例如VB或者Delphi语言，那么在C#中使用数组的时候就难免疑问到底使用0开始还是用1开始呢，那么使用foreach就可以避免这类问题。
第二个好处就是对于多维数组操作用foreach就非常简便了，例如：

1 int[,] nVisited = new int[8,8];
2         // Use "for" to loop two-dimension array
3         for( int i = 0; i < nVisited.GetLength(0); i++ )
4             for( int j = 0; j < nVisited.GetLength( 1 ); j++ )
5                 Debug.WriteLine( nVisited[i,j].ToString() );
6  
7         // Use "foreach" to loop two-dimension array
8         foreach( int i in nVisited )
9             Debug.WriteLine( i.ToString() );

对于三维或更多维，foreach语句不用发生任何变化，而对于for语句来说就要进行修改了，这里就不多说了。
第三个要说的就是foreach完成类型转换操作，这种体现可能通过如上的例子看不出任何效果，但是对于ArrayList之类的数据集来说，这种操作就显得比较突出，例如：

 1  // Init an arraylist object
 2         int[] nArray = new int[100];
 3         ArrayList arrInt = new ArrayList();
 4         arrInt.AddRange( nArray );
 5  
 6         // Use "foreach" to loop an arraylist
 7         foreach( int i in arrInt )
 8             Debug.WriteLine( i.ToString() );
 9  
10         // Use "for" to loop an arraylist
11         for( int i = 0; i < arrInt.Count; i++ )
12         {
13             int n = ( int ) arrInt[i];
14             Debug.WriteLine( n.ToString() );
15         }
16

最后要说的是使用foreach并没有增加资源使用，这句话听得有些难懂，由于对于继承了IEnumerable接口的类型数据，才能使用foreach语句，那么对于使用foreach会访问IEnumerable接口中GetEnumerator方法来进行枚举，那么对于如上的foreach语句，对应的语句其实如下：

1  IEnumerator it = arrInt.GetEnumerator() as IEnumerator;
2         using( IDisposable disp = it as IDisposable )
3         {
4             while( it.MoveNext() )
5             {
6                 int elem = ( int )it.Current;
7                 Debug.WriteLine( elem.ToString() );
8             }
9         }

也就是说在出了foreach之后对于IEnumerator的对象也进行Dispose处理。

对于foreach说了这么多好处，那么在使用它是否可以无懈可击呢。其实不是这样的，在foreach语句中有两个限制，第一不能修改枚举成员，其次不要对集合进行删除操作。也就是如下两种方式都是错误的。

 1  // Use "foreach" to loop an arraylist
 2         foreach( int i in arrInt )
 3         {
 4             i++;//Can't be compiled
 5             Debug.WriteLine( i.ToString() );
 6         }
 7  
 8         // Use "foreach" to loop an arraylist
 9         foreach( int i in arrInt )
10         {
11             arrInt.Remove( i );//It will generate error in run-time
12             Debug.WriteLine( i.ToString() );
13         }
14

那么对于如上两个操作，可以用for来实现，此外这里多说一句，就是对于一个记录集的多条数据删除问题，也是经常出现问题的地方（论坛上经常问类似的问题），由于在一些记录集中进行删除的时候，在删除操作之后相应的索引也发生了变化，这时候的删除要反过来进行删除，大致形式如下。

1  // Use "for" to loop an arraylist
2         for( int i = arrInt.Count - 1; i >=0; i-- )
3         {
4             int n = ( int ) arrInt[i];
5             if( n == 5 )
6                 arrInt.RemoveAt( i ); // Remove data here
7             Debug.WriteLine( n.ToString() );
8         }
9

除了这两个地方外，foreach可以基本适用于任何循环，因此对于循环的编写要尽量使用foreach，因为它会使你的代码清晰简洁，又不失高效。
二、

split 用法

第一种方法：

1   string s = "abcdeabcdeabcde";
2             string[] sArray = s.Split('c');
3             foreach (string i in sArray)
4                 Console.WriteLine(i.ToString());
5             Console.ReadKey();

输出下面的结果:

ab
deab
deab
de

第二种方法：
我们看到了结果是以一个指定的字符进行的分割。使用另一种构造方法对多个字符进行分割:

1 string s="abcdeabcdeabcde";
2 string[] sArray1=s.Split(new char[3]{'c','d','e'}) ;
3 foreach(string i in sArray1)
4   Console.WriteLine(i.ToString());

可以输出下面的结果：
ab
ab
ab

第三种方法：
除了以上的这两种方法以外,第三种方法是使用正则表达式。新建一个控制台项目。然后先添加引用：

1 using System.Text.RegularExpressions;
2             string content = "agcyongfa365macyongfa365gggyongfa365ytx";
3             string[] resultString = Regex.Split(content, "yongfa365", RegexOptions.IgnoreCase);
4             foreach (string i in resultString)
5                 Console.WriteLine(i.ToString());
6             Console.ReadKey();

输出下面的结果:
agc
mac
ggg
ytx

第四种方法：

1   string str1 = "我*****是*****一*****个*****教*****师";
2             string[] str2;
3             str1 = str1.Replace("*****", "*");
4             str2 = str1.Split('*');
5             foreach (string i in str2)
6                 Console.Write(i.ToString());
7             Console.ReadKey();

一般用的最多的是：str.Replace("\r\n","\r").Split('\r')

第五种方法：
string str1="我**是*****一*****个*****教*****师";
我希望显示的结果为:我是一个教师。
我如果采用上面的第四种方法来做就会产生下面的错误：我   是一个教师。中间有空格输出，所以输出结果并不是希望的结果，这就又回到了正则表达式了，这时可以采用下面的第五种方法：
            string str1 = "我**是*****一*****个*****教*****师";
            string[] str2 = System.Text.RegularExpressions.Regex.Split(str1, @"\*+");
            foreach (string i in str2)
                Console.Write(i.ToString());
            Console.ReadKey();
这里通过\*+巧妙的完成了我们的目标。

其实哥很宅

c#--foreach遍历的用法与split的用法

公告