众所周知教科书上对于foreach之中的注释是在遍历过程中无法改变其遍历的元素
例如声明一个数组
int[] ii={,,,};
foreach(int m in ii){
m = ;//错误 “m”是一个“foreach 迭代变量”，无法为它赋值
Console.WriteLine(m);
}
由上面可以知道，我们无法改变数组里面的值，但是foreach语句是为了集合而创建的，数组只是集合的一种，而其他集合会是怎么样的呢？
C#里面为我们创建好了好几个集合类，List<T> ,Array等都是集合，现在我们就使用List<T>作为集合来验证我们的想法，现在我们来创建一个类型声明为Product类。
public class Product
{
public int Id { set; get; }
public string Name { set; get; }
public string Code { set; get; }
public String Category { get; set; }
public decimal Price { get; set; }
public DateTime ProductDate { get; set; }
public override string ToString()
{
return String.Format("{0}{1}{2}{3}{4}{5}", this.Id.ToString().PadLeft(), this.Name.PadLeft(), this.Code.PadLeft(), this.Category.PadLeft(), this.Price.ToString().PadLeft(), this.ProductDate.ToString("yyyy-M-d").PadLeft());
} }
在这个类里面我们重写了ToString方法以便我们能更好看到输出结果。
现在我们声明一个实例。
Product pr = new Product();
pr.Id = 1;
pr.Name = "肥皂";
pr.Price = 1M; pr.ProductDate = DateTime.Parse("2015-02-14");
pr.Code = "0001";
pr.Category = "日用品";
将pr加入到集合List中
List<Product> list = new List<Product>();
list.Add(pr);
然后我们遍历它
foreach (Product prd in list)
{
Console.WriteLine(prd.ToString());
}
输出结果是
Id 商品名 产品代号 种类 价格 生产日期
0 肥皂 0001 日用品 1 2015-2-14
我们尝试在遍历修改一下迭代变量
foreach (Product prd in list)
{
Console.WriteLine(prd.ToString());
}
foreach (Product prd in list)
{
prd.Id = 2; Console.WriteLine(prd.ToString()); }
输出结果是
Id 商品名 产品代号 种类 价格 生产日期
0 肥皂 0001 日用品 1 2015-2-14
2 肥皂 0001 日用品 1 2015-2-14
修改成功了，成功改变了迭代变量的元素，我们此时将pr.Id输出发现pr的Id也被修改成2了，这是为什么了？
我们修改prd的元素不但没报错，还改变了原始值。难道是因为我们修改的是prd.Id而不是prd所以我们成功了吗？
那好我们再次修改将Product类修改成为一个结构（将public class Product成 public struct Product）。再次运行上面的代码，发现连编译都通过不了。显示““prd”是一个“foreach 迭代变量无法为它赋值””。
现在来通过分析集合类的结构来解释这个问题，集合类如果要使用foreach方法必须包含“GetEnumerator”的公共定义，而该方法的返回值是一个Enmerator<T>，用通俗的话来讲就是一个结合类要调用这个foreach方法C#要求它能得到一个枚举器，这个枚举器是一个类型，他必须要有 bool MoveNext()方法， T Current返回T类型的一个属性， void Reset()方法。我们每次使用foreach方法，都要调用这个枚举器类型的方法，我们使用Current属性返回当前迭代的变量，因为Current属性只有get方法所以只能得到Product的实例里面的值，当我们想给迭代变量赋值时就会报错，因为我们没有set方法。但是为什么我们却可以修改Product类中字段，而不可修改Product结构中的字段呢？这里牵涉到值类型和引用类型在内存中存贮的差异，简单来说，我们在堆上如果存在两个变量，一个是值类型，一个是引用类型，当我们对值类型变量（也就是结构）做出prd.Id时，我们现在的位置还是在堆上这个值类型实例的位置，我们如果只有get方法只能得到其值无法修改，但是如果我们是一个引用类型，当我们对引用类型实例（也就是类）做出prd.Id时，因为引用类型变量存贮的只是一个地址，我们prd.Id的位置会直接转移到实例的字段，而不是这个变量上面，所以我们使用prd.Id并不是得到迭代变量，而是得到迭代变量的实例上面。
仔细想想其实这就是因为一个引用类型A的成员如果包含了值类型成员B和引用类型成员C时，这个A类型的实例，如果要阻止修改A类型实例a，那么a里面值类型B的实例b不能修改，因为b就贮存在a里面，而a里面引用类型C的实例c却可以修改，因为a里面就贮存了实例c的地址，修改实例c里面的内容并不会修改a里面实例c的地址。
下面是product的集合类productCollection的代码，代码出自前辈张子阳的博客。大家感兴趣可以了解一下。
#region product集合类型
public class ProductCollection : IEnumerable<Product>
{
//使用哈希表存贮Product
private Hashtable table; /// <summary>
/// 构造函数可以添加Product类实例
/// </summary>
/// <param name="array">Product实例</param>
public ProductCollection(params Product[] array)
{
table = new Hashtable();
foreach (Product pp in array)
{
this.Add(pp);
}
} /// <summary>
/// 索引器
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
public Product this[int index]
{
get
{
string selected = getKey(index);
return table[selected] as Product; }
set
{
string selected = getKey(index);
table[selected] = value; } } public Product this[string key]
{
get
{
String selected = getKey(key);
return table[selected] as Product;
}
set
{
string selected = getKey(key);
table[selected] = value;
} }
private string getKey(int index)
{
if (index < || index >= table.Count)
{
throw new Exception("索引超过范围！"); }
int i = ;
string selected = "";
foreach (string item in table.Keys)
{
if (i == index)
{
selected = item;
break;
}
i++; }
return selected;
} private string getKey(string key)
{
foreach (string k in table.Keys)
{
if (key == k) return k;
}
throw new Exception("不存在该键值");
}
public void Add(Product item)
{
foreach (string key in table.Keys)
{
if (key == item.Code)
{
throw new Exception(item.Code + "产品代码不能重复");
}
}
table.Add(item.Code, item);
}
public int Count
{
get
{
return table.Count;
}
} public void Insert(int index, Product item)
{ }
public void Remove(Product item)
{ }
/// <summary>
/// 返回一个枚举器
/// </summary>
/// <returns>枚举器</returns> public IEnumerator<Product> GetEnumerator()
{
return new ProductEnumerator(this);
}
IEnumerator IEnumerable.GetEnumerator()
{
return new ProductEnumerator(this);
}
public class ProductEnumerator : IEnumerator<Product>
{ public readonly ProductCollection collection;
private int index;
public ProductEnumerator(ProductCollection collection)
{
this.collection = collection; index = -;
}
public Product Current
{
get
{
return collection[index];
} }
object IEnumerator.Current
{
get
{
return collection[index];
} }
public bool MoveNext()
{
index++;
if (index >= collection.Count)
{
return false; }
else return true;
}
public void Reset()
{
index = -;
}
public void Dispose()
{ } }
} #endregion