C# 最轻量级的.NET集合

我想知道.NET中的集合实现有什么区别

例如，我经常使用

List

等来存储项目列表。不过，我只需要一个物品容器，我想我并不需要

List

所具有的所有功能。我只需要一个容器，它具有put方法，并允许客户端代码在容器上迭代

---

是否有更快、更轻量级的集合实现在.NET中实现了

IEnumerable

？

您在集合中存储了什么？如果它是一种类型（

T

），那么

List

是您的最佳选择

对于非泛型类型，考虑使用<代码> HasStuts，它们可以在某些情况下显著提高性能。

---

正如@RuneFS所说，正如您要求迭代和put。迭代哈希集等于迭代列表，但是将对象添加到哈希集比将其添加到列表要慢（比较哈希），并且在功能上也不等效（哈希集中的不同哈希）。

实现

IEnumerable

的最轻量级容器是类型化数组。它没有

Add

方法（因此不会像列表那样动态调整大小），但如果您知道需要预先调整多少个元素，则可以定义数组并在给定位置插入元素

var myArray = new int[10];
myArray[0] = 123;
myArray[1] = 234;

---

如果你只需要添加和迭代，我相信链表是最轻量级的。我还没有看过Stack put的实现，创建一个不占用太多空间的应用程序相当容易。这是一个相当幼稚的解决方案，可以根据大小进行优化。我的观点是，实现leightweight集合很简单

public class Stack<T>{
   readonly T _head;
   readonly Stack<T> _tail;
   public Stack(T head,Stack<T> tail){
       _head = head;
       _tail = tail;
   }

   public Stack<T> Push(T element){
       return new Stack<T>(element,this);
   }

   public IEnumerator<T> GetEnumerator(){
         yield return _head;
         var current = _tail;
         while(_tail != null){
             yield return current._head;
             current = current._tail;
         }
   }
}

公共类堆栈{
只读T_头；
只读栈尾；
公共烟囱（T形封头、烟囱尾部）{
_头=头；
_尾=尾；
}
公共堆栈推送（T元素）{
返回新堆栈（元素，此）；
}
公共IEnumerator GetEnumerator（）{
收益率-收益率头；
无功电流=_尾；
while（_tail！=null）{
产生回流电流。_头；
电流=电流；
}
}
}

性能因为这比使用预分配数组的实现要慢，因为分配给元素比新建一个新对象要快，并且取决于内部数组的填充程度。例如，列表实际上可能会占用更多的空间，但通过每次只使用还有一个元素，但它在性能方面具有显著的开销。您还可以选择在两者之间保持平衡，在大多数情况下，您可以为大量新元素保留足够的空间，这会过度分配内存，但在大多数情况下会提高性能

public class Stack<T>{
   T[] _heads;
   T[] _tail;
   int _next;
   public Stack(T head,T[] tail){
       _heads = new T[tail.length];
       _next = _heads.Length -2; 
       _heads[_heads.Length -1] = head;
       _tail = tail;
   }

   public void Push(T element){
        if(_next < 0){
            var length = _heads.Length;
            var _new = new T[length * 2];
            _heads = new T[length * 2];                
            _next = length * 2-1;
            Array.Copy(_heads,_new,length);
            Array.Copy(_tails,0,_new,length,length);
            _tails = _new;
        } else{
            _heads[_next--] = element;
        }
   }

   public IEnumerator<T> GetEnumerator(){
         yield return _head;
         var current = _tail;
         while(_tail != null){
             yield return current._head;
             current = current._tail;
         }
   }
}

公共类堆栈{
T[]_头；
T[]_尾；
int_next；
公共堆栈（T头，T[]尾）{
_头部=新T[尾部长度]；
_next=_heads.Length-2；
_头部[_heads.Length-1]=头部；
_尾=尾；
}
公共无效推送（T元素）{
如果（_next<0）{
变量长度=_heads.length；
var_new=新的T[长度*2]；
_头=新T[长度*2]；
_next=长度*2-1；
数组.Copy（_heads，_new，length）；
复制（_tails，0，_new，length，length）；
_尾巴=新的；
}否则{
_头[_next--]=元素；
}
}
公共IEnumerator GetEnumerator（）{
收益率-收益率头；
无功电流=_尾；
while（_tail！=null）{
产生回流电流。_头；
电流=电流；
}
}
}

您基本上回到了列表等集合所具有的平衡。它构建在一个内部阵列上，该阵列通常太大，无法在不浪费太多内存的情况下进行高速添加

---

因此，对于所有优化问题，这实际上取决于您希望优化什么。如果您愿意牺牲性能，您通常可以优化内存，反之亦然

您是否有迹象表明

列表的权重在您的程序中有问题？没有：），但我只是想知道。最近我在采访中遇到了一个问题：在.NET中存储数据集合的最轻量级/最快速的etc方式是什么：）@dragofly真正的答案是：这真的很重要吗？我是否处于这样一种情况：一个人需要远远超越其他人？如果答案是肯定的，那么可能级别稍微低一点会更好。所以你只需要
Add
方法，而不需要搜索、按索引访问？这些问题让我很恼火，它们通常表明高级开发人员自负过度。在99.9%的情况下，哪种重量最轻并不重要，如果你达到最高速度，需要5分钟的研究才能找到一个合适的答案。什么是“通用类型”？？
列表中的
T
就是您想要存储在其中的任何类型，可以是
int
、
字符串
或
个人
！泛型类型是您创建的任何类型：）如
Person
：b但为什么只针对非泛型类型？对于泛型类型，我建议使用
HashSet
@AndrewBarber是的，我已经清理了：）我自己不满意！OP代表迭代和put。迭代哈希集等于（ish）迭代列表，但是将对象添加到哈希集比将其添加到列表慢（比较哈希值），并且在功能上也不等效（哈希集中的不同哈希值），虽然它不会动态调整大小，但您必须指定数组的大小，因此，这意味着它通常会保留比所需更多的内存。在这里，我认为这是对愚蠢的面试问题的技术正确答案，假设你有正确的大小。：）@mattytommo所有的收藏品也是如此。列表在内部使用数组。如果那是