public string ExecuteRequest(string requestQueueName, string responseQueueName, string message)
        {
            var requestQueue = _queueManager.AccessQueue(requestQueueName, MQC.MQOO_OUTPUT | MQC.MQOO_FAIL_IF_QUIESCING);
            var requestMessage = new MQMessage();
            requestMessage.WriteBytes(message);
            requestQueue.Put(requestMessage, _putMessageOptions);
            _queueManager.Commit();
            requestQueue.Close();

            var responseQueue = _queueManager.AccessQueue(responseQueueName, MQC.MQOO_INPUT_AS_Q_DEF | MQC.MQOO_FAIL_IF_QUIESCING);
            var receiveMessage = new MQMessage { CorrelationId = requestMessage.MessageId };
            var getMessageOptions = new MQGetMessageOptions
            {
                Options = MQC.MQGMO_FAIL_IF_QUIESCING | MQC.MQGMO_WAIT,
                WaitInterval = 10000, 
                MatchOptions = MQC.MQMO_MATCH_CORREL_ID
            };
            responseQueue.Get(receiveMessage, getMessageOptions);
            _queueManager.Commit();
            responseQueue.Close();
            var byteResult = receiveMessage.ReadBytes(receiveMessage.MessageLength);
            return System.Text.Encoding.UTF8.GetString(byteResult);
        }

public class Requestor : IDisposable
{
    private ISession _session;
    private IDestination _requestDestination;
    private IDestination _responseDestination;
    private IMessageProducer _producer;
    private bool _disposed;
    private int _timeout = 30000; // Default Timeout = 30 sec.


    /// <value>
    /// Время (в миллисекундах) ожидания ответного сообщения. По умолчанию - 30000 (30 сек.)
    /// </value>
    public int Timeout
    {
        get { return _timeout; }
        set { _timeout = value; }
    }


    public Requestor(ISession session, IDestination requestDestination, IDestination responseDestination)
    {
        this._session = session;
        this._requestDestination = requestDestination;
        this._responseDestination = responseDestination;
        this._producer = session.CreateProducer(requestDestination);
    }
        

    public virtual IMessage Request(IMessage requestMessage)
    {
        if (this._disposed)
            throw new IllegalStateException(this.GetType().FullName);
        this._producer.Send(requestMessage);
        IMessage responseMessage = null;
        using (IMessageConsumer consumer = _session.CreateConsumer(_responseDestination, "JMSCorrelationID = '" + requestMessage.JMSMessageID + "'"))
        {
            responseMessage = consumer.Receive(_timeout);
        }
        return responseMessage;
    }


    public void Close()
    {
        this.Dispose();
    }


    public void Dispose()
    {
        this.Dispose(true);
    }


    protected virtual void Dispose(bool disposing)
    {
        if (this._disposed)
            return;
        if (disposing)
        {
            this._responseDestination.Dispose();
            this._producer.Dispose();
            this._session = (ISession)null;
        }
        this._disposed = true;
    }
}

IConnectionFactory connectionFactory = CreateConnectionFactory(host, port, queueManagerName, channelName);
using (IConnection connection = connectionFactory.CreateConnection())
{
    using (ISession session = connection.CreateSession(false, AcknowledgeMode.AutoAcknowledge))
    {
        using (IDestination requestDestination = CreateDestination(session, requestQueueName))
        using (IDestination responseDestination = CreateDestination(session, responseQueueName))
        {
            using (Requestor requestor = new Requestor(session, requestDestination, responseDestination))
            {
                connection.Start();
                IMessage requestMessage = session.CreateTextMessage(message);
                ITextMessage responseMessage = (ITextMessage)requestor.Request(requestMessage);
                Console.WriteLine(responseMessage.Text);
            } // requestor
        } // destinations
    } // session
} // connection