.net 将StringCollection转换为List<；字符串>；

通常，只要有可能，我会选择

List

[或者在VB中，

List（Of String）

]而不是

StringCollection

：另请参见

然而，看起来，VS2008的设置设计器显然不支持泛型，因此，

List

。因此，如果我想在用户设置中使用字符串列表，我必须在那里使用

StringCollection

现在，由于我不想在整个代码中看到

StringCollection

，我需要将其转换为

List

。我如何有效地做到这一点？或者，更好的是，我弄错了，有一种方法可以在设置设计器中使用

List

？

---

编辑：我必须使用.NET2.0。

如果使用.NET3.5，将

StringCollection

转换为

List

非常简单

var list = stringCollection.Cast<string>().ToList();

var list=stringCollection.Cast（）.ToList（）；

关于你的第二个问题，我确实记得可以在VisualStudio的设置设计器中使用

List

。如果选择“自定义类型”，然后将浏览器切换到相应的类型，则应能正常工作。但是，我可能在这一点上弄错了，所以我需要验证它。

如果您使用的是C#3.0和.NET 3.5，您可以使用

var list = new List<string>(new StringCollection().Cast<string>());

var list=new list（new StringCollection（）.Cast（））；

另一种方法是：

var c = new StringCollection();
c.AddRange(new List<string>().ToArray());

var c=newstringcollection（）；
c、 AddRange（新列表（）.ToArray（））；

为什么不保持它的简单性，只需迭代它并将项目添加到列表中，或者我误解了什么

public static List<string> Convert(StringCollection collection)
{
    List<string> list = new List<string>();
    foreach (string item in collection)
    {
        list.Add(item);
    }
    return list;
}

公共静态列表转换（StringCollection集合）
{
列表=新列表（）；
foreach（集合中的字符串项）
{
列表。添加（项目）；
}
退货清单；
}

如果必须使用.NET 2.0，我认为最干净的选择是为

StringCollection

创建一个包装器，分别实现

IEnumerable

和

IEnumerator

的

StringCollection

和

StringEnumerator

。（注意：根据元数据，

StringEnumerator

不实现

IEnumerator

）。下面是示例。然而，在一天结束时，某个地方的某个人将在

StringCollection

上执行

foreach（）

，因此有人可能会认为一个简单的

foreach（StringCollection中的字符串项）

并添加到

列表中就足够了；我怀疑这不足以满足你的需要

您也可以使用这种方法实现
IList
，以避免重复底层字符串，但您将为使用“包装器”类型的委托调用（在堆栈上再调用一个方法！）付出代价。我建议您按照系统中的接口来处理问题，不管怎样，
IEnumberable
，
IList
等等，而不是具体的列表，它将引导您走向更大的灵活性

    static void Main(string[] args)
    {
        StringCollection stringCollection = new StringCollection();
        stringCollection.AddRange(new string[] { "hello", "world" });

        // Wrap!
        List<string> listOfStrings = new List<string>(new StringCollectionEnumerable(stringCollection));

        Debug.Assert(listOfStrings.Count == stringCollection.Count);
        Debug.Assert(listOfStrings[0] == stringCollection[0]); 

    }

    private class StringCollectionEnumerable : IEnumerable<string>
    {
        private StringCollection underlyingCollection; 

        public StringCollectionEnumerable(StringCollection underlyingCollection)
        {
            this.underlyingCollection = underlyingCollection; 
        }

        public IEnumerator<string> GetEnumerator()
        {
            return new StringEnumeratorWrapper(underlyingCollection.GetEnumerator()); 
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return this.GetEnumerator(); 
        }
    }

    private class StringEnumeratorWrapper : IEnumerator<string>
    {
        private StringEnumerator underlyingEnumerator; 

        public StringEnumeratorWrapper(StringEnumerator underlyingEnumerator)
        {
            this.underlyingEnumerator = underlyingEnumerator;
        }

        public string Current
        {
            get
            {
                return this.underlyingEnumerator.Current; 
            }
        }

        public void Dispose()
        {
            // No-op 
        }

        object System.Collections.IEnumerator.Current
        {
            get
            {
                return this.underlyingEnumerator.Current;
            }
        }

        public bool MoveNext()
        {
            return this.underlyingEnumerator.MoveNext(); 
        }

        public void Reset()
        {
            this.underlyingEnumerator.Reset(); 
        }
    }

static void Main（字符串[]args）
{
StringCollection StringCollection=新建StringCollection（）；
AddRange（新字符串[]{“hello”，“world”}）；
//包装！
List listOfStrings=新列表（新StringCollectionEnumerable（stringCollection））；
Assert（listOfStrings.Count==stringCollection.Count）；
Assert（listOfStrings[0]==stringCollection[0]）；
}
私有类StringCollectionEnumerable:IEnumerable
{
私人藏品藏于藏品之下；
公共StringCollectionEnumerable（StringCollection underyingCollection）
{
this.underyingcollection=underyingcollection；
}
公共IEnumerator GetEnumerator（）
{
返回新的StringEnumeratorWrapper（underyingCollection.GetEnumerator（））；
}
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator（）
{
返回此.GetEnumerator（）；
}
}
私有类StringEnumeratorWrapper:IEnumerator
{
私有StringEnumerator位于Enumerator之下；
公共StringEnumeratorWrapper（StringEnumerator下的StringEnumerator）
{
this.underyingEnumerator=underyingEnumerator；
}
公共字符串电流
{
得到
{
返回this.underyingEnumerator.Current；
}
}
公共空间处置（）
{
//无操作
}
对象System.Collections.IEnumerator.Current
{
得到
{
返回this.underyingEnumerator.Current；
}
}
公共图书馆
{
返回此.UnderlineEnumerator.MoveNext（）；
}
公共无效重置（）
{
此.underyingEnumerator.Reset（）；
}
}
stringCollection.Cast（）.ToList（）

C#2.0

StringCollection colString=new StringCollection（）；
string[]arrString=新字符串[colString.Count]；
colString.CopyTo（arrString，0）；
List lstString=新列表（arrString）；

如果性能是一个问题，我会选择Cast而不是OfType，只是为了避免OfType正在执行的类型测试。我们知道所有实例都是string类型。无论如何，这可能是可以忽略不计的。@Jerome:是的，你可能是对的，尽管在大多数情况下，这确实应该是可以忽略不计的。只有在处理混合类型的集合时，才真正需要调用type而不是Cast。（不确定你是否意识到我在你发表评论前不久就更新了答案，正是因为这个原因。）不，你不能在设置中输入列表：我刚刚尝试过。“自定义”在VS2008/.Net2中不可用，“浏览”无法识别。（是的，我暂时无法使用.NET2-4.0，但要到明年才能使用）

StringCollection colString = new StringCollection();
string[] arrString = new string[colString.Count];
colString.CopyTo(arrString, 0);
List<string> lstString = new List<string>(arrString);