private void ASyncReadButton_Click(System.Object sender, System.EventArgs e)
{
try
{
_mRequest = null;
_mHandle = 0;
var subscription = OpcController.Subscription;
if (subscription != null)
{
// Begin the asynchronous read request.
if ((subscription.Items != null))
{
StatusBar.Text = "OPC Group Async Read in progress ...";
ReadCompleteEventHandler rceh = OnReadComplete;
subscription.Read(subscription.Items, +_mHandle, rceh, out _mRequest);
}
}
// Update controls if request successful.
if ((_mRequest != null))
{
ASyncReadButton.Enabled = false;
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
//======================================================================
// Asynchronous I/O
/// <summary>
/// Begins an asynchronous read operation for a set of items.
/// </summary>
/// <param name="items">The set of items to read (must include the server handle).</param>
/// <param name="requestHandle">An identifier for the request assigned by the caller.</param>
/// <param name="callback">A delegate used to receive notifications when the request completes.</param>
/// <param name="request">An object that contains the state of the request (used to cancel the request).</param>
/// <returns>A set of results containing any errors encountered when the server validated the items.</returns>
public IdentifiedResult[] Read(
Item[] items,
object requestHandle,
ReadCompleteEventHandler callback,
out IRequest request)
{
return(m_subscription.Read(items, requestHandle, callback, out request));
}
//======================================================================
// Asynchronous I/O
/// <summary>
/// Begins an asynchronous read operation for a set of items.
/// </summary>
/// <param name="items">The set of items to read (must include the server handle).</param>
/// <param name="requestHandle">An identifier for the request assigned by the caller.</param>
/// <param name="callback">A delegate used to receive notifications when the request completes.</param>
/// <param name="request">An object that contains the state of the request (used to cancel the request).</param>
/// <returns>A set of results containing any errors encountered when the server validated the items.</returns>
public IdentifiedResult[] Read(
Item[] items,
object requestHandle,
ReadCompleteEventHandler callback,
out IRequest request)
{
throw new NotImplementedException("BeginRead");
}
/// <summary>
/// 异步读取数据
/// </summary>
/// <param name="itemClientHandles"></param>
/// <param name="requestHandle"></param>
/// <param name="callback"></param>
/// <param name="request"></param>
/// <returns></returns>
public IdentifiedResult[] AsyncRead(
object[] itemClientHandles,
object requestHandle,
ReadCompleteEventHandler callback,
out IRequest request)
{
if (itemClientHandles == null)
{
throw new ArgumentNullException("items");
}
if (callback == null)
{
throw new ArgumentNullException("callback");
}
request = null;
// check if nothing to do.
if (itemClientHandles.Length == 0)
{
return(new IdentifiedResult[0]);
}
lock (this)
{
if (this.m_group == null)
{
throw new Exception("The remote server is not currently connected.");
}
// ensure a callback connection is established with the server.
if (m_connection == null)
{
Advise();
}
// get item ids.
ItemIdentifier[] itemIDs = null;
lock (m_items)
{
itemIDs = m_items.GetItemIDs(itemClientHandles);
}
// create request object.
OpcRequest internalRequest = new OpcRequest(
this,
requestHandle,
m_filters,
m_counter++,
callback);
// register request with callback object.
m_callback.BeginRequest(internalRequest);
request = internalRequest;
// begin read request.
IdentifiedResult[] results = null;
int cancelID = 0;
try
{
results = BeginRead(itemIDs, internalRequest.RequestID, out cancelID);
}
catch (Exception e)
{
m_callback.EndRequest(internalRequest);
throw e;
}
// apply request options.
//lock (m_items)
//{
// m_items.ApplyFilters(m_filters | (int)ResultFilter.ClientHandle, results);
//}
lock (internalRequest)
{
// check if all results have already arrived - this invokes the callback if this is the case.
if (internalRequest.BeginRead(cancelID, results))
{
m_callback.EndRequest(internalRequest);
request = null;
}
}
// return initial results.
return(results);
}
}
/// <summary>
/// Begins an asynchronous read operation for a set of items.
/// </summary>
/// <param name="items">The set of items to read (must include the server handle).</param>
/// <param name="requestHandle">An identifier for the request assigned by the caller.</param>
/// <param name="callback">A delegate used to receive notifications when the request completes.</param>
/// <param name="request">An object that contains the state of the request (used to cancel the request).</param>
/// <returns>A set of results containing any errors encountered when the server validated the items.</returns>
public IdentifiedResult[] Read(
Item[] items,
object requestHandle,
ReadCompleteEventHandler callback,
out IRequest request)
{
if (items == null)
{
throw new ArgumentNullException("items");
}
lock (this)
{
request = null;
// handle trivial case.
if (items.Length == 0)
{
return(new IdentifiedResult[0]);
}
// validate the items.
ArrayList validItems = new ArrayList();
IdentifiedResult[] results = new IdentifiedResult[items.Length];
for (int ii = 0; ii < items.Length; ii++)
{
// initialize result with item.
results[ii] = new IdentifiedResult(items[ii]);
// check for invalid handle.
if (items[ii].ServerHandle == null)
{
results[ii].ResultID = ResultID.Da.E_INVALIDHANDLE;
continue;
}
// lookup subscription item.
SubscriptionItem item = (SubscriptionItem)m_items[items[ii].ServerHandle];
if (item == null)
{
results[ii].ResultID = ResultID.Da.E_INVALIDHANDLE;
continue;
}
// at least one valid item exists.
validItems.Add(items[ii]);
}
if (validItems.Count > 0)
{
request = new Opc.Da.Request(this, requestHandle);
m_requests.Add(request, callback);
ThreadPool.QueueUserWorkItem(new WaitCallback(OnRead), new object[] { request, validItems.ToArray(typeof(Item)) });
}
// apply result filters.
ApplyFilters(m_filters, results);
// return results.
return(results);
}
}
