C#

<code>
public class CommunicationManager
{
	public delegate void CMEventHandler();
	public event CMEventHandler DataReceived;

	private ManualResetEvent ReadyToStop = new ManualResetEvent(false);
	private AutoResetEvent ReadyToSend = new AutoResetEvent(false);
	private AutoResetEvent ReadyToRecv = new AutoResetEvent(false);

	private Socket sock;
	private Queue inQ, outQ;

	public CommunicationManager() {}
	public bool MessagesPending() {}
	public string GetMessage() {}
	public void SendMessage(string msg) {}
	public void Connect(string IP, int Port) {}
	public void Disconnect() {}

	private void ReceiveThreadEntryPoint(object state)
	{
		WaitHandle[] handles = new WaitHandle[2];
		handles[0] = ReadyToStop;
		handles[1] = ReadyToRecv;
		StateObject so = new StateObject();

		while(true) 
		{
			if (sock != null && sock.Connected) 
			{
				so.Clear();
				so.sock = sock;
				sock.BeginReceive(so.buff, 0, StateObject.BUFFER_SIZE, 0, new AsyncCallback(ReceiveCallback), so);
			}				

			if (WaitHandle.WaitAny(handles) == 0)
				break;
		}
	}

	private void SendThreadEntryPoint(object state)
	{
		while(true)
		{
			WaitHandle[] handles = new WaitHandle[2];
			handles[0] = ReadyToStop;
			handles[1] = ReadyToSend;

			if( WaitHandle.WaitAny(handles) == 0 )
			{
				break;
			}

			if (sock != null && sock.Connected) 
			{
				while(outQ.Count > 0) 
				{
					StateObject so = new StateObject();
					so.sock = sock;
					byte[] buff = Encoding.ASCII.GetBytes((string)outQ.Dequeue());
					sock.BeginSend(buff, 0, buff.Length, 0, new AsyncCallback(SendCallback), so);
				}
			}

		}
	}
	private void ReceiveCallback(IAsyncResult ar)
	{
		StateObject so = (StateObject)ar.AsyncState;
		Socket s = so.sock;

		try
		{
			// sanity check
			if (s == null || !s.Connected) return;

			//Finishes the async read operation, gets number of bytes received
			int read = s.EndReceive(ar);
			if (read > 0)
			{
				//read not empty

				//post the message to the inbound queue
				string msg = Encoding.ASCII.GetString(so.buff, 0, read);
				inQ.Enqueue(msg);

				//receive complete, set up the next one
				ReadyToRecv.Set();
			}
		}
		catch {}

	}

	private void SendCallback(IAsyncResult ar)
	{
		StateObject so = (StateObject)ar.AsyncState;
		Socket s = so.sock;

		try
		{
			// sanity check
			if (s == null || !s.Connected) return;

			// finish the async send operation
			int sent = s.EndSend(ar);
		}
		catch {}
	}

	private class StateObject {}
}
</code>

class BaseClass
{
  public enum Action
  {
    NO_ACTION
  }

  protected virtual bool ValidateAction(Action a)
  {
   return true;
  }
}

class DerivedClass : BaseClass
{
  public new enum Action
  {
    ACTION1,
    ACTION2
  }

  protected override bool ValidateAction(Action a)
  {
    //... validate Action ...
  }
}