Notification / Subcription in AQ

Question

The following code is me trying to subcribe to the notifications that a new item has been queued. I can't get notification to the MessageAvailable subcriber. Any ideas?
I have confirmed that I have access to the queues (I created them) and that the subcription is valid but I'm not getting any notification. Other threads suggest that I set up the Consumer Name and Notification consumers but I'm getting no response.
Code Below :
using System;
using System.Windows.Forms;
using Oracle.DataAccess.Client;
namespace WindowsFormsApplication1
public partial class Form1 : Form
string theConectionString = "user id=scott;password=tiger;data source=TTORCL";
private OracleConnection theConnection;
private OracleConnection theConnection2;
private OracleAQQueue theQueue;
public Form1()
InitializeComponent();
SetUp();
private void SetUp()
theConnection = new OracleConnection(theConectionString);
theConnection.Open();
theConnection2 = new OracleConnection(theConectionString);
theConnection2.Open();
OracleTransaction txn = theConnection2.BeginTransaction();
theQueue = new OracleAQQueue("JOBSQUEUE", theConnection2);
theQueue.NotificationConsumers = new string[1] { "JOHNDALY" };
theQueue.DequeueOptions.Wait = 0; // We will not wait for a message to become available
theQueue.DequeueOptions.Visibility = OracleAQVisibilityMode.OnCommit; // Messages only leave the queue when we commit.
theQueue.DequeueOptions.ConsumerName = "JOHNDALY";
theQueue.MessageAvailable += new OracleAQMessageAvailableEventHandler(IncomingMessageCallback);
txn.Commit();
public void IncomingMessageCallback(object sender, OracleAQMessageAvailableEventArgs e)
string message = "Notification Received...\n" + "QueueName : "
+ e.QueueName + "\n"
+ "Notification Type : " + e.NotificationType;
textBox1.Text = message + System.Environment.NewLine + "----------------------" + System.Environment.NewLine + textBox1.Text;
private void button1_Click(object sender, EventArgs e)
// Create queue
using (var queue = new OracleAQQueue("JOBSQUEUE", theConnection))
OracleTransaction txn = theConnection.BeginTransaction();
queue.MessageType = OracleAQMessageType.Raw;
queue.EnqueueOptions.Visibility = OracleAQVisibilityMode.OnCommit;
OracleAQMessage enqMsg = new OracleAQMessage();
enqMsg.Payload = new byte[] {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
enqMsg.SenderId = new OracleAQAgent("SCOTT");
queue.Enqueue(enqMsg);
txn.Commit();
//var txnt = theConnection.BeginTransaction();
//var m = queue.Dequeue();
textBox1.Text = System.Text.UTF32Encoding.UTF32.GetString(enqMsg.MessageId);
//txnt.Commit();
private void button2_Click(object sender, EventArgs e)
theConnection2.Dispose();
theQueue.Dispose();
theConnection.Dispose();
Application.Exit();
}

Answer 1

Here's the code I wrote (some time ago now) which sets up the receiver. Obviously it is just a snippet - hopefully for those variables which are declared elsewhere, you can infer their meaning from their name. If not, just ask. This code works for both single-consumer and multi-consumer messages.
Doesn't look too different to your code, although note however my last comment - the event only fires when a message arrives on a queue, not when messages are already on it. So it looks like I am doing a poll as part and parcel of the set up.
The only other thing to say is that I am purely listening in this scenario, so my code is kept quite clean. I noticed your scenario was both sending and revceiving - I don't see why there'd be a problem with this but maybe it'd be a good idea to strip your code down to the bare minimum at least until you've figured out what is going on?
Pete
/// <summary>
/// Creates the queues and initiates the pocess of IsListening and receiving of Aq messages
/// Note that we will always listen transactionally
/// </summary>
public void Start()
if (true == IsListening)
return;
//create the queue
Logger.Write("OracleAQXmlListener(Low-level): Creating the Queue:" + _queueName,
"Information", StandardPriorities.Low, TraceEventType.Information);
// Creates the internal connection and queue objects
if (null == _queue)
if (null == _connection)
connection = new OracleConnection(connectionString);
queue = new OracleAQQueue(queueName, _connection, ExpectedPayloadType);
// If a subscriber is specified, add a notification consumer
// Note that under the hood, the MessageAvailable event sets up notifications,
// and we need to explicitly register this consumer to receive notifications
if (false == string.IsNullOrWhiteSpace(_subscriberName))
// Add a consumer
_queue.NotificationConsumers = new string[1] {_subscriberName};
// We'll also take this opportunity to set some dequeue options
_queue.DequeueOptions.Wait = 0;                 // We will not wait for a message to become available
_queue.DequeueOptions.Visibility = OracleAQVisibilityMode.OnCommit;  // Messages only leave the queue when we commit.
_queue.DequeueOptions.ProviderSpecificType = true;                   // We specifically want an OracleXmlType tobe returned
// If a subscriber is specified, add a message consumer.
// Note that despite the line of code above to register for notifications, we must also,
// separately, register ourselves to dequeue messages.
// In short, both of these lines of code are required for multi-consumer queues
if (false == string.IsNullOrWhiteSpace(_subscriberName))
queue.DequeueOptions.ConsumerName = subscriberName;
// Try opening the connection. We know the connection is not currently open because of the call to IsListening
// earlier
Logger.Write("OracleAQXmlListener(Low-level): Opening the connection:" + _queueName,
"Information", StandardPriorities.Low, TraceEventType.Information);
_connection.Open();++
// Now register the callback method
// This must be done on an open connection
Logger.Write("OracleAQXmlListener(Low-level): Registering the callback:" + _queueName,
"Information", StandardPriorities.Low, TraceEventType.Information);
queue.MessageAvailable += new OracleAQMessageAvailableEventHandler(QueueMessageAvailable);
// Note that the message handler above only fires when a message arrives on the queue, it does
// not take account of messages that may already be on the queue.
// So we will be a little pro-active and process any messages that are on the queue currently
ReadQueueMessages(_connection, _queue);
...just for good measure...
private void ReadQueueMessages(OracleConnection connection, OracleAQQueue queue)
const int NO_MESSAGES_ON_QUEUE = 25228; // this is the number of the exception thrown by Oracle when
// there is a timeout on the queue.
// We hardwire the "listen" timeout value to be zero, so this
// exception essentially gets raised when there are no more
// messages to process
bool queueEmpty = false;
OracleTransaction tx = null;
try
while (false == queueEmpty)
try
tx = connection.BeginTransaction();
OracleAQMessage msg = queue.Dequeue();
tx.Commit();
FireReceiveEvent(msg);
catch (OracleException oex)
if (NO_MESSAGES_ON_QUEUE == oex.Number)
queueEmpty = true;
else
throw (oex);
// We'll hook into the event at this point. In its normal state, the event is set/signalled, and
// execution just flows through the call below (which returns immediately).
// However the event will be in a non-signalled state if the user has requested to shut down the
// service.
// In this event, the line below will block any forther flow.
// This is exactly what we want, however, because at this point in time we're in a totally clean state
// (i.e. we're not halfway through processing a message!)
_pauseEvent.WaitOne();
catch (Exception ex)
// Okay, an exception was thrown in the above block.
// First off, rollback any ongoing transaction
if (null != tx) tx.Rollback();
string sMessage = "MsmqListener(Low-level): OnReceiveCompleted throws Exception on queue: " + _queueName;
ex.Data.Add("Identifier", sMessage);
ExceptionReporting.ReportException(ex, "DefaultExceptionPolicy");
finally
if (null != tx)
tx.Dispose();
tx = null;
Edited by: Peter Hurford on 07-Mar-2011 05:55
Edited by: Peter Hurford on 07-Mar-2011 05:56