/// <summary>
/// Begins an asynchronous write operation for a set of items.
/// </summary>
/// <param name="items">The set of item values to write (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[] Write(
ItemValue[] items,
object requestHandle,
WriteCompleteEventHandler callback,
out IRequest request)
{
throw new NotImplementedException("BeginRead");
}
/// <summary>
/// Begins an asynchronous write operation for a set of items.
/// </summary>
/// <param name="items">The set of item values to write (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[] Write(
ItemValue[] items,
object requestHandle,
WriteCompleteEventHandler callback,
out IRequest request)
{
return(m_subscription.Write(items, requestHandle, callback, out request));
}
/// <summary>
/// Completes an asynchronous write request.
/// </summary>
private void OnWrite(object stateInfo)
{
try
{
do
{
object requestHandle = null;
IdentifiedResult[] results = null;
WriteCompleteEventHandler callback = null;
lock (this)
{
// check if subscription object has been disposed.
if (m_disposed)
{
return;
}
// check if write queue has emptied.
if (m_writeQueue.Count == 0)
{
break;
}
// get operation parameters.
object[] parameters = (object[])m_writeQueue.Dequeue();
Opc.Da.Request request = (Opc.Da.Request)parameters[0];
ItemValue[] items = (ItemValue[])parameters[1];
requestHandle = request.Handle;
callback = (WriteCompleteEventHandler)m_requests[request];
// do write request if not cancelled.
if (callback != null)
{
m_requests.Remove(request);
results = Write(items);
}
}
// invoke callback.
if (callback != null)
{
callback(requestHandle, results);
}
}while (true);
}
catch (Exception e)
{
string message = e.Message;
}
}
public IdentifiedResult[] AsyncWrite(
ItemValue[] items,
object requestHandle,
WriteCompleteEventHandler callback,
out IRequest request)
{
if (items == null)
{
throw new ArgumentNullException("items");
}
if (callback == null)
{
throw new ArgumentNullException("callback");
}
request = null;
// check if nothing to do.
if (items.Length == 0)
{
return(new IdentifiedResult[0]);
}
lock (this)
{
if (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(items);
}
// 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 write request.
IdentifiedResult[] results = null;
int cancelID = 0;
try
{
results = BeginWrite(itemIDs, items, 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.BeginWrite(cancelID, results))
{
m_callback.EndRequest(internalRequest);
request = null;
}
}
// return initial results.
return(results);
}
}
/// <summary>
/// 异步写数据
/// </summary>
/// <param name="dataAddress"></param>
/// <param name="dataValue"></param>
/// <returns></returns>
public OperateResult AsyncWriteData(string dataAddress, string dataValue)
{
#region 检验
if (string.IsNullOrEmpty(dataAddress) || string.IsNullOrEmpty(dataValue))
{
return(new OperateResult("传入的参数都不能为空"));
}
if (_opcServer == null)
{
return(new OperateResult("OPCServer未能正确初始化！"));
}
if (!_opcServer.IsConnected)
{
return(new OperateResult("OPCServer连接错误！"));
}
#endregion
string groupName = "AsyncWriteData";
OpcGroup group = _opcServer.FindGroupByName(groupName);
if (group != null)
{
_opcServer.RemoveGroup(group);
}
group = _opcServer.AddGroup(groupName, 1, false); //添加组
string datavalue = dataValue.Split('|')[0];
WriteCompleteEventHandler writeFinishHandler = WriteFinishHandler;
IRequest request;
#region 添加Item及写入Item
if ((dataAddress.Contains(',')) && (OPCServerName == _RSLinxOPC)) //RSLinx 数组的写入
{
//地址前缀,类型,起始位置,长度
#region RSLinx 数组及地址串
string[] tags = dataAddress.Split(',');
if (tags.Length < 3)
{
return(new OperateResult("RSLinx 地址错误"));
}
string mainAddress = tags[0]; //主地址
string type = tags[1]; //类型
int beginIndex = SafeConverter.SafeToInt(tags[2]); //开始索引
int length = SafeConverter.SafeToInt(tags[3]); //长度
string endStr = (tags.Length > 4) ? tags[4] : "";
Guid[] handels = new Guid[length];
string[] address = new string[length];
string[] values = new string[length];
for (int i = 0; i < length; i++)
{
handels[i] = Guid.NewGuid();
values[i] = datavalue.Length > i ? datavalue[i].ToString() : "0"; //默认为0
if (type.ToLower() == "array") //数组型
{
address[i] = mainAddress + "[" + (i + beginIndex).ToString() + "]";
}
else //连续地址
{
address[i] = mainAddress + type + (i + beginIndex).ToString() + endStr;
}
}
ItemResult[] itemResults = group.AddItems(address, handels);
ItemValue[] itemValues = new ItemValue[length];
for (int i = 0; i < length; i++)
{
itemValues[i] = new ItemValue(itemResults[i])
{
Value = values[i]
};
}
group.AsyncWrite(itemValues, handels, writeFinishHandler, out request);
#endregion
}
else //正常类型
{
Guid[] handel = new[] { Guid.NewGuid() };
ItemResult[] itemResults = group.AddItems(new[] { dataAddress }, handel);
ItemValue itemValue = new ItemValue(itemResults[0])
{
Value = datavalue,
};
group.AsyncWrite(new ItemValue[] { itemValue }, handel, writeFinishHandler, out request);
}
#endregion
return(OperateResult.CreateSuccessResult());
}
/// <summary>
/// Begins an asynchronous write operation for a set of items.
/// </summary>
/// <param name="items">The set of item values to write (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[] Write(
ItemValue[] items,
object requestHandle,
WriteCompleteEventHandler 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);
m_writeQueue.Enqueue(new object[] { request, validItems.ToArray(typeof(ItemValue)) });
ThreadPool.QueueUserWorkItem(new WaitCallback(OnWrite));
}
// apply result filters.
ApplyFilters(m_filters, results);
// return results.
return(results);
}
}
