.net enumeração primeiro e último

Question

há uma maneira em .NET (ou algum tipo de métodos de extensão padrão) para fazer perguntas de uma enumeração?

Por exemplo é o item atual primeiro ou último item na enumeração:

string s = "";

foreach (var person in PeopleListEnumerator) {

  if (PeopleListEnumerator.IsFirstItem) s += "[";

  s += person.ToString();

  if (!PeopleListEnumerator.IsLastItem) s += ",";
  else s += "]";
}

Answer 1

Apenas por uma questão de diversão, uma solução para o problema geral que não requer avaliação ansiosa e tem uma única variável local (exceto o recenseador):

static class TaggedEnumerableExtensions
{
    public class TaggedItem<T>
    {
        public TaggedItem(T value, bool isFirst, bool isLast)
        {
            IsFirst = isFirst;
            IsLast = isLast;
            Value = value;
        }
        public T Value { get; private set; }
        public bool IsFirst { get; private set; }
        public bool IsLast { get; private set; }
    }
    public static IEnumerable<TaggedItem<T>> ToTaggedEnumerable<T>(this IEnumerable<T> e)
    {
        using (var enumerator = e.GetEnumerator()) {
            if (!enumerator.MoveNext())
                yield break;
            var current = enumerator.Current;
            if (!enumerator.MoveNext()) {
                yield return new TaggedItem<T>(current, true, true);
                yield break;
            } else {
                yield return new TaggedItem<T>(current, true, false);
            }

            for (;;) {
                current = enumerator.Current;
                if (!enumerator.MoveNext()) {
                    yield return new TaggedItem<T>(current, false, true);
                    yield break;
                }
                yield return new TaggedItem<T>(current, false, false);
            }
        }
    }
}

Test:

class Program
{
    static void Main(string[] args)
    {
        foreach (var item in Enumerable.Range(0, 10).ToTaggedEnumerable()) {
            Console.WriteLine("{0} {1} {2}", item.IsFirst, item.IsLast, item.Value);
        }
    }
}

Answer 2

Se sua coleção é uma lista, você pode fazer:

string s = "[" + String.Join(",", PeopleList.ToArray()) + "]";

Answer 3

Não que eu saiba. Você pode tentar escrever tais métodos de extensão si mesmo, no entanto. Ou acompanhar o primeiro último item / em outro lugar.

Eric Lippert tinha um blog sobre esse tipo de problema recentemente, juntamente com alguns pensamentos sobre como modificar sua descrição do problema de forma mais precisa refletir o que você realmente quer.

Você é provavelmente melhor usar um String.Join com alguma LINQ neste caso:

String.Join(
  ",",
  (from p in PeopleListEnumerator
  select p.ToString()).ToArray()
)

Answer 4

A interface IEnumerable não define ou esperar que os itens que ele retorna para ser em qualquer ordem. Assim, o conceito de "First" nem sempre se aplica.

No entanto, para este padrão particular é isso que eu faço

StringBuilder result = new StringBuilder();
result.Append( '[' );

foreach( var person in PeopleListEnumerator )
{
    if( result.Length > 1 )
        result.Append( ',' );
    result.Append( person.ToString() );
}

result.Append( ']' );

Answer 5

Jon Skeet escreveu inteligente Enumerations para fornecer esse tipo de funcionalidade e são parte do MiscUtils biblioteca.

Dito seu exemplo específico é melhor resolvidos pela abordagem String.Join () como muitos outros têm apontado. Escrevendo uma extensão geral string Join(this IEnumerable<T>,string) não é difícil e é, então, utilizável em mais situações sem ter que recorrer a arranjos temporários irritantes.

Answer 6

Usando o LINQ, você pode fazer:

string s = 
    string.Format("[{0}]", string.Join(",",PeopleListEnumerator.Select(p => p.ToString()).ToArray()));

Answer 7

Eu encontro-me definir e usar um "bool primeiro" variável local, por exemplo:

string s = "[";
bool first = true;

foreach (var person in PeopleListEnumerator) {

  if (first)
    first = false;
  else
    s += ",";
  s += person.ToString();
}
s += "]";

Answer 8

Este código de perto corresponde ao que você realmente quer realizar:

StringBuilder s = new StringBuilder("[");
string delimiter = "";

foreach (var person in PeopleListEnumerator) {  
  s.Append(delimiter).Append(person.ToString());
  delimiter = ",";
}

return s.Append("]").ToString();

Answer 9

A maneira que eu esfolar este gato (sim, há que muitas maneiras) seria:

StringBuilder sb = new StringBuilder();

foreach (var person in PeopleListEnumerator )
{
    sb.AppendFormat(",{0}", person.ToString());
}

string s = "[" + sb.ToString().Substring(1) + "]";

Espero que isso ajude ...

Answer 10

enumerações

Em NET não têm noção de ordem, exceto por valor. Se você quer um primeiro e último enumeração eu sugeriria explicitamente definir o que esses primeiros e últimos valores são. O seguinte enumeração é um exemplo disso:

public enum PlayerType : byte
{
    Starter = byte.MinValue,
    RegularPlayer = 1,
    BenchWarmer = 2,
    Closer = byte.MaxValue
}

Você pode então expressar algo semelhante ao seguinte:

List<byte> values = new List<byte>((byte[])Enum.GetValues(typeof(PlayerType)));

PlayerType starter = (PlayerType)values.Min();
PlayerType closer = (PlayerType)values.Max();