Tratamento de aviso para possível enumeração múltipla de IEnumerable

No meu código na necessidade de usar IEnumerable<>várias vezes, portanto, obter o erro Resharper de "Enumeração múltipla possível de IEnumerable".

Código de amostra:

public List<object> Foo(IEnumerable<object> objects)
{
    if (objects == null || !objects.Any())
        throw new ArgumentException();

    var firstObject = objects.First();
    var list = DoSomeThing(firstObject);        
    var secondList = DoSomeThingElse(objects);
    list.AddRange(secondList);

    return list;
}

• Posso alterar o objectsparâmetro Liste evitar a possível enumeração múltipla, mas não obtenho o objeto mais alto que posso manipular.
• Outra coisa que posso fazer é converter o IEnumerablepara Listno início do método:

 public List<object> Foo(IEnumerable<object> objects)
 {
    var objectList = objects.ToList();
    // ...
 }

Mas isso é apenas estranho .

O que você faria neste cenário?

O problema de usar IEnumerablecomo parâmetro é que ele diz aos chamadores "desejo enumerar isso". Não diz a eles quantas vezes você deseja enumerar.

Posso alterar o parâmetro objects para List e evitar a possível enumeração múltipla, mas não obtenho o objeto mais alto que posso manipular .

O objetivo de pegar o objeto mais alto é nobre, mas deixa espaço para muitas suposições. Deseja realmente que alguém passe uma consulta LINQ to SQL para esse método, apenas para enumerá-la duas vezes (obtendo resultados potencialmente diferentes a cada vez?)

A falta semântica aqui é que um chamador, que talvez não tenha tempo para ler os detalhes do método, pode presumir que você repete apenas uma vez - para que ele passe um objeto caro para você. A assinatura do seu método não indica os dois lados.

Ao alterar a assinatura do método para IList/ ICollection, você pelo menos esclarecerá ao chamador quais são suas expectativas e elas podem evitar erros dispendiosos.

Caso contrário, a maioria dos desenvolvedores que analisam o método pode presumir que você itera apenas uma vez. Se tomar um IEnumerableé tão importante, considere fazê-lo .ToList()no início do método.

É uma pena que o .NET não tenha uma interface que seja IEnumerable + Count + Indexer, sem os métodos Adicionar / Remover etc., que é o que eu suspeito que resolveria esse problema.

Se seus dados sempre serão repetíveis, talvez não se preocupe. No entanto, você também pode desenrolá-lo - isso é especialmente útil se os dados recebidos puderem ser grandes (por exemplo, leitura do disco / rede):

if(objects == null) throw new ArgumentException();
using(var iter = objects.GetEnumerator()) {
    if(!iter.MoveNext()) throw new ArgumentException();

    var firstObject = iter.Current;
    var list = DoSomeThing(firstObject);  

    while(iter.MoveNext()) {
        list.Add(DoSomeThingElse(iter.Current));
    }
    return list;
}

Observe que mudei um pouco a semântica de DoSomethingElse, mas isso é principalmente para mostrar o uso desenrolado. Você pode envolver novamente o iterador, por exemplo. Você também pode transformá-lo em um bloco iterador, o que pode ser bom; então não há list- e você faria yield returnos itens à medida que os obtém, em vez de adicionar a uma lista a ser devolvida.

O uso IReadOnlyCollection<T>ou IReadOnlyList<T>na assinatura do método, em vez de IEnumerable<T>, tem a vantagem de tornar explícito que você pode precisar verificar a contagem antes de iterar ou iterar várias vezes por algum outro motivo.

No entanto, eles têm uma enorme desvantagem que causará problemas se você tentar refatorar seu código para usar interfaces, por exemplo, para torná-lo mais testável e amigável ao proxy dinâmico. O ponto principal é que IList<T>não herda deIReadOnlyList<T> e da mesma forma para outras coleções e suas respectivas interfaces somente leitura. (Em resumo, isso ocorre porque o .NET 4.5 queria manter a compatibilidade ABI com versões anteriores. Mas eles nem aproveitaram a oportunidade para mudar isso no núcleo do .NET. )

Isso significa que, se você obtém uma IList<T>parte de algum programa e deseja passá-lo para outra parte que espera uma IReadOnlyList<T>, não pode! No entanto, você pode passar um IList<T>como umIEnumerable<T> .

No final, IEnumerable<T>é a única interface somente leitura suportada por todas as coleções .NET, incluindo todas as interfaces de coleção. Qualquer outra alternativa voltará a mordê-lo quando você perceber que se excluiu de algumas opções de arquitetura. Então eu acho que é o tipo apropriado para usar em assinaturas de funções para expressar que você deseja apenas uma coleção somente leitura.

(Observe que você sempre pode escrever um IReadOnlyList<T> ToReadOnly<T>(this IList<T> list)método de extensão que faça a conversão simples, se o tipo subjacente suportar as duas interfaces, mas você deve adicioná-lo manualmente em qualquer lugar ao refatorar, onde IEnumerable<T>sempre é compatível.)

Como sempre, isso não é absoluto; se você estiver escrevendo um código pesado para o banco de dados, em que a enumeração múltipla acidental seria um desastre, talvez prefira uma troca diferente.

Se o objetivo é realmente evitar várias enumerações, é melhor ler a resposta de Marc Gravell, mas mantendo a mesma semântica, você pode simplesmente remover o redundante Anye as Firstchamadas e seguir com:

public List<object> Foo(IEnumerable<object> objects)
{
    if (objects == null)
        throw new ArgumentNullException("objects");

    var first = objects.FirstOrDefault();

    if (first == null)
        throw new ArgumentException(
            "Empty enumerable not supported.", 
            "objects");

    var list = DoSomeThing(first);  

    var secondList = DoSomeThingElse(objects);

    list.AddRange(secondList);

    return list;
}

Observe que isso pressupõe que você IEnumerablenão é genérico ou, pelo menos, está restrito a ser um tipo de referência.

Normalmente sobrecarrego meu método com IEnumerable e IList nessa situação.

public static IEnumerable<T> Method<T>( this IList<T> source ){... }

public static IEnumerable<T> Method<T>( this IEnumerable<T> source )
{
    /*input checks on source parameter here*/
    return Method( source.ToList() );
}

Tomo o cuidado de explicar nos comentários resumidos dos métodos que a chamada IEnumerable executará um .ToList ().

O programador pode optar por .ToList () em um nível superior se várias operações estiverem sendo concatenadas e depois chamar a sobrecarga IList ou deixar minha sobrecarga IEnumerable cuidar disso.

Se você precisar apenas verificar o primeiro elemento, poderá espiá-lo sem iterar toda a coleção:

public List<object> Foo(IEnumerable<object> objects)
{
    object firstObject;
    if (objects == null || !TryPeek(ref objects, out firstObject))
        throw new ArgumentException();

    var list = DoSomeThing(firstObject);
    var secondList = DoSomeThingElse(objects);
    list.AddRange(secondList);

    return list;
}

public static bool TryPeek<T>(ref IEnumerable<T> source, out T first)
{
    if (source == null)
        throw new ArgumentNullException(nameof(source));

    IEnumerator<T> enumerator = source.GetEnumerator();
    if (!enumerator.MoveNext())
    {
        first = default(T);
        source = Enumerable.Empty<T>();
        return false;
    }

    first = enumerator.Current;
    T firstElement = first;
    source = Iterate();
    return true;

    IEnumerable<T> Iterate()
    {
        yield return firstElement;
        using (enumerator)
        {
            while (enumerator.MoveNext())
            {
                yield return enumerator.Current;
            }
        }
    }
}

Primeiro, esse aviso nem sempre significa muito. Normalmente, eu o desabilito depois de me certificar de que não é um gargalo de desempenho. Significa apenas que a IEnumerableavaliação é feita duas vezes, o que geralmente não é um problema, a menos que o processo evaluationdemore muito. Mesmo que demore muito, nesse caso, você está usando apenas um elemento na primeira vez.

Nesse cenário, você também pode explorar ainda mais os poderosos métodos de extensão linq.

var firstObject = objects.First();
return DoSomeThing(firstObject).Concat(DoSomeThingElse(objects).ToList();

É possível avaliar apenas IEnumerableuma vez neste caso com alguma trabalheira, mas perfil primeiro e ver se é realmente um problema.