Convertir StringCollection de List<String>

Normalement, je choisirais List<String> [ou, en VB, List(Of String)] sur StringCollection chaque fois que possible: voir aussi Meilleure chaîne de conteneur.

Cependant, comme il semble, de génériques et, par conséquent, List<String> — sont apparemment pas pris en charge dans VS 2008 les paramètres de concepteur. Donc, si je veux utiliser une liste de chaînes dans mes paramètres de l'utilisateur, j'ai du avoir recours à l'aide d'un StringCollection là.

Maintenant que je ne veux pas voir StringCollection tout au long de mon code, j'ai besoin de les convertir à List<String>. Comment puis-je le faire efficacement? Ou, mieux encore, suis-je dans l'erreur et il y a un moyen d'utiliser List<String> dans les paramètres de designer?

EDIT: j'ai à utiliser .NET 2.0.

InformationsquelleAutor CarstenK | 2009-05-10
  1. 16

    Si vous ont à utiliser .NET 2.0, j'imagine que le cleanliest option serait de créer un wrapper pour StringCollection qui implémente IEnumerable<string> et IEnumerator<string> pour StringCollection et StringEnumerator respectivement. (note: selon les métadonnées, StringEnumerator ne pas mettre en œuvre IEnumerator). L'échantillon ci-dessous. Cependant, à la fin de la journée, quelqu'un, quelque part va faire un foreach() sur le StringCollection, donc on pourrait valoir qu'un simple foreach(string item in stringCollection) et en ajoutant à la List<string> suffirait; je doute que cela ne serait pas performat suffisant pour vos besoins.

    Vous pourriez également mettre en œuvre IList<string> à l'aide de cette approche ainsi, vous éviter de dupliquer les sous-jacents des chaînes, mais vous aurez à payer une pénalité d'avoir le "wrapper" type de déléguer des appels (un de plus un appel de méthode sur la pile!). Je vous suggère de traiter les choses en termes d'interfaces au sein de votre système de toute façon IEnumberable<string>, IList<string> etc, plutôt que sur le béton de la Liste, il vous guide sur le chemin à une plus grande flexibilité.

        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(); 
}
}
    InformationsquelleAutor Phil Price
  2. 105

    Conversion StringCollection à List<string> est merveilleusement simple si vous êtes en utilisant .NET 3.5.

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

    Concernant votre deuxième question, j'ai l'air de se rappeler qu'il est possible d'utiliser List<string> dans les paramètres designer de Visual Studio. Si vous sélectionnez personnalisé, tapez le navigateur de l'idéal type, il devrait fonctionner. Cependant, je ne pouvais être trompé sur ça, donc je vais avoir besoin de le vérifier.

    • Si la performance est un sujet de préoccupation, j'ai choisi de Fonte au lieu de OfType, juste pour éviter le type de test que OfType est la scène. Nous savons tous les cas sont de type string. De toute façon, cela peut être négligeable.
    • Ouais, vous avez probablement raison sur ce, si en effet il devrait être négligeable dans la plupart des situations. L'appel de OfType plutôt que de Cast est vraiment nécessaire quand vous avez affaire avec des collections de types différents de toute façon. (Je ne sais pas si vous vous êtes rendu compte que j'avais juste mis à jour la réponse peu de temps avant votre commentaire, de toute façon, précisément pour cette raison.)
    • Non, vous ne pouvez pas entrer List<string> dans les Réglages: je l'ai juste essayé. "Personnalisée" n'est pas disponible dans VS2008/.Net2 et "Parcourir" ne pas le reconnaître. (oui, je suis coincé avec .NET2 pour le moment - 4.0 est sur les cartes, mais pas avant l'année prochaine)
    InformationsquelleAutor Noldorin
  3. 18

    stringCollection.Cast<string>().ToList()

    InformationsquelleAutor Tasawer Khan
  4. 5

    Pourquoi ne pas faire simple et juste itération, bien que cela et ajouter les éléments à la liste, ou ai-je mal compris quelque chose?

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

    Si vous êtes à l'aide de C# 3.0 et .NET 3.5, vous pouvez créer une liste à l'aide de 

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

    Dans l'autre sens est :

    var c = new StringCollection();
c.AddRange(new List<string>().ToArray());
    InformationsquelleAutor Jerome Laban
  6. 2

    C# 2.0

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