C# for和foreach之间有什么区别？

for

和

foreach

循环之间的主要区别是什么

在哪些场景中，我们可以使用

for

而不是

foreach

，反之亦然

可以用一个简单的程序来显示吗

---

我觉得两者都一样。我无法区分它们。

如果要迭代的对象实现了

IEnumerable

接口，则可以使用

foreach

。如果只能通过索引访问对象，则需要使用

for

。

for循环的

结构表示“执行此操作n.次”

foreach
循环是一种结构，表示“对该IEnumerable中的每个值/对象执行此操作”
如果您有数组或其他IEnumerable数据集合，foreach是有用的。但是for可用于访问可通过其索引访问的数组元素。
我将尝试用更一般的方法回答这个问题：

foreach
用于以预定义的方式迭代给定集合或列表（任何实现
IEnumerable
的元素）的每个元素。您不能影响确切的顺序（除了跳过条目或取消整个循环），因为这是由容器决定的

foreach (String line in document) { // iterate through all elements of "document" as String objects
    Console.Write(line); // print the line
}

for
只是编写循环的另一种方法，该循环在进入循环之前和每次迭代之后执行一次代码。它通常用于循环给定次数的代码。与foreach相反，这里您可以影响当前位置

for (int i = 0, j = 0; i < 100 && j < 10; ++i) { // set i and j to 0, then loop as long as i is less than 100 or j is less than 10 and increase i after each iteration
    if (i % 8 == 0) { // skip all numbers that can be divided by 8 and count them in j
        ++j
        continue;
    }
    Console.Write(i);
}
Console.Write(j);

对于（int i=0，j=0；i<100&&j<10；++i）{//将i和j设置为0，然后循环，只要i小于100或j小于10，并在每次迭代后增加i
如果（i%8==0）{//跳过所有可以被8除的数字，并在j中计算它们
++j
继续；
}
控制台。写入（i）；
}
控制台。写入（j）；

如果可能且适用，请始终使用
foreach
而不是
for
（假设存在一些数组索引）。根据内部数据组织的不同，
foreach
可以比使用带有索引的
for
快得多（特别是在使用链表时）。
for循环：

 1) need to specify the loop bounds( minimum or maximum).

  2) executes a statement or a block of statements repeatedly 
    until a specified expression evaluates to false.

例1：-
例2：-
关于foreach，每个人都给了你正确的答案，也就是说，它是一种循环实现IEnumerable的元素的方法

另一方面，for比其他答案中显示的要灵活得多。事实上，只要指定的条件为true，for就用于执行语句块

从Microsoft文档：

for (initialization; test; increment)
     statement

初始化
必修的。表情。在执行循环之前，此表达式只执行一次

试验
必修的。布尔表达式。若测试为true，则执行语句。如果test为false，则终止循环

增量
必修的。表情。增量表达式在循环的每次传递结束时执行

声明
可选。若测试为真，则要执行的语句。可以是复合语句

这意味着您可以以多种不同的方式使用它。经典的学校示例是从1到10的数字之和：

int sum = 0;
for (int i = 0; i <= 10; i++)
    sum = sum + i;

int sum = 0;
for (int i = 0; i <= 10; i = i + 2)
    sum = sum + i;

但您可以将其用于从1到10的偶数之和：

int sum = 0;
for (int i = 0; i <= 10; i++)
    sum = sum + i;

int sum = 0;
for (int i = 0; i <= 10; i = i + 2)
    sum = sum + i;

当您预先指示或确定希望循环运行多少次时，for循环非常有用。例如，如果您需要为一周中的每一天执行一个流程，那么您知道您需要7个循环

foreach循环是指您希望对集合或数组的所有部分重复一个过程，但具体循环运行多少次并不重要。例如，您正在格式化用户喜爱的书籍列表。每个用户可能有不同数量的书籍，或者没有，我们并不关心有多少，我们只希望循环作用于所有书籍。
for和foreach之间的简单区别

  for loop is working with values.it must have condition then increment and intialization also.you have to knowledge about 'how many times loop repeated'.

 foreach is working with objects and enumaretors. no need to knowledge how many times loop repeated.

foreach几乎等同于：

var enumerator = list.GetEnumerator();
var element;
while(enumerator.MoveNext()){
  element = enumerator.Current;
}

为了实现与“foreach”兼容的模式，需要提供一个类，该类具有一个方法GetEnumerator（），该方法返回一个对象，该对象具有一个MoveNext（）方法、Reset（）方法和一个Current属性

实际上，您不需要实现IEnumerable和IEnumerator

一些衍生点：


foreach
不需要知道集合长度，因此允许迭代“流”或某种“元素生成器”
foreach
在迭代器上调用虚拟方法（大多数情况下），因此其性能不如
for
的
foreach语句为实现System.Collections.IEnumerable或System.Collections.Generic.IEnumerable接口的数组或对象集合中的每个元素重复一组嵌入语句。foreach语句用于遍历集合以获取所需的信息，但不能用于从源集合中添加或删除项以避免不可预知的副作用。如果需要从源集合中添加或删除项，请使用for循环。
这取决于您正在执行的操作和需要的内容

如果您正在迭代一组项，而不关心索引值，那么foreach更方便、更易于编写且更安全：您不会得到错误的项数

例如，如果您需要处理集合中的每一个第二项，或者按相反的顺序处理它们，那么for循环是唯一实用的方法

最大的区别在于foreach循环依次处理集合中每个元素的实例，而for循环可以处理任何数据，并且不限于集合元素。这意味着for循环可以修改一个集合-这是非法的，并且将
int sum = 0;
for (int i = 0; i <= 10; i = i + 2)
    sum = sum + i;

int i = 65;
for (string s = string.Empty; s != "ABC"; s = s + Convert.ToChar(i++).ToString()) ;
    Console.WriteLine(s);

  for loop is working with values.it must have condition then increment and intialization also.you have to knowledge about 'how many times loop repeated'.

 foreach is working with objects and enumaretors. no need to knowledge how many times loop repeated.

var enumerator = list.GetEnumerator();
var element;
while(enumerator.MoveNext()){
  element = enumerator.Current;
}

int[] test = { 0, 1, 2, 3, ...};

int[][] test = {{1,2,3,4},
                {5,2,6,5,8}};

class Program
{

    static void Main(string[] args)
    {
        List<TestClass> lst = new List<TestClass>();
        for (int i = 1; i <= 10000000; i++)
        {
            TestClass obj = new TestClass() {
                ID = i,
                Name = "Name" + i.ToString()
            };
            lst.Add(obj);
        }

        DateTime start = DateTime.Now;
        foreach (var obj in lst)
        {
            //obj.ID = obj.ID + 1;
            //obj.Name = obj.Name + "1";
        }
        DateTime end = DateTime.Now;
        var first = end.Subtract(start).TotalMilliseconds;

        start = DateTime.Now;
        for (int j = 0; j<lst.Count;j++)
        {
            //lst[j].ID = lst[j].ID + 1;
            //lst[j].Name = lst[j].Name + "1";
        }
        end = DateTime.Now;
        var second = end.Subtract(start).TotalMilliseconds;
    }
}

public class TestClass
{
    public long ID { get; set; }
    public string Name { get; set; }
}

public class ConcurrentModification {
    public static void main(String[] args) {
        List<String> str = new ArrayList<>();

        for(int i=0; i<1000; i++){
            str.add(String.valueOf(i));
        }

        /**
         * this for loop is fail-safe. It goes into infinite loop but does not fail. 
         */
        for(int i=0; i<str.size(); i++){
            System.out.println(str.get(i));
            str.add(i+ "  " + "10");
        }

        /**
         * throws ConcurrentModificationexception 
        for(String st: str){
            System.out.println(st);
            str.add("10");
        }
        */

        /* throws ConcurrentModificationException 
         Iterator<String> itr = str.iterator();
        while(itr.hasNext()) {
            System.out.println(itr.next());
            str.add("10");
        }*/
    }
} 

List<string> myStrlist = new List<string>() { "Sachin", "Ganguly", "Dravid" };
              foreach(string item in myStrlist)

              {

                  item += " cricket"; // ***Not Possible*** 

              }