I'm developing a communication API to be used by a lot of generic clients to communicate with a proprietary system.

This proprietary system exposes an API, and I use a particular classes to send and wait messages from this system: obviously the system alert me that a message is ready using an event. The event is named OnMessageArrived.

My idea is to expose a simple SendSyncMessage(message) method that helps the user/client to simply send a message and the method returns the response.

The client:

using ( Communicator c = new Communicator() )
{
    response = c.SendSync(message);
}

The communicator class is done in this way:

public class Communicator : IDisposable
{
    // Proprietary system object
    ExternalSystem c;

    String currentRespone;
    Guid currentGUID;
    private readonly ManualResetEvent _manualResetEvent;
    private ManualResetEvent _manualResetEvent2;

    String systemName = "system";
    String ServerName = "server";

    public Communicator()
    {
        _manualResetEvent = new ManualResetEvent(false);           

        //This methods are from the proprietary system API
        c = SystemInstance.CreateInstance();
        c.Connect(systemName , ServerName);
    }

    private void ConnectionStarter( object data )
    {
        c.OnMessageArrivedEvent += c_OnMessageArrivedEvent;

       _manualResetEvent.WaitOne();

        c.OnMessageArrivedEvent-= c_OnMessageArrivedEvent;

    }

    public String SendSync( String Message )
    {
        Thread _internalThread = new Thread(ConnectionStarter);
        _internalThread.Start(c);

        _manualResetEvent2 = new ManualResetEvent(false);

        String toRet;
        int messageID;

        currentGUID = Guid.NewGuid();

        c.SendMessage(Message, "Request", currentGUID.ToString());

        _manualResetEvent2.WaitOne();

        toRet = currentRespone;

        return toRet;
    }

    void c_OnMessageArrivedEvent( int Id, string root, string guid, int TimeOut, out int ReturnCode )
    {
        if ( !guid.Equals(currentGUID.ToString()) )
        {
            _manualResetEvent2.Set();
            ReturnCode = 0;
            return;
        }

        object newMessage;

        c.FetchMessage(Id, 7, out newMessage);

        currentRespone = newMessage.ToString();

        ReturnCode = 0;

        _manualResetEvent2.Set();
    }
}

I'm really noob in using waithandle, but my idea was to create an instance that sends the message and waits for an event. As soon as the event arrived, checks if the message is the one I expect (checking the unique guid), otherwise continues to wait for the next event. This because could be (and usually is in this way) a lot of clients working concurrently, and I want them to work parallel. As I implemented my stuff, at the moment if I run client 1, client 2 and client 3, client 2 starts sending message as soon as client 1 has finished, and client 3 as client 2 has finished: not what I'm trying to do.

Can you help me to fix my code and get my target?

Thanks!