¿Hay una forma común de pasar un solo elemento de tipo T
a un método que espera un IEnumerable<T>
parámetro? El lenguaje es C #, framework versión 2.0.
Actualmente estoy usando un método auxiliar (es .Net 2.0, así que tengo un montón de métodos auxiliares de proyección / proyección similares a LINQ), pero esto parece una tontería:
public static class IEnumerableExt
{
// usage: IEnumerableExt.FromSingleItem(someObject);
public static IEnumerable<T> FromSingleItem<T>(T item)
{
yield return item;
}
}
Otra forma sería, por supuesto, crear y completar una List<T>
o una Array
y pasarla en lugar de IEnumerable<T>
.
[Editar] Como método de extensión podría llamarse:
public static class IEnumerableExt
{
// usage: someObject.SingleItemAsEnumerable();
public static IEnumerable<T> SingleItemAsEnumerable<T>(this T item)
{
yield return item;
}
}
¿Me estoy perdiendo de algo?
[Edit2] Encontramos someObject.Yield()
(como @Peter sugirió en los comentarios a continuación) el mejor nombre para este método de extensión, principalmente por brevedad, así que aquí está junto con el comentario XML si alguien quiere obtenerlo:
public static class IEnumerableExt
{
/// <summary>
/// Wraps this object instance into an IEnumerable<T>
/// consisting of a single item.
/// </summary>
/// <typeparam name="T"> Type of the object. </typeparam>
/// <param name="item"> The instance that will be wrapped. </param>
/// <returns> An IEnumerable<T> consisting of a single item. </returns>
public static IEnumerable<T> Yield<T>(this T item)
{
yield return item;
}
}
Yield
? Nada supera la brevedad.
left==null
cheque aquí. Rompe la belleza del código y evita que el código sea más flexible: ¿qué pasa si algún día resulta que necesitas generar un singleton con algo que puede ser nulo? Quiero decir, new T[] { null }
no es lo mismo que new T[] {}
, y algún día puede que necesites distinguirlos.
if (item == null) yield break;
ahora se le impide pasar nulo y aprovechar el patrón de objeto nulo (trivial)IEnumerable
. (foreach (var x in xs)
maneja un vacíoxs
muy bien). Por cierto, esta función es la unidad monádica de la mónada de la listaIEnumerable<T>
, y dado el festival de amor de la mónada en Microsoft, me sorprende que algo así no esté en el marco en primer lugar.