he creado una cola genérica personalizada que implementa una interfaz genérica de IQueue, que utiliza la cola genérica del espacio de nombres System.Collections.Generic como cola interna privada. El ejemplo se ha eliminado del código irrelevante.En caso de que un iterador de IEnumerable en una cola dequeue un elemento
public interface IQueue<TQueueItem>
{
void Enqueue(TQueueItem queueItem);
TQueueItem Dequeue();
}
public class CustomQueue<TQueueItem> : IQueue<TQueueItem>
{
private readonly Queue<TQueueItem> queue = new Queue<TQueueItem>();
...
public void Enqueue(TQueueItem queueItem)
{
...
queue.Enqueue(queueItem);
...
}
public TQueueItem Dequeue()
{
...
return queue.Dequeue();
...
}
}
que quieren mantener las cosas consistentes con las implementaciones básicas y se han dado cuenta de que la cola del núcleo implementa IEnumerable por lo que hará lo mismo, ya sea de forma explícita mediante la implementación de IEnumerable en la clase o heredarlo con la interfaz iQueue.
Lo que quiero saber es cuándo enumerar en la cola cada movimiento siguiente dequeue el siguiente elemento? He usado reflector para ver cómo lo ha hecho Microsoft y todo lo que hacen es pasar por la matriz privada de colas, pero Microsoft está lejos de ser infalible, así que quería obtener una opinión general.
public class CustomQueue<TQueueItem> : IQueue<TQueueItem>, IEnumerable<TQueueItem>
{
...
public IEnumerator<TQueueItem> GetEnumerator()
{
while (queue.Count > 0)
{
yield return Dequeue();
}
}
//Or
public IEnumerator<TQueueItem> GetEnumerator()
{
return queue.GetEnumerator();
}
...
}
Estoy en dos mentes, por un lado, siento que iteración a través de una colección no debe cambiar el estado de las colecciones, pero por otro lado, y sobre todo con mi aplicación particular, esto haría que el uso de un aspecto limpio.
EDIT
Para poner las cosas en contexto. La clase que estoy implementando hace un Monitor. Espere al Dequeer y no haya elementos en la cola. Cuando un artículo se coloca en la cola, hay un Monitor.Pulse. Esto permite que un hilo empuje cosas en la cola y el otro esencialmente "mirar" la cola.
Desde el punto de vista de codificación que estoy tratando de decidir qué se ve más limpia:
foreach(QueueItem item in queue)
{
DoSomethingWithThe(item);
}
//Or
while(systemIsRunning)
{
DoSomethingWithThe(queue.Dequeue());
}
Por mi aplicación particular, no importaría si hubiera varios elementos desencola proceso. Debido a que es una cola, ambos pueden elegir un elemento, ya que ningún elemento debe procesarse más de una vez, de ahí el uso de una cola.
EDITAR
Curiosamente he encontrado una entrada de blog en la que alguien ha hecho exactamente esto.
http://blogs.msdn.com/b/toub/archive/2006/04/12/blocking-queues.aspx
EDITAR
Una última puñalada en esto antes de cerrar esto. ¿Cómo se sienten las personas acerca de la clase que no implementan IEnumerable sino que tienen un método IEnumerator GetEnumerator() que dequeues items? El lenguaje .net admite el tipado de pato, ya que uno de los usos es foreach. Tal vez esto merece su propia pregunta?
EDITAR
han planteado la cuestión de la aplicación de un método GetEnumerator sin implementar IEnumerable en otro question.
Acepto lo que estaba considerando hacer era un abuso, de ahí el motivo de la publicación, solo necesitaba que me lo dijeran 10 u 11 veces. Creo que la verdadera pregunta que me tengo que hacer es por qué tengo que implementar IEnumerable. Lo estoy haciendo porque la implementación central hace, ya que no tengo requisitos reales para iterar sobre mi cola. – Bronumski
Lamentablemente, no puedo marcarlos como correctos, así que les daré un día para que limpien sus respuestas y marquen el más votado como correcto. – Bronumski