C # - ¿Cómo crear una matriz desde un empadronador

Question

En C #, ¿cuál es la forma más elegante para crear una matriz de objetos, desde un enumerador de los objetos? p.ej. en este caso tengo un enumerador que puede devolver el byte de, por lo que quiero convertir esto a byte [].

EDIT: El código que crea el empadronador:

IEnumerator<byte> enumerator = updDnsPacket.GetEnumerator();

Answer 1

Asumiendo que tiene un IEnumerable , puede utilizar la Enumerable.ToArray método de extensión:

IEnumerable<byte> udpDnsPacket = /*...*/;

byte[] result = udpDnsPacket.ToArray();

Answer 2

OK, así que, en el supuesto de que tiene un enumerador real (IEnumerator<byte>), se puede utilizar un bucle while:

var list = new List<byte>();
while(enumerator.MoveNext())
  list.Add(enumerator.Current);
var array = list.ToArray();

En realidad, preferiría convertir el IEnumerator<T> a un IEnumerable<T>:

public static class EnumeratorExtensions
{
    public static IEnumerable<T> ToEnumerable<T>(this IEnumerator<T> enumerator)
    {
      while(enumerator.MoveNext())
          yield return enumerator.Current;
    }
}

A continuación, se puede obtener la matriz:

var array = enumerator.ToEnumerable().ToArray();

Por supuesto, todo esto supone que está utilizando .Net 3.5 o superior.

Answer 3

Ya que tienes una IEnumerator<byte> y no un IEnumerable<byte> , no se puede utilizar de LINQ ToArray método. ToArray es un método de extensión en IEnumerable<T>, no en IEnumerator<T>.

Me gustaría sugerir a escribir un método de extensión similar a Enumerable.ToArray pero luego con el propósito de crear una matriz de su encuestador:

public T[] ToArray<T>(this IEnumerator<T> source)
{
    T[] array = null;
    int length = 0;
    T t;
    while (source.MoveNext())
    {
        t = source.Current();
        if (array == null)
        {
            array = new T[4];
        }
        else if (array.Length == length)
        {
            T[] destinationArray = new T[length * 2];
            Array.Copy(array, 0, destinationArray, 0, length);
            array = destinationArray;
        }
        array[length] = t;
        length++;
    }
    if (array.Length == length)
    {
        return array;
    }
    T[] destinationArray = new T[length];
    Array.Copy(array, 0, destinationArray, 0, length);
    return destinationArray;
}

Lo que pasa es que iterate su artículo empadronador por punto y añadirlos a una matriz que está aumentando gradualmente de tamaño.