Opc.Ua.ServerTest.SubscribeTest.CreateMonitoredItems C# (CSharp) Method

CreateMonitoredItems() private method

Creates the monitored items.
private CreateMonitoredItems ( Subscription subscription, MonitoredItemCreateRequestCollection itemsToCreate, List monitoredItems ) : bool
subscription Subscription
itemsToCreate MonitoredItemCreateRequestCollection
monitoredItems List
return bool
        private bool CreateMonitoredItems(
            Subscription subscription, 
            MonitoredItemCreateRequestCollection itemsToCreate,
            List<MonitoredItem> monitoredItems)
        {   
            try
            {
                RequestHeader requestHeader = new RequestHeader();
                requestHeader.ReturnDiagnostics = 0;

                MonitoredItemCreateResultCollection results;
                DiagnosticInfoCollection diagnosticInfos;

                ResponseHeader responseHeader = Session.CreateMonitoredItems(
                    requestHeader,
                    subscription.SubscriptionId,
                    TimestampsToReturn.Both,
                    itemsToCreate,
                    out results,
                    out diagnosticInfos);

                ClientBase.ValidateResponse(results, itemsToCreate);
                ClientBase.ValidateDiagnosticInfos(diagnosticInfos, itemsToCreate);
                                
                if (diagnosticInfos != null && diagnosticInfos.Count > 0)
                {
                    Log("Returned non-empty DiagnosticInfos array during CreateMonitoredItems.");
                    return false;
                }

                bool success = true;
                DateTime updateTime = responseHeader.Timestamp;
                
                for (int ii = 0; ii < itemsToCreate.Count; ii++)
                {
                    MonitoredItemCreateRequest request = itemsToCreate[ii];
                    MonitoredItemCreateResult result = results[ii];
                    Node node = (Node)request.Handle;

                    if (StatusCode.IsBad(result.StatusCode))
                    {
                        if (!VerifyBadAttribute(node, request.ItemToMonitor.AttributeId, result.StatusCode))
                        {
                            success = false;
                        }

                        continue;
                    }
                    
                    // check if attribute is not supposed to be valid for node.
                    if (!Attributes.IsValid(node.NodeClass, request.ItemToMonitor.AttributeId))
                    {
                        Log(
                            "CreateMonitoredItem accepted for invalid attribute Node '{0}'. NodeId = {1}, NodeClass = {2}, Attribute = {3}",
                            node,
                            node.NodeId,
                            node.NodeClass,
                            Attributes.GetBrowseName(request.ItemToMonitor.AttributeId));

                        success = false;
                        continue;
                    }

                    // check filter result.
                    if (request.RequestedParameters.Filter == null)
                    {
                        if (!ExtensionObject.IsNull(result.FilterResult))
                        {
                            Log(
                                "Server returned a non-null filter result for Node '{0}', NodeId = {1}, AttributeId = {2}, FilterResult = {3}",
                                node,
                                node.NodeId,
                                Attributes.GetBrowseName(request.ItemToMonitor.AttributeId),
                                result.FilterResult);

                            success = false;
                            continue;
                        }
                    }

                    MonitoredItem monitoredItem = new MonitoredItem();
                    
                    monitoredItem.MonitoredItemId = result.MonitoredItemId;
                    monitoredItem.Node = node;
                    monitoredItem.TimestampsToReturn = TimestampsToReturn.Both;
                    monitoredItem.DiagnosticsMasks = 0;
                    monitoredItem.AttributeId = request.ItemToMonitor.AttributeId;
                    monitoredItem.MonitoringMode = request.MonitoringMode;
                    monitoredItem.ClientHandle = request.RequestedParameters.ClientHandle;
                    monitoredItem.SamplingInterval = result.RevisedSamplingInterval;
                    monitoredItem.QueueSize = result.RevisedQueueSize;
                    monitoredItem.DiscardOldest = request.RequestedParameters.DiscardOldest;
                    monitoredItem.Filter = ExtensionObject.ToEncodeable(request.RequestedParameters.Filter) as MonitoringFilter;
                    monitoredItem.UpdateTime = updateTime;
                    
                    monitoredItems.Add(monitoredItem);
                }
                
                return success;              
            }
            catch (Exception e)
            {
                Log(e, "CreateMonitoredItems Failed.");
                return false;
            } 
        }