Raccourci pour créer seul élément de la liste en C#

En C#, est-il une ligne de raccourci pour instancier une Liste<T> avec un seul élément.

Je suis actuellement en train de faire:

new List<string>( new string[] { "title" } ))

Avoir ce code partout réduit la lisibilité. J'ai pensé à l'aide d'un utilitaire méthode comme ceci:

public static List<T> SingleItemList<T>( T value )
{
    return (new List<T>( new T[] { value } ));
}

Si je pouvais faire:

SingleItemList("title");

Est-il plus court /moyen le plus propre?

Grâce.

InformationsquelleAutor Ryan Ische | 2009-01-20

215

Simplement utiliser ce:
```
List<string> list = new List<string>() { "single value" };
```
Vous pouvez omettre l' () accolades:
```
List<string> list = new List<string> { "single value" };
```
Mise à jour: bien sûr, cela fonctionne aussi pour les plus d'une entrée:
```
List<string> list = new List<string> { "value1", "value2", ... };
```
- mettre un 1 littérale dans les parenthèses de la première option, de sorte que le stockage pour exactement un espace est alloué plutôt que la valeur par défaut de 10
- La valeur par défaut finit par être 4, je crois: new List<string> { "Bonjour" }.Capacité == 4
InformationsquelleAutor M4N
34
```
var list = new List<string>(1) { "hello" };
```
Très similaire à ce que d'autres ont posté, sauf qu'il fait certain de n'allouer de l'espace pour le seul élément à l'origine.

Bien sûr, si vous savez que vous allez être l'ajout d'un tas de trucs plus tard, il peut ne pas être une bonne idée, mais il vaut la peine de mentionner une fois.
- Capacité une. J'ai voté pour les quatre réponses sur cette page, y compris à la fois de Jon Skeet, mais je les considère celui-ci pour être la plus correcte.
InformationsquelleAutor Joel Coehoorn
25

Michael idée d'utiliser des méthodes d'extension conduit à quelque chose d'encore plus simple:
```
public static List<T> InList<T>(this T item)
{
    return new List<T> { item };
}
```
De sorte que vous pourriez faire ceci:
```
List<string> foo = "Hello".InList();
```
Je ne suis pas sûr de savoir si je l'aime ou pas, que vous avez l'esprit...
- Je suis également pas sûr que je l'aime: n'est-ce pas une "étrange" extension de type chaîne de caractères (par exemple) ?
- Je n'ai pas fait ça pour les méthodes d'extension dans votre livre, pourtant, Jon 🙂 Cela ne semble étrange, mais j'aime bien l'utilité. Merci Martin et Jon.
- C'est une étrange extension de tous type. C'est généralement déconseillée, mais c'est intéressant, cette idée générale.
- Il hase à l'interne langage spécifique au domaine usages, en particulier avec des types valeur. Prenons, par exemple: l'horloge.AlertUser.Dans(1.Minutes) se lit beaucoup mieux que d'horloge.AlertUser(TimeSpan.FromMinutes(1));
InformationsquelleAutor Jon Skeet
16

Une autre réponse à ma précédente, en fonction de l'exposition à la Google Java Collections:
```
public static class Lists
{
    public static List<T> Of<T>(T item)
    {
        return new List<T> { item };
    }
}
```
Alors:
```
List<string> x = Lists.Of("Hello");
```
Je vous conseille de vérifier la GJC - il a beaucoup de choses intéressantes dans. (Personnellement, je préfère ignorer les "alpha" tag - c'est seulement la version open source qui est "alpha" et il est basé sur une très stable et très utilisé interne de l'API.)

InformationsquelleAutor Jon Skeet
7

Utiliser une extension de la méthode avec la méthode de chaînage.
```
public static List<T> WithItems(this List<T> list, params T[] items)
{
    list.AddRange(items);
    return list;
}
```
Cela vous permettrait de faire ceci:
```
List<string> strings = new List<string>().WithItems("Yes");
```
ou
```
List<string> strings = new List<string>().WithItems("Yes", "No", "Maybe So");
```
Mise à jour

Vous pouvez maintenant utiliser la liste des initialiseurs:
```
var strings = new List<string> { "This", "That", "The Other" };
```
Voir http://msdn.microsoft.com/en-us/library/bb384062(v=vs. 90).aspx
- C'est peut-être en raison de nouvelles versions de C# depuis 2009, mais je trouve new List<string> {"Yes"} à être mieux... ?
- Selon la documentation de Microsoft (msdn.microsoft.com/en-us/library/bb384062(v=vs. 90).aspx) cela a été pris en charge dans Visual Studio 2008. Je ne me souviens pas si loin en arrière pour dire définitivement si j'ai plus de complexe à ce moment. La mise à jour.
InformationsquelleAutor Michael Meadows
5
```
new[] { "item" }.ToList();
```
C'est plus courte que
```
new List<string> { "item" };
```
et vous n'avez pas à spécifier le type.

InformationsquelleAutor Waldemar Gałęzinowski
5

Encore une autre façon, trouvé sur C#/.Net petites merveilles:
```
Enumerable.Repeat("value",1).ToList()
```
- Confus, mais intelligent.
InformationsquelleAutor Grzegorz Sławecki
2

Je voudrais juste faire
```
var list = new List<string> { "hello" };
```
InformationsquelleAutor Brian Rasmussen

Pour un seul élément énumérable en java, il serait Collections.singleton("chaîne");

En c#, cela va être plus efficace que la nouvelle Liste:

public class SingleEnumerator<T> : IEnumerable<T>
{
    private readonly T m_Value;

    public SingleEnumerator(T value)
    {
        m_Value = value;
    }

    public IEnumerator<T> GetEnumerator()
    {
        yield return m_Value;
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        yield return m_Value;
    }
}

mais est-il une façon plus simple en utilisant le framework?

InformationsquelleAutor

2

J'ai un peu de fonction:
```
public static class CoreUtil
{    
    public static IEnumerable<T> ToEnumerable<T>(params T[] items)
    {
        return items;
    }
}
```
Car il ne pas prescrire un béton de type de retour c'est tellement générique que je l'utilise tous sur la place. Votre code devrait ressembler à
```
CoreUtil.ToEnumerable("title").ToList();
```
Mais bien sûr, il permet aussi
```
CoreUtil.ToEnumerable("title1", "title2", "title3").ToArray();
```
J'ai souvent l'utiliser quand j'ai à ajouter/ajouter un élément à la sortie d'une LINQ déclaration. Par exemple, pour ajouter un élément vide à une liste de sélection:
```
CoreUtil.ToEnumerable("").Concat(context.TrialTypes.Select(t => t.Name))
```
Permet d'économiser quelques ToList() et Add consolidés.

(Réponse tardive, mais je suis tombé sur cette oldie et pensé que ce pourrait être utile)

InformationsquelleAutor Gert Arnold
1

Vous pouvez également faire
```
new List<string>() { "string here" };
```
InformationsquelleAutor Rune Grimstad

Essayer var

var s = new List<string> { "a", "bk", "ca", "d" };

InformationsquelleAutor delwasaf ewrew

1

Inspiré par les autres réponses (et donc je peux le ramasser à chaque fois que j'en ai besoin!), mais avec de nommage/style aligné avec F# (qui a une norme singleton fonction par la structure de données*):
```
namespace System.Collections.Generic
{
    public static class List
    {
        public static List<T> Singleton<T>(T value) => new List<T>(1) { value };
    }
}
```
* sauf pour ResizeArray lui-même, bien sûr, d'où cette question 🙂

Dans la pratique, je fait nom il Create à s'aligner avec d'autres aides que je définir comme Tuple.Créer, Lazy.Create[2], LazyTask.Créer etc:
```
namespace System.Collections.Generic
{
    static class List
    {
        public static List<T> Create<T>(T value) => new List<T>(1) { value };
    }
}
```
[2]
```
namespace System
{
    public static class Lazy
    {
        public static Lazy<T> Create<T>(Func<T> factory) => new Lazy<T>(factory);
    }
}
```
- Merci! Ma solution. Couple de choses: (1) votre liste de mise en œuvre n'est pas public, donc il ne peut pas être utilisé en dehors de la déclaration de l'assemblée, et (2) quel est le but de la farce dans l'espace de noms System?
- raison pour mettre les Lazy extension dans System est que Lazy lui-même est en System [et donc Create apparaissent dans les compleiton listes sans using]. Il n'y a rien à gagner de forcer les gens à open un diff de l'espace de noms? Faire autre chose privée n'était pas intentionnel; fixe
InformationsquelleAutor Ruben Bartelink

Vous devez vous connecter pour publier un commentaire.