/// <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); } }