Updating Data Asynchronously Using Message Queuing

[ Team LiB ]


Recipe 4.13 Updating Data Asynchronously Using Message Queuing
Problem
You need to asynchronously update data on a database on system that is not always
connected.
Solution
You must use message queuing and an XML DiffGram to:
•
Construct and send an MSMQ message containing a DiffGram to the server.
•
Extract the DiffGram from the message and use it to update the data source at the
server.
•
Construct and send a message containing the latest DataSet to the client.
•
Retrieve the response at the client and deserialize it into a DataSet.
The sample code contains four event handlers:
Form.Load
Sets up the sample by loading a DataSet with the Customers table from the
Northwind database. The default view of the table is bound to a data grid on the
form.
Send Update Button.Click
Checks if the update message queue exists and creates it if necessary. A
MessageQueue object is created to access the queue. A message is created
containing a DiffGram of the changes made to the DataSet containing the
Customers table. This message is sent to the update queue.
Process Update Button.Click
Checks if the update message queue exists and creates it if necessary. A
MessageQueue object is created to access the queue. An attempt is made to

receive a message from the queue, waiting one second before giving up. If a
message is received, a DataAdapter that uses a CommandBuilder to generate
updating logic is created and used to update the database with the changes in the
DataSet contained in the body of the message. The latest version of the Customers
table is retrieved into a new DataSet. A result queue is created if necessary and a
message containing the latest DataSet is sent to the queue.
Receive Update Button.Click
Checks if the result message queue exists and creates it if necessary. A
MessageQueue object is created to access the queue and the formatter set to
deserialize the DataSet in the message bodies. An attempt is made to receive a
message from the queue, waiting one second before giving up. If a message is
received, the DataSet in the body is deserialized and the default view of the
Categories DataTable is bound to the data grid on the form.
The C# code is shown in Example 4-32
.
Example 4-32. File: MessageQueueUpdateForm.cs
// Namespaces, variables, and constants
using System;
using System.Configuration;
using System.Windows.Forms;
using System.Messaging;
using System.Data;
using System.Data.SqlClient;

private const String CUSTOMERS_TABLE = "Customers";

private const String QUEUENAMEUPDATE = @".\Private$\adodotnetcb0413update";
private const String QUEUENAMERESULT = @".\Private$\adodotnetcb0413result";

private DataSet ds;

// . . .

private void MessageQueueUpdateForm_Load(object sender, System.EventArgs e)
{
// As a starting point, load the data directly.
// Create the DataAdapter to load customers data.
SqlDataAdapter da = new SqlDataAdapter("SELECT * FROM Customers",
ConfigurationSettings.AppSettings["Sql_ConnectString"]);
// Get the schema and data for the customers table.
ds = new DataSet( );
da.FillSchema(ds, SchemaType.Source, CUSTOMERS_TABLE);
da.Fill(ds, CUSTOMERS_TABLE);

// Bind the default view of the customers table to the grid.
dataGrid.DataSource = ds.Tables[CUSTOMERS_TABLE].DefaultView;
}

private void sendUpdateButton_Click(object sender, System.EventArgs e)
{
// Create the result queue if it does not exist.
if(!MessageQueue.Exists(QUEUENAMEUPDATE))
MessageQueue.Create(QUEUENAMEUPDATE);

// Create an object to access the result queue.
MessageQueue mq = new MessageQueue(QUEUENAMEUPDATE);
// Set the formatter for serialization of message bodies.
mq.Formatter = new XmlMessageFormatter(new Type[] {typeof(DataSet)});

// Create a message containing the changes.

mq.Send(ds.GetChanges( ));

MessageBox.Show("Update message sent.","MessageQueue Update",
MessageBoxButtons.OK, MessageBoxIcon.Information);
}

private void processUpdateButton_Click(object sender, System.EventArgs e)
{
// Create the result queue if it does not exist.
if(!MessageQueue.Exists(QUEUENAMEUPDATE))
MessageQueue.Create(QUEUENAMEUPDATE);

// Create an object to access the result queue.
MessageQueue mq = new MessageQueue(QUEUENAMEUPDATE);
// Set the formatter for deserialization of message bodies.
mq.Formatter = new XmlMessageFormatter(new Type[] {typeof(DataSet)});

// Receive a message from the query queue.
System.Messaging.Message msg;
try
{
msg = mq.Receive(new TimeSpan(0,0,1));
}
catch(MessageQueueException ex)
{
MessageBox.Show(ex.Message, "MessageQueue Receive Error",
MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}

// Create the DataAdapter and CommandBuilder to update.
SqlDataAdapter da =
new SqlDataAdapter("SELECT * FROM " + CUSTOMERS_TABLE,
ConfigurationSettings.AppSettings["Sql_ConnectString"]);
SqlCommandBuilder cb = new SqlCommandBuilder(da);

if (msg.BodyStream.Length > 0)
{
// Get the DataSet of changes from the message body.
DataSet dsChanges = (DataSet)msg.Body;

// Process the updates.
da.Update(dsChanges, CUSTOMERS_TABLE);
}

// Get the updated DataSet.
DataSet dsUpdate = new DataSet( );
da.Fill(dsUpdate, CUSTOMERS_TABLE);

// Create the result queue if it does not exist.
if(!MessageQueue.Exists(QUEUENAMERESULT))
MessageQueue.Create(QUEUENAMERESULT);

// Create an object to access the result queue.
mq = new MessageQueue(QUEUENAMERESULT);
// Send a message with the update DataSet to the queue.
mq.Send(dsUpdate);

MessageBox.Show("Update processed. Refreshed DataSet sent.",
"MessageQueue Process", MessageBoxButtons.OK,

MessageBoxIcon.Information);
}

private void receiveUpdateButton_Click(object sender, System.EventArgs e)
{
// Create the result queue if it does not exist.
if(!MessageQueue.Exists(QUEUENAMERESULT))
MessageQueue.Create(QUEUENAMERESULT);

// Create an object to access the result queue.
MessageQueue mq = new MessageQueue(QUEUENAMERESULT);
// Set the formatter for deserialization of message bodies.
mq.Formatter = new XmlMessageFormatter(new Type[] {typeof(DataSet)});

// Receive a message from the result queue.
System.Messaging.Message msg;
try
{
msg = mq.Receive(new TimeSpan(0,0,1));
}
catch(MessageQueueException ex)
{
MessageBox.Show("ERROR: " + ex.Message, "MessageQueue Receive",
MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}

// Refresh the DataSet underlying the DataGrid.
ds = (DataSet)msg.Body;
dataGrid.DataSource = ds.Tables[CUSTOMERS_TABLE].DefaultView;

MessageBox.Show("Retrieved and loaded refreshed data.",
"MessageQueue Receive", MessageBoxButtons.OK,
MessageBoxIcon.Information);
}
Discussion
The discussion in Recipe 2.22
provides an overview of Message Queuing (MSMQ).
For more information about DiffGrams, see Recipe 8.8
.
[ Team LiB ]