foreach  我知道这个也能循环，但这个一般用到哪？
望大神带上代码!

int[] fibarray = new int[] { 0, 1, 2, 3, 5, 8, 13 };
        foreach (int i in fibarray)
        {
            System.Console.WriteLine(i);
        }
        for(int i=0; i<fibarray.length-1;i++)
        {
            System.Console.WriteLine(fibarray[i]);
        }
这是两种用法 达到的效果一样的 个人认为foreach 在底层还是封装了for功能的

实现枚举接口！

李洋 发表于 2013-10-21 10:38
循环语句是编程的基本语句，在C#中除了沿用C语言的循环语句外，还提供了foreach语句来实现循环。那么我要说 ...

很详细，受用了

就是在一段字符数组或集合里面找自己想要的
语句格式：
foreach（【类型】 【迭代变量名】 in 【集合类型的表达式】）
{
     【语句块】
}

forecach的主要作用是遍历，将数组或集合的所有元素都遍历一次.
与for对比一下更好理解：
for具有foreach的遍历作用，而且for还可以指定循环遍历的次数，即for的功能大于foreach,如果仅仅是遍历元素foreach更方便，如下对比：

string[] strs = "我是中国人";
forech(int i in strs)
{
   console.WriteLine(strs);
}

string[] strs = "我是中国人";
for(int i=0;i<strs.length;i++)
{
   console.WriteLine(strs[i]);
}

for 循环：
for(表达式1；表达式2；表达式3)
{
循环体；
}
表达式1：一般用来声明循环变量  int i=0；
表达式2：一般为关系表达式  i<100;
表达式3：改变循环条件  i++;
对已知循环次数的循环 多用for循环；
Foreach
语法：
Foreach(集合中单个的类型 局部变量名  in  集合对象)
{
循环体；//循环体中的”局部变量”表示集合中遍历的数剧
}
循环的过程：总是从开始，一直循环到结束，中间不会停下来，除了break；

循环语句是编程的基本语句，在C#中除了沿用C语言的循环语句外，还提供了foreach语句来实现循环。那么我要说的就是，在循环操作中尽量使用foreach语句来实现。

为了来更好地说明为什么要提倡使用foreach，用如下三种不同方式来编写循环语句。
        int[] nArray = new int[100];

        // Use "foreach" to loop array
        foreach( int i in nArray )
            Debug.WriteLine( i.ToString() );

        // Use "for" to loop array
        for( int i = 0; i < nArray.Length; i++ )
            Debug.WriteLine( nArray[i].ToString() );

        // Another way using "for" to loop array
        int nLength = nArray.Length;
        for( int i = 0; i < nLength; i++ )
            Debug.WriteLine( nArray[i].ToString() );

很明显，foreach语句很简洁，但是它的优点不仅仅在于此，它的效率也是最高的。可能很多人认为最后一种的效率会更高，因为表面上看着不用每次访问引用类型的属性。可是它却是三者当中，效率最低的。因为C#是强类型检查，那么对于数组访问的时候，要对索引的有效值进行判断，那么对于最后一种代码实际产生的效果如同下面的代码一样。
        // Another way using "for" to loop array
        int nLength = nArray.Length;
        for( int i = 0; i < nLength; i++ )
        {
            if( i < nArray.Length )
                Debug.WriteLine( nArray[i].ToString() );
            else
                throw new IndexOutOfRangeException();
        }
（书中这里有些出入，经过网友sozdream的提示，在1.1环境下发现最后一种方法是最快的，前两者的速度基本相等；通过Dissambly查看最后一种循环方法所产生的代码，并没有产生类似于文章所说的那种索引检查。不过还是不建议使用最后一种，因为此方法对索引的判断有些脱节，尤其是当循环中数组尺寸发生变化的时候，索引有效检查无法及时进行）

foreach语句除了简洁和高效外，还有很多优点，接下来一一列举。

第一个就是不用考虑数组起始索引是几，很多人可能从其他语言转到C#的，那么原先语言的起始索引可能不是1，例如VB或者Delphi语言，那么在C#中使用数组的时候就难免疑问到底使用0开始还是用1开始呢，那么使用foreach就可以避免这类问题。

第二个好处就是对于多维数组操作用foreach就非常简便了，例如：
        int[,] nVisited = new int[8,8];
        // Use "for" to loop two-dimension array
        for( int i = 0; i < nVisited.GetLength(0); i++ )
            for( int j = 0; j < nVisited.GetLength( 1 ); j++ )
                Debug.WriteLine( nVisited[i,j].ToString() );

        // Use "foreach" to loop two-dimension array
        foreach( int i in nVisited )
            Debug.WriteLine( i.ToString() );

对于三维或更多维，foreach语句不用发生任何变化，而对于for语句来说就要进行修改了，这里就不多说了。

第三个要说的就是foreach完成类型转换操作，这种体现可能通过如上的例子看不出任何效果，但是对于ArrayList之类的数据集来说，这种操作就显得比较突出，例如：
        // Init an arraylist object
        int[] nArray = new int[100];
        ArrayList arrInt = new ArrayList();
        arrInt.AddRange( nArray );

        // Use "foreach" to loop an arraylist
        foreach( int i in arrInt )
            Debug.WriteLine( i.ToString() );

        // Use "for" to loop an arraylist
        for( int i = 0; i < arrInt.Count; i++ )
        {
            int n = ( int ) arrInt[i];
            Debug.WriteLine( n.ToString() );
        }

最后要说的是使用foreach并没有增加资源使用，这句话听得有些难懂，由于对于继承了IEnumerable接口的类型数据，才能使用foreach语句，那么对于使用foreach会访问IEnumerable接口中GetEnumerator方法来进行枚举，那么对于如上的foreach语句，对应的语句其实如下：
        IEnumerator it = arrInt.GetEnumerator() as IEnumerator;
        using( IDisposable disp = it as IDisposable )
        {
            while( it.MoveNext() )
            {
                int elem = ( int )it.Current;
                Debug.WriteLine( elem.ToString() );
            }
        }

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

对于foreach说了这么多好处，那么在使用它是否可以无懈可击呢。其实不是这样的，在foreach语句中有两个限制，第一不能修改枚举成员，其次不要对集合进行删除操作。也就是如下两种方式都是错误的。
        // Use "foreach" to loop an arraylist
        foreach( int i in arrInt )
        {
            i++;//Can't be compiled
            Debug.WriteLine( i.ToString() );
        }

        // Use "foreach" to loop an arraylist
        foreach( int i in arrInt )
        {
            arrInt.Remove( i );//It will generate error in run-time
            Debug.WriteLine( i.ToString() );
        }

那么对于如上两个操作，可以用for来实现，此外这里多说一句，就是对于一个记录集的多条数据删除问题，也是经常出现问题的地方（论坛上经常问类似的问题），由于在一些记录集中进行删除的时候，在删除操作之后相应的索引也发生了变化，这时候的删除要反过来进行删除，大致形式如下。
        // Use "for" to loop an arraylist
        for( int i = arrInt.Count - 1; i >=0; i-- )
        {
            int n = ( int ) arrInt[i];
            if( n == 5 )
                arrInt.RemoveAt( i ); // Remove data here
            Debug.WriteLine( n.ToString() );
        }

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

1. Public Void ClearAllLables(ControlCollection  MyControlCollections)
   
2. {
   
3.   foreach(System.Web.UI.Control MyControls in MyControllections)
   
4.    {
   
5.      if(MyControls.HasControls())
   
6.       {
   
7.         ClearAllLables(MyControls.Controls);
   
8.       }
   
9.      else
   
10.       {
    
11. 　　　　　　if(MyControls is System.Web.UI.WebControls.Lable)
    
12.             {
    
13.                ((Lable)MyControls).Text=String.Empty;
    
14.              }
    
15. 　　　　｝
    
16.    }
    
17. }
    
18. //再调用这个方法就行了
    
19. 
    
20. protected void btSearch_Click(object sender, EventArgs e)
    
21.     {
    
22.        ClearAllLables(this.Controls);     
    
23.      }

复制代码

给你看一个foreach遍历控件的代码。
这就说明 foreach 的遍历类型其实很多，。很强大。

int[] arr= {1,2,3,4};
foreach(int i in arr)
{
    console.WriteLine(i);
}
一般用于遍历数组的时候

在对键值要求不高的情况下使用，用于遍历数组、集合、字典等。

forech()跟for循环差不多，在有些情况下会很好用。比如遍历某个数组的时候
int[] numbers = {1,2,3,4,56,6};
forech(int item in numbers)
{
   console.WriteLine(item);
}
要灵活运用

int[] fibarray = new int[] { 0, 1, 2, 3, 5, 8, 13 };
        foreach (int i in fibarray)
        {
            System.Console.WriteLine(i);
        }