Question

第一个问题是关于如何保护我的列表不被改变（从外部删除/添加/清除等...）

有我的方式：

class Foo 
{
    public int[] MyCollection
    {
        get{ return (_myCollection==null)?null:_myCollection.ToArray();
    }
    protected List<int> _myCollection;
}

好吗？或者有更好的想法，或者可能是模式？

第二：当我用秒表测试这个解决方案时，我非常惊讶。

List -enumeration比使用施法时间的List.ToArray（）枚举慢：

List<int> myList = new List<int>();
for (int j = 0; j < 10000; j++)
{
    myList.Add(j);
}
Stopwatch sw = new Stopwatch();
sw.Start();
for (int i = 0; i < 10000; i++)
{
    //casting every iteration:
    var ROC = myList.ToArray();
    int count = 0;
    foreach (var a in ROC)
    {
        count += a;
    }
}
sw.Stop();
Console.WriteLine(sw.Elapsed);

它显示我700毫秒，

List<int> myList = new List<int>();
for (int j = 0; j < 10000; j++)
{
    myList.Add(j);
}
Stopwatch sw = new Stopwatch();
sw.Start();
for (int i = 0; i < 10000; i++)
{
    int count = 0;
    //No casting at all
    foreach (var a in myList)
    {
        count += a;
    }
}
sw.Stop();
Console.WriteLine(sw.Elapsed);

告诉我843毫秒......为什么会这样？

Answer 1

首先，如果您有两个问题，请发两个问题。我会回答你的第一个问题。

其次，考虑如何保护列表免受变异，这对您有好处。很多人都忘记了这一点，并将其内部状态暴露给了来电者。

你可以做很多事情。

1）首先不要使用可变列表。使用不可变列表。不可变列表的Add方法返回不同的列表，而不是改变当前列表。现在BCL中有新的不可变列表类。这些在空间和时间上都非常有效。

2）使用可变列表并每次复制。你已经这样做了。问题当然是它很慢并且占用了大量内存。

3）按照克劳迪奥的建议返回AsReadOnly。请注意，这只是在列表周围创建一个只读的外观;如果列表更改，则只读外观也会更改。 “只读”意味着：用户无法写入。这并不意味着它永远不会改变。此外，还有一个枚举问题，我将在（4）中解决：

4）让LINQ完成工作。 return _myCollection.Select(x=>x);并且属性属于IEnumerable<int>类型。这有两个缺点。首先，调用者只能获得前导枚举。其次，假设调用者正在对属性执行foreach，然后在循环内部执行更改列表的操作。这将导致异常;您在枚举时无法更改列表。如果你需要支持那个场景，那么（1）或（2）是你最好的选择;在那些枚举将通过快照，而不是在变异列表上。

Answer 2

对于只读集合，您可以使用List<T>.AsReadOnly()

public IList<int> MyCollection
{
   get{ return _myCollection==null  ? null : _myCollection.AsReadOnly();
}

如果有必要，为了更清楚地说明我们正在讨论只读集合，您可以像这样定义您的属性

public IReadOnlyList<int> MyCollection

Answer 3

回答问题中的第二个问题

迭代int数组vs迭代整数列表会在IL代码级别产生非常不同的输出。

迭代整数数组

  IL_0015:  ldloc.3
  IL_0016:  ldloc.s    CS$7$0001
  IL_0018:  ldelem.i4
  IL_0019:  stloc.2
  IL_001a:  ldloc.1
  IL_001b:  ldloc.2
  IL_001c:  add
  IL_001d:  stloc.1
  IL_001e:  ldloc.s    CS$7$0001
  IL_0020:  ldc.i4.1
  IL_0021:  add
  IL_0022:  stloc.s    CS$7$0001
  IL_0024:  ldloc.s    CS$7$0001
  IL_0026:  ldloc.3
  IL_0027:  ldlen
  IL_0028:  conv.i4
  IL_0029:  blt.s      IL_0015

迭代整数列表

IL_0010:  ldloca.s   CS$5$0000
IL_0012:  call       instance !0 valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator<int32>::get_Current()
IL_0017:  stloc.1
IL_0018:  ldloc.0
IL_0019:  ldloc.1
IL_001a:  add
IL_001b:  stloc.0
IL_001c:  ldloca.s   CS$5$0000
IL_001e:  call       instance bool valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator<int32>::MoveNext()
IL_0023:  brtrue.s   IL_0010

这里的关键是当使用列表时，CLR每次迭代都会执行一个类型（get_Current()对象类型为int）。这可能会导致性能问题。

C＃只读访问List＆lt;＆gt;或其他集合，或ToArray（）魔术

3 个答案: