Existe uma maneira comum de passar um único item do tipo T
para um método que espera um IEnumerable<T>
parâmetro? O idioma é C #, versão 2.0 do framework.
Atualmente, estou usando um método auxiliar (é .Net 2.0, então eu tenho vários métodos auxiliares de projeção / projeção semelhantes ao LINQ), mas isso parece bobo:
public static class IEnumerableExt
{
// usage: IEnumerableExt.FromSingleItem(someObject);
public static IEnumerable<T> FromSingleItem<T>(T item)
{
yield return item;
}
}
Outra maneira, é claro, seria criar e preencher um List<T>
ou um Array
e passá-lo em vez de IEnumerable<T>
.
[Editar] Como método de extensão, ele pode ser chamado:
public static class IEnumerableExt
{
// usage: someObject.SingleItemAsEnumerable();
public static IEnumerable<T> SingleItemAsEnumerable<T>(this T item)
{
yield return item;
}
}
Estou faltando alguma coisa aqui?
[Edit2] Descobrimos someObject.Yield()
(como @ Peter sugeriu nos comentários abaixo) o melhor nome para esse método de extensão, principalmente por questões de concisão, então aqui está o comentário XML, se alguém quiser pegá-lo:
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 a brevidade.
left==null
cheque aqui. Ele quebra as belezas do código e deixa o código mais flexível - e se algum dia você descobrir que precisa gerar um singleton com algo que pode ser nulo? Quero dizer, new T[] { null }
não é o mesmo que new T[] {}
, e um dia você pode precisar distingui-los.
if (item == null) yield break;
Agora você não pode passar nulo, nem tirar proveito do padrão de objeto nulo (trivial) paraIEnumerable
. (foreach (var x in xs)
lida com um vazioxs
muito bem). Aliás, essa função é a unidade monádica da mônada da listaIEnumerable<T>
e, dada a festa de amor da mônada na Microsoft, estou surpreso que algo assim não esteja no quadro em primeiro lugar.