CODEWITHSUNDEEP
c#list.net-3.5named-pipes
Prix
Prix

Reputation: 19528

Namedpipe to list while being able to read or use that list?

Let's say I have a list and am streaming data from a namedpipe to that list.

hypothetical sample:

private void myStreamingThread()
{
    while(mypipe.isconnected)
    {
       if (mypipe.hasdata)
           myList.add(mypipe.data);
    }
}

Then on another thread I need to read that list every 1000ms for example:

private void myListReadingThread()
{
    while(isStarted)
    {
       if (myList.count > 0)
       {
           //do whatever I need to.
       }
       Thread.Sleep(1000);
    }
}

My priority here is to be able to read the list every 1000 ms and do whatever I need with the list but at the same time it is very important to be able to get the new data from it that comes from the pipe.

What is a good method to come with this ?

Forgot to mention I am tied to .NET 3.5

Upvotes: 2

Views: 196

Answers (2)

Jim Mischel
Jim Mischel

Reputation: 134005

I would recommend using a Queue with a lock.

Queue<string> myQueue = new Queue<string>();

private void myStreamingThread()
{
    while(mypipe.isconnected)
    {
       if (mypipe.hasdata)
       {
           lock (myQueue)
           {
               myQueue.add(mypipe.data);
           }
       }
    }
}

If you want to empty the queue every 1000 ms, do not use Thread.Sleep. Use a timer instead.

System.Threading.Timer t = new Timer(myListReadingProc, null, 1000, 1000);


private void myListReadingProc(object s)
{
   while (myQueue.Count > 0)
   {
       lock (myQueue)
       {
           string item = myQueue.Dequeue();
           // do whatever
       }
    }
}

Note that the above assumes that the queue is only being read by one thread. If multiple threads are reading, then there's a race condition. But the above will work with a single reader and one or more writers.

Upvotes: 2

Richard Schneider
Richard Schneider

Reputation: 35477

I would suggest using a ConcurrentQueue (http://msdn.microsoft.com/en-us/library/dd267265.aspx). If you use a simple List<> then you will encourter a lot threading issues.

The other practice would be to use a mutex called outstandingWork and wait on it instead of Thread.Sleep(). Then when you enqueue some work you pulse outstandingWork. This means that you sleep when no work is available but start processing work immediately instead of sleep the entire 1 second.

Edit

As @Prix pointed out, you are using .Net 3.5. So you cannot use ConcurrentQueue. Use the Queue class with the following

Queue<Work> queue;
AutoResetEvent outstandingWork = new AutoResetEvent(false);

void Enqueue(Work work) 
{
    lock (queue)
    { 
       queue.Enqueue(work); 
       outstandingWork.Set();
    }
}

Work DequeMaybe()
{
    lock (queue)
    {
       if (queue.Count == 0) return null;
       return queue.Dequeue();
    }
}

void DoWork()
{
   while (true)
   {
      Work work = DequeMaybe();
      if (work == null)
      {
          outstandingWork.WaitOne();
          continue;
      }
      // Do the work.
   }
}

Upvotes: 1

Related Questions