/// <summary> /// Changes the requested data type for one or more items in a group. /// </summary> /// <param name="items">The group items.</param> /// <param name="requestedTypes">Array of new Requested Datatypes to be stored.</param> /// <returns> /// Array of HRESULTs. Indicates which items were successfully affected. /// </returns> /// <exception cref="System.ArgumentException">Wrong size of requested types array.;requestedTypes</exception> public HRESULT[] SetDataTypes(IList <OpcDaItem> items, IList <Type> requestedTypes) { CheckItems(items); if (items.Count != requestedTypes.Count) { throw new ArgumentException("Wrong size of requested types array.", "requestedTypes"); } int[] serverHandles = ArrayHelpers.GetServerHandles(items); IList <VarEnum> requestedDatatypes = requestedTypes.Select(TypeConverter.ToVarEnum).ToArray(); HRESULT[] ppErrors = As <OpcItemMgt>().SetDatatypes(serverHandles, requestedDatatypes); var changedItems = new List <OpcDaItem>(items.Count); for (int index = 0; index < items.Count; index++) { if (ppErrors[index].Succeeded) { OpcDaItem item = items[index]; item.RequestedDataType = requestedTypes[index]; changedItems.Add(item); } } OnItemsChanged(new OpcDaItemsChangedEventArgs(null, null, changedItems.ToArray())); return(ppErrors); }
private OpcDaItemResult[] CreateItemResults(IList <OpcDaItemDefinition> itemDefinitions, OPCITEMDEF[] pItemArray, OPCITEMRESULT[] opcDaItemResults, HRESULT[] ppErrors, bool setGroup) { var results = new OpcDaItemResult[pItemArray.Length]; for (int index = 0; index < opcDaItemResults.Length; index++) { OPCITEMRESULT opcItemResult = opcDaItemResults[index]; OpcDaItemDefinition opcItemDefinition = itemDefinitions[index]; HRESULT error = ppErrors[index]; if (error.Succeeded) { var item = new OpcDaItem(opcItemDefinition, opcItemResult, setGroup ? this : null) { UserData = opcItemDefinition.UserData }; results[index] = new OpcDaItemResult(item, error); } else { results[index] = new OpcDaItemResult(null, error); } } return(results); }
private void UpdateClientHandles() { if (_items.Count == 0) // nothing to update { return; } var serverHandles = new int[_items.Count]; var clientHandles = new int[_items.Count]; for (int i = 0; i < _items.Count; i++) { OpcDaItem item = _items[i]; serverHandles[i] = item.ServerHandle; clientHandles[i] = i; } HRESULT[] errors = SetClientHandles(serverHandles, clientHandles); for (int i = 0; i < errors.Length; i++) { if (errors[i].Succeeded) // Update only for succeded { _items[i].ClientHandle = i; } } }
internal OpcDaItem GetItem(int clientHandle) { if (clientHandle < _items.Count) { OpcDaItem opcDaItem = _items[clientHandle]; if (opcDaItem.ClientHandle == clientHandle) { return(opcDaItem); } } return(_items.SingleOrDefault(i => i.ClientHandle == clientHandle)); }
/// <summary> /// Synchronizes the group items. It means existing items will be replaced with new items. It fires ItemsChanged event /// after synchronization. /// </summary> public void SyncItems() { IEnumOPCItemAttributes enumerator = As <OpcItemMgt>().CreateEnumerator(); List <OPCITEMATTRIBUTES> itemAttributes = enumerator.EnumareateAllAndRelease(OpcConfiguration.BatchSize); OpcDaItem[] oldItems = _items.ToArray(); _items.Clear(); foreach (OPCITEMATTRIBUTES opcitemattributes in itemAttributes) { var item = new OpcDaItem(opcitemattributes, this); _items.Add(item); } OnItemsChanged(new OpcDaItemsChangedEventArgs(_items.ToArray(), oldItems, null)); }
/// <summary> /// Sets one or more items in a group to active or inactive. This controls whether or not valid data can be obtained /// from Read CACHE for those items and whether or not they are included in the OnDataChange subscription to the group. /// </summary> /// <param name="items">The group items.</param> /// <param name="isActive">If set to <c>true</c> items are to be activated, otherwise items are to be deactivated.</param> /// <returns> /// Array of HRESULTs. Indicates which items were successfully affected. /// </returns> public HRESULT[] SetActiveItems(IList <OpcDaItem> items, bool isActive = true) { CheckItems(items); int[] serverHandles = ArrayHelpers.GetServerHandles(items); HRESULT[] ppErrors = As <OpcItemMgt>().SetActiveState(serverHandles, isActive); var changedItems = new List <OpcDaItem>(items.Count); for (int index = 0; index < items.Count; index++) { if (ppErrors[index].Succeeded) { OpcDaItem item = items[index]; item.IsActive = isActive; changedItems.Add(item); } } OnItemsChanged(new OpcDaItemsChangedEventArgs(null, null, changedItems.ToArray())); return(ppErrors); }
/// <summary> /// Add one or more items to the group. /// </summary> /// <param name="itemDefinitions">The list of item definitions.</param> /// <returns> /// Array of item results. /// </returns> /// <exception cref="System.ArgumentNullException">itemDefinitions</exception> public OpcDaItemResult[] AddItems(IList <OpcDaItemDefinition> itemDefinitions) { if (itemDefinitions == null) { throw new ArgumentNullException("itemDefinitions"); } if (itemDefinitions.Count == 0) { return(new OpcDaItemResult[0]); } OPCITEMDEF[] pItemArray = ArrayHelpers.CreateOPITEMDEFs(itemDefinitions); HRESULT[] ppErrors; OPCITEMRESULT[] opcDaItemResults = As <OpcItemMgt>().AddItems(pItemArray, out ppErrors); OpcDaItemResult[] results = CreateItemResults(itemDefinitions, pItemArray, opcDaItemResults, ppErrors, true); var addedItems = new List <OpcDaItem>(itemDefinitions.Count); foreach (OpcDaItemResult result in results) { OpcDaItem item = result.Item; if (result.Error.Succeeded && item != null) { _items.Add(item); addedItems.Add(item); } } // Set client handles to index of items UpdateClientHandles(); OnItemsChanged(new OpcDaItemsChangedEventArgs(addedItems.ToArray(), null, null)); return(results); }
/// <summary> /// Initializes a new instance of the <see cref="OpcDaItemResult"/> class. /// </summary> /// <param name="item">The item.</param> /// <param name="error">The HRESULT of the operation.</param> public OpcDaItemResult(OpcDaItem item, HRESULT error) { Item = item; Error = error; }
/// <summary> /// Initializes a new instance of the <see cref="OpcDaItemResult"/> class. /// </summary> /// <param name="item">The item.</param> /// <param name="error">The HRESULT of the operation.</param> public OpcDaItemResult(OpcDaItem item, HRESULT error) { Item = item; Error = error; }
/// <summary> /// Initializes a new instance of the <see cref="OpcDaItemsChangedEventArgs"/> class. /// </summary> /// <param name="added">The added items.</param> /// <param name="removed">The removed items.</param> /// <param name="changed">The changed items.</param> public OpcDaItemsChangedEventArgs(OpcDaItem[] added, OpcDaItem[] removed, OpcDaItem[] changed) { Added = added; Removed = removed; Changed = changed; }