2 tråde om samme Queue

Hvis det er MessageQueue vi taler om bør du læse beskeder fra den via. Eventet RecieveCompleted.

F.eks sådan her.

logViewQueue.ReceiveCompleted += new ReceiveCompletedEventHandler(MyReceiveCompleted);
logViewQueue.BeginReceive();

private void MyReceiveCompleted(Object source, ReceiveCompletedEventArgs asyncResult) {
MessageQueue queue = (MessageQueue)source;
queue.Formatter = new XmlMessageFormatter(new Type[] { typeof(XmlDocument) });
System.Messaging.Message message = new System.Messaging.Message();
message = queue.EndReceive(asyncResult.AsyncResult);
}

hvis ikke dine beskeder er overført i XML format skal du ændre på linjen:
queue.Formatter = new XmlMessageFormatter(new Type[] { typeof(XmlDocument) });

eller sende dine beskeder i XML format, som er simpelt.

Det kan laves *MEGET* pænere.

  while (true)
  {
      if (_smsQueue.Count > 0)
      {
        Console.WriteLine(_smsQueue.Dequeue());
      }
  }

vil æde 100% CPU mens køen er tom !

#Kalp
yes, har kigget lidt på MSMQ, har desværre bare ikke haft tid til at kode noget endnu..

#arne_v
Ja, ved det godt, det er ret skidt. hva ville du foreslå ?

Du skal have lavet en blocking queue !

Således at den der læser venter indtil der er noget uden at bruge CPU.

Jeg kan godt finde et eksempel hvis nødvendigt.

Må du meget gerne

For 3 år siden lavede jeg denne kode til et andet spørgsmål:

using System;
using System.Collections;
using System.Threading;

namespace E
{
    public abstract class Command
    {
        public abstract void Execute();
    }
    public class Test1Command : Command
    {
        private int v;
        public Test1Command(int v)
        {
            this.v = v;
        }
        public override void Execute()
        {
            Console.WriteLine("Test1 thread = " + Thread.CurrentThread.Name + " v = " + v);
        }
    }
    public class Test2Command : Command
    {
        private int v;
        public Test2Command(int v)
        {
            this.v = v;
        }
        public override void Execute()
        {
            Console.WriteLine("Test2 thread = " + Thread.CurrentThread.Name + " v = " + v);
        }
    }
    public class CommandQueue
    {
        private Queue q;
        public CommandQueue()
        {
            q = new Queue();
        }
        public void Enqueue(Command cmd)
        {
            Monitor.Enter(q);
            q.Enqueue(cmd);
            Monitor.PulseAll(q);
            Monitor.Exit(q);
        }
        public Command Dequeue()
        {
            Command cmd = null;
            do
            {
                Monitor.Enter(q);
                if(q.Count > 0)
                {
                    cmd = (Command)q.Dequeue();
                }
                else
                {
                    Monitor.Wait(q);
                }
                Monitor.Exit(q);
            } while(cmd == null);
            return cmd;
        }
    }
    public class WorkerThread
    {
        private CommandQueue cq;
        public WorkerThread(CommandQueue cq)
        {
            this.cq = cq;
        }
        public void Run()
        {
            while(true)
            {
                Command cmd = cq.Dequeue();
                cmd.Execute();
            }
        }
    }
    public class WorkerThreadPool
    {
        private WorkerThread[] wt;
        public WorkerThreadPool(int n, CommandQueue cq)
        {
            wt = new WorkerThread[n];
            for(int i = 0; i < wt.Length; i++)
            {
                wt[i] = new WorkerThread(cq);
                Thread t = new Thread(new ThreadStart(wt[i].Run));
                t.Name = "Thread-" + (i + 1);
                t.Start();
            }
        }
    }
    public class TestClass
    {
        public static void Main(string[] args)
        {
            CommandQueue qc = new CommandQueue();
            WorkerThreadPool wtp = new WorkerThreadPool(3, qc);
            qc.Enqueue(new Test1Command(1));
            qc.Enqueue(new Test2Command(2));
            qc.Enqueue(new Test1Command(3));
            qc.Enqueue(new Test2Command(4));
            Thread.Sleep(5000);
            Environment.Exit(0);
        }
    }
}

CommandQueue.Dequeue er blocking

#arne_v
det blev den løsning jeg brugte, så smid et svar

svar