This isn't specific to C# but I'm working in C# and maybe there's a language-specific solution.
Oh, and it's prob a noob question...

I have a class which looks after two queues. And it must expose a number of functions with each function adding one element to one of the queues. Like this:

Code:
public class Manager : IChores
{
    private Queue<string> m_type1Processes;
    private Queue<string> m_type2Processes;

    public void IChores.WashDishes ()
    {
         m_type1Processes.Enqueue("Fill sink");
    }

    public void IChores.ChangeOil ()
    {
         m_type2Processes.Enqueue("Buy oil");
    }
}
And yeah, there does need to be two queues because the times and circumstances in which processes are Dequeued is quite different in the two types.

Some of the queue-processing logic may look a little like this:

Code:
private void UpdateType1Queue ()
{
    lock(m_type1QueueLock)
    {
          if (m_type1Queue.Count == 0)
          {
                // Do something
          }
          else
          {
                // Do something else
          }
    }
}
So, the issue is that all this code is very error-prone. My queues are not really called "type1" and "type2", but nonetheless it would be easy to mistype and add an element to the wrong queue, and it would create an insidious bug.
And similar mistypes could happen anywhere within the queue-processing logic.

Bearing in mind that I can't change IChores, what's the best way to make this code less error-prone, i.e. make the association between method and queue more overt?
And for processing, is there a way to explicitly say "This function deals with *this* queue, and any attempt to touch the other queue is an error"?

thanks