Modo preferito per creare una nuova sequenza IEnumerable <T> da un singolo valore?

97

Di solito creo una sequenza da un singolo valore utilizzando la sintassi dell'array, in questo modo:

IEnumerable<string> sequence = new string[] { "abc" };

O utilizzando un nuovo elenco. Mi piacerebbe sapere se qualcuno ha un modo più espressivo per fare la stessa cosa.

c# linq c#-3.0

— Marcel Lamothe
fonte

3

Come è una sequenza vuota?

— CoderDennis

È semplicemente imbarazzante che dotnet non abbia ancora qualcosa di simile Enumerable.From<T>(params T[] items).

— Good Night Nerd Pride

144

Il tuo esempio non è una sequenza vuota, è una sequenza con un elemento. Per creare una sequenza vuota di stringhe puoi fare

var sequence = Enumerable.Empty<string>();

EDIT OP ha chiarito che stavano cercando di creare un unico valore. In quel caso

var sequence = Enumerable.Repeat("abc",1);

— JaredPar
fonte

D'oh, mi sono distratto, scusa. Intendevo creare da un singolo valore, non creare un'istanza vuota!

— Marcel Lamothe,

Questa è 'la risposta' flag it?

— n8wrl

Questo metodo è più puramente funzionale rispetto alla creazione di un nuovo array.

— Roy Tinker

69

Mi piace quello che suggerisci, ma con il tipo di array omesso:

var sequence = new[] { "abc" };

— Bryan Watts
fonte

4

Non ho mai capito che potresti farlo. Penso che questo sia più chiaro rispetto all'uso di Repeat.

— Marcel Lamothe,

1

Ma questo non è un IEnumerable, è un array!

— Zodman

4

@Bryan Watts Lo so, ma è un'implementazione concreta di IEnumerable. La domanda sta chiedendo un IEnumerable <> (anche se l'esempio non lo è). C'è una differenza.

— Zodman

Forse la domanda dovrebbe essere cambiata.

— Zodman

1

@ Jonesopolis: Questa è una situazione diversa e non correlata. Puoi usare Task.FromResultper ottenere quello.

— Bryan Watts

21

O anche più breve,

string[] single = { "abc" };

Vorrei creare un metodo di estensione:

public static T[] Yield<T>(this T item)
{
    T[] single = { item };
    return single;
}

O anche meglio e più breve, solo

public static IEnumerable<T> Yield<T>(this T item)
{
    yield return item;
}

Forse questo è esattamente ciò che Enumerable.Repeatsta facendo sotto il cofano.

— nawfal
fonte

1

L'ultimo è geniale. Fatta eccezione per il nome ... entrerà in conflitto con i tipi che implementano già IEnumerable come la stringa nel tuo esempio. Prova .AsSingleItemEnumerable () o semplicemente .Yield () -> "abc" .Yield ()

— DanO

7

Penso che ToEnumerable sia più appropriato.

— Zodman

2

+1 Yieldè buono. Anch'io l'ho fatto IEnumerable<T> Yield<T>(this T source, params T[] others).

— Jodrell

Ho provato a farla finita con Yield del tutto a favore di un lambda ma in qualche modo non è mai stato compilato ... cfr. stackoverflow.com/questions/1217729/… ;-).

— Peter - Ripristina Monica il

@PeterSchneider come e perché l'hai fatto? Senza vedere il codice non posso commentare. Non credo di seguirti.

— nawfal

5

o semplicemente creare un metodo

public static IEnumerable<T> CreateEnumerable<T>(params T[] items)
{
    if(items == null)
        yield break;

    foreach (T mitem in items)
        yield return mitem;
}

o

public static IEnumerable<T> CreateEnumerable<T>(params T[] items)
{
   return items ?? Enumerable.Empty<T>();
}

utilizzo:

IEnumerable<string> items = CreateEnumerable("single");

— Andrea
fonte