Passando um único item como IEnumerable <T>

Existe uma maneira comum de passar um único item do tipo Tpara 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 Arraye 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&lt;T&gt;
    /// 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&lt;T&gt; consisting of a single item. </returns>
    public static IEnumerable<T> Yield<T>(this T item)
    {
        yield return item;
    }
}

Seu método auxiliar é a maneira mais limpa de fazer isso, IMO. Se você passar uma lista ou uma matriz, um código inescrupuloso pode convertê-lo e alterar o conteúdo, levando a um comportamento estranho em algumas situações. Você pode usar uma coleção somente leitura, mas é provável que envolva ainda mais quebra automática. Eu acho que sua solução é a mais limpa possível.

Bem, se o método espera IEnumerableque você precise passar algo que é uma lista, mesmo que contenha apenas um elemento.

passagem

new[] { item }

como o argumento deve ser suficiente, eu acho

No C # 3.0, você pode utilizar a classe System.Linq.Enumerable:

// using System.Linq

Enumerable.Repeat(item, 1);

Isso criará um novo IEnumerable que contém apenas seu item.

No C # 3 (eu sei que você disse 2), você pode escrever um método de extensão genérico que pode tornar a sintaxe um pouco mais aceitável:

static class IEnumerableExtensions
{
    public static IEnumerable<T> ToEnumerable<T>(this T item)
    {
        yield return item;
    }
}

código do cliente é então item.ToEnumerable().

Este método auxiliar funciona para itens ou muitos.

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

Estou surpreso que ninguém tenha sugerido uma nova sobrecarga do método com um argumento do tipo T para simplificar a API do cliente.

public void DoSomething<T>(IEnumerable<T> list)
{
    // Do Something
}

public void DoSomething<T>(T item)
{
    DoSomething(new T[] { item });
}

Agora, seu código de cliente pode fazer isso:

MyItem item = new MyItem();
Obj.DoSomething(item);

ou com uma lista:

List<MyItem> itemList = new List<MyItem>();
Obj.DoSomething(itemList);

Qualquer um (como foi dito anteriormente)

MyMethodThatExpectsAnIEnumerable(new[] { myObject });

ou

MyMethodThatExpectsAnIEnumerable(Enumerable.Repeat(myObject, 1));

Como observação lateral, a última versão também pode ser boa se você quiser uma lista vazia de um objeto anônimo, por exemplo

var x = MyMethodThatExpectsAnIEnumerable(Enumerable.Repeat(new { a = 0, b = "x" }, 0));

Como acabei de encontrar e vi que o usuário LukeH sugeriu também, uma maneira simples e agradável de fazer isso é a seguinte:

public static void PerformAction(params YourType[] items)
{
    // Forward call to IEnumerable overload
    PerformAction(items.AsEnumerable());
}

public static void PerformAction(IEnumerable<YourType> items)
{
    foreach (YourType item in items)
    {
        // Do stuff
    }
}

Esse padrão permitirá que você chame a mesma funcionalidade de várias maneiras: um único item; vários itens (separados por vírgula); uma matriz; uma lista; uma enumeração etc.

Não tenho 100% de certeza sobre a eficiência do uso do método AsEnumerable, mas funciona muito bem.

Atualização: A função AsEnumerable parece bastante eficiente! ( referência )

Embora seja um exagero para um método, acredito que algumas pessoas possam achar úteis as extensões interativas.

As extensões interativas (Ix) da Microsoft incluem o seguinte método.

public static IEnumerable<TResult> Return<TResult>(TResult value)
{
    yield return value;
}

Que pode ser utilizado assim:

var result = EnumerableEx.Return(0);

Ix adiciona nova funcionalidade não encontrada nos métodos de extensão Linq originais e é um resultado direto da criação das Extensões Reativas (Rx).

Pense, Linq Extension Methods+ Ix= Rxpara IEnumerable.

Você pode encontrar Rx e Ix no CodePlex .

Isso é 30% mais rápido que yieldou Enumerable.Repeatquando usado foreachdevido a essa otimização do compilador C # e com o mesmo desempenho em outros casos.

public struct SingleSequence<T> : IEnumerable<T> {
    public struct SingleEnumerator : IEnumerator<T> {
        private readonly SingleSequence<T> _parent;
        private bool _couldMove;
        public SingleEnumerator(ref SingleSequence<T> parent) {
            _parent = parent;
            _couldMove = true;
        }
        public T Current => _parent._value;
        object IEnumerator.Current => Current;
        public void Dispose() { }

        public bool MoveNext() {
            if (!_couldMove) return false;
            _couldMove = false;
            return true;
        }
        public void Reset() {
            _couldMove = true;
        }
    }
    private readonly T _value;
    public SingleSequence(T value) {
        _value = value;
    }
    public IEnumerator<T> GetEnumerator() {
        return new SingleEnumerator(ref this);
    }
    IEnumerator IEnumerable.GetEnumerator() {
        return new SingleEnumerator(ref this);
    }
}

neste teste:

    // Fastest among seqs, but still 30x times slower than direct sum
    // 49 mops vs 37 mops for yield, or c.30% faster
    [Test]
    public void SingleSequenceStructForEach() {
        var sw = new Stopwatch();
        sw.Start();
        long sum = 0;
        for (var i = 0; i < 100000000; i++) {
            foreach (var single in new SingleSequence<int>(i)) {
                sum += single;
            }
        }
        sw.Stop();
        Console.WriteLine($"Elapsed {sw.ElapsedMilliseconds}");
        Console.WriteLine($"Mops {100000.0 / sw.ElapsedMilliseconds * 1.0}");
    }

IanG tem um bom post sobre o assunto , sugerindo EnumerableFrom()como o nome (e menciona que Haskell e Rx o chamam Return). O IIRC F # também chama Retorno . F # Seqchama o operadorsingleton<'T> .

Tentador, se você está preparado para ser cêntrico em C #, é chamá-lo Yield[aludindo aos yield returnenvolvidos na realização].

Se você está interessado nos aspectos de desempenho, James Michael Hare também tem uma postagem de zero ou um item retornando, o que vale uma varredura.

Isso pode não ser melhor, mas é bem legal:

Enumerable.Range(0, 1).Select(i => item);

Concordo com os comentários do @ EarthEngine na postagem original, que é 'AsSingleton' é um nome melhor. Veja esta entrada da Wikipedia . Da definição de singleton, segue-se que, se um valor nulo for passado como argumento de que 'AsSingleton' retornará um IEnumerable com um único valor nulo, em vez de um IEnumerable vazio, o que encerraria o if (item == null) yield break;debate. Eu acho que a melhor solução é ter dois métodos: 'AsSingleton' e 'AsSingletonOrEmpty'; onde, no caso de um nulo ser passado como argumento, 'AsSingleton' retornará um único valor nulo e 'AsSingletonOrEmpty' retornará um IEnumerable vazio. Como isso:

public static IEnumerable<T> AsSingletonOrEmpty<T>(this T source)
{
    if (source == null)
    {
        yield break;
    }
    else
    {
        yield return source;
    }
}

public static IEnumerable<T> AsSingleton<T>(this T source)
{
    yield return source;
}

Então, esses seriam, mais ou menos, análogos aos métodos de extensão 'First' e 'FirstOrDefault' no IEnumerable que parecem adequados.

A maneira mais fácil que eu diria seria new T[]{item};; não há sintaxe para fazer isso. O equivalente mais próximo que consigo pensar é a paramspalavra - chave, mas é claro que exige que você tenha acesso à definição do método e é utilizável apenas com matrizes.

Enumerable.Range(1,1).Select(_ => {
    //Do some stuff... side effects...
    return item;
});

O código acima é útil quando se usa como

var existingOrNewObject = MyData.Where(myCondition)
       .Concat(Enumerable.Range(1,1).Select(_ => {
           //Create my object...
           return item;
       })).Take(1).First();

No trecho de código acima, não há verificação vazia / nula e é garantido que apenas um objeto seja retornado sem medo de exceções. Além disso, por ser preguiçoso, o fechamento não será executado até que seja provado que não há dados existentes que atendam aos critérios.

Estou um pouco atrasado para a festa, mas vou compartilhar o meu caminho de qualquer maneira. Meu problema era que eu queria vincular o ItemSource ou um WPF TreeView a um único objeto. A hierarquia fica assim:

Projeto> Lote (s)> Quarto (s)

Sempre haveria apenas um projeto, mas eu ainda queria mostrar o projeto na árvore, sem ter que passar uma coleção com apenas esse objeto, como sugerido por alguns.
Como você só pode passar objetos IEnumerable como ItemSource, decidi fazer minha classe IEnumerable:

public class ProjectClass : IEnumerable<ProjectClass>
{
    private readonly SingleItemEnumerator<AufmassProjekt> enumerator;

    ... 

    public IEnumerator<ProjectClass > GetEnumerator() => this.enumerator;

    IEnumerator IEnumerable.GetEnumerator() => this.GetEnumerator();
}

E crie meu próprio enumerador de acordo:

public class SingleItemEnumerator : IEnumerator
{
    private bool hasMovedOnce;

    public SingleItemEnumerator(object current)
    {
        this.Current = current;
    }

    public bool MoveNext()
    {
        if (this.hasMovedOnce) return false;
        this.hasMovedOnce = true;
        return true;
    }

    public void Reset()
    { }

    public object Current { get; }
}

public class SingleItemEnumerator<T> : IEnumerator<T>
{
    private bool hasMovedOnce;

    public SingleItemEnumerator(T current)
    {
        this.Current = current;
    }

    public void Dispose() => (this.Current as IDisposable).Dispose();

    public bool MoveNext()
    {
        if (this.hasMovedOnce) return false;
        this.hasMovedOnce = true;
        return true;
    }

    public void Reset()
    { }

    public T Current { get; }

    object IEnumerator.Current => this.Current;
}

Provavelmente, essa não é a solução "mais limpa", mas funcionou para mim.

EDIT
Para manter o princípio de responsabilidade única, como o @Groo apontou, criei uma nova classe de wrapper:

public class SingleItemWrapper : IEnumerable
{
    private readonly SingleItemEnumerator enumerator;

    public SingleItemWrapper(object item)
    {
        this.enumerator = new SingleItemEnumerator(item);
    }

    public object Item => this.enumerator.Current;

    public IEnumerator GetEnumerator() => this.enumerator;
}

public class SingleItemWrapper<T> : IEnumerable<T>
{
    private readonly SingleItemEnumerator<T> enumerator;

    public SingleItemWrapper(T item)
    {
        this.enumerator = new SingleItemEnumerator<T>(item);
    }

    public T Item => this.enumerator.Current;

    public IEnumerator<T> GetEnumerator() => this.enumerator;

    IEnumerator IEnumerable.GetEnumerator() => this.GetEnumerator();
}

Que eu usei assim

TreeView.ItemSource = new SingleItemWrapper(itemToWrap);

EDIT 2
Corrigi um erro com o MoveNext()método.

Para ser apresentado em "Não necessariamente uma boa solução, mas ainda assim ... uma solução" ou "Truques LINQ estúpidos", você pode combinar Enumerable.Empty<>()com Enumerable.Append<>()...

IEnumerable<string> singleElementEnumerable = Enumerable.Empty<string>().Append("Hello, World!");

... ou Enumerable.Prepend<>()...

IEnumerable<string> singleElementEnumerable = Enumerable.Empty<string>().Prepend("Hello, World!");

Os dois últimos métodos estão disponíveis desde o .NET Framework 4.7.1 e o .NET Core 1.0.

Esta é uma solução viável se alguém realmente pretender usar os métodos existentes, em vez de escrever os seus próprios, embora eu esteja indeciso se isso é mais ou menos claro do que a Enumerable.Repeat<>()solução . Esse é definitivamente um código mais longo (em parte devido à inferência de parâmetro de tipo não ser possível Empty<>()) e, no entanto, cria o dobro de objetos enumeradores.

Completando este "Você sabia que esses métodos existem?" resposta, Array.Empty<>()poderia ser substituído Enumerable.Empty<>(), mas é difícil argumentar que torna a situação ... melhor.

Recentemente, perguntei a mesma coisa em outro post ( existe uma maneira de chamar um método C # que exija um IEnumerable <T> com um único valor? ... com benchmarking ).

Eu queria que as pessoas que estivessem aqui aparecessem para ver a breve comparação de benchmark mostrada naquele post mais recente para 4 das abordagens apresentadas nessas respostas.

Parece que simplesmente escrever new[] { x }os argumentos do método é a solução mais curta e rápida.