it-swarm.com.de

Verknüpfung zum Erstellen einer einzelnen Artikelliste in C #

In C # gibt es eine Inline-Verknüpfung, mit der eine Liste <T> mit nur einem Element instanziiert werden kann.

Ich mache gerade:

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

Wenn Sie diesen Code überall haben, ist die Lesbarkeit eingeschränkt. Ich habe mir überlegt, eine Utility-Methode wie diese zu verwenden:

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

Also könnte ich tun:

SingleItemList("title");

Gibt es einen kürzeren/saubereren Weg?

Vielen Dank.

119
Ryan Ische

Benutze einfach folgendes:

List<string> list = new List<string>() { "single value" };

Sie können sogar die () Klammern weglassen:

List<string> list = new List<string> { "single value" };

Update: Das funktioniert natürlich auch bei mehreren Einträgen:

List<string> list = new List<string> { "value1", "value2", ... };
219
M4N
var list = new List<string>(1) { "hello" };

Sehr ähnlich dem, was andere veröffentlicht haben, mit der Ausnahme, dass zunächst nur Platz für den einzelnen Artikel reserviert wird.

Natürlich, wenn Sie wissen, dass Sie später ein paar Dinge hinzufügen werden, ist es vielleicht keine gute Idee, aber es lohnt sich immer noch, einmal darauf einzugehen.

35
Joel Coehoorn

Michaels Idee, Erweiterungsmethoden zu verwenden, führt zu etwas noch Einfacherem:

public static List<T> InList<T>(this T item)
{
    return new List<T> { item };
}

So könnten Sie dies tun:

List<string> foo = "Hello".InList();

Ich bin mir nicht sicher, ob es mir gefällt oder nicht, wohlgemerkt ...

25
Jon Skeet

Eine andere Antwort als meine frühere, basierend auf der Exposition gegenüber den Google Java Collections :

public static class Lists
{
    public static List<T> Of<T>(T item)
    {
        return new List<T> { item };
    }
}

Dann:

List<string> x = Lists.Of("Hello");

Ich rate zum Auschecken im GJC - es enthält viele interessante Dinge. (Ich persönlich würde das "alpha" -Tag ignorieren - es ist nur die Open Source-Version, die "alpha" ist und auf einer sehr stabilen und stark genutzten internen API basiert .)

16
Jon Skeet

Verwenden Sie eine Erweiterungsmethode mit Methodenverkettung.

public static List<T> WithItems(this List<T> list, params T[] items)
{
    list.AddRange(items);
    return list;
}

Damit können Sie Folgendes tun:

List<string> strings = new List<string>().WithItems("Yes");

oder

List<string> strings = new List<string>().WithItems("Yes", "No", "Maybe So");

Update

Sie können jetzt Listeninitialisierer verwenden:

var strings = new List<string> { "This", "That", "The Other" };

Siehe http://msdn.Microsoft.com/en-us/library/bb384062 (v = vs.90) .aspx

7
Michael Meadows
new[] { "item" }.ToList();

Es ist kürzer als

new List<string> { "item" };

und Sie müssen den Typ nicht angeben.

Noch ein anderer Weg, gefunden auf C # /. Net Little Wonders :

Enumerable.Repeat("value",1).ToList()
5

Ich würde es einfach tun

var list = new List<string> { "hello" };
2
Brian Rasmussen

Für ein einzelnes in Java) aufzählbares Element wäre es Collections.singleton ("string");

In c # wird dies effizienter sein als eine neue 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;
    }
}

aber gibt es eine einfachere Möglichkeit, das Framework zu verwenden?

2
Squirrel

Ich habe diese kleine Funktion:

public static class CoreUtil
{    
    public static IEnumerable<T> ToEnumerable<T>(params T[] items)
    {
        return items;
    }
}

Da es keinen konkreten Rückgabetyp vorschreibt, ist dieser so allgemein gehalten, dass ich ihn überall verwende. Ihr Code würde so aussehen

CoreUtil.ToEnumerable("title").ToList();

Aber natürlich erlaubt es auch

CoreUtil.ToEnumerable("title1", "title2", "title3").ToArray();

Ich benutze es oft, wenn ich ein Element an die Ausgabe einer LINQ-Anweisung anhängen/voranstellen muss. So fügen Sie beispielsweise einer Auswahlliste ein leeres Element hinzu:

CoreUtil.ToEnumerable("").Concat(context.TrialTypes.Select(t => t.Name))

Speichert einige Anweisungen ToList() und Add.

(Späte Antwort, aber ich bin über diesen Oldie gestolpert und dachte, das könnte hilfreich sein.)

2
Gert Arnold

Versuchen Sie var

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

Inspiriert von den anderen Antworten (und so kann ich sie abholen, wann immer ich sie brauche!), Aber mit Benennung/Stil, der an F # ausgerichtet ist (das hat eine Standardfunktion singleton pro Datenstruktur *):

namespace System.Collections.Generic
{
    public static class List
    {
        public static List<T> Singleton<T>(T value) => new List<T>(1) { value };
    }
}

* außer natürlich ResizeArray selbst, daher diese Frage :)


In der Praxis nenne ich es tatsächlich Create, um mich mit anderen von mir definierten Helfern auszurichten, wie Tuple.Create , Lazy.Create [2], LazyTask.Create 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);
    }
}
1
Ruben Bartelink

Sie können auch tun

new List<string>() { "string here" };
1
Rune Grimstad