public async Task <bool[]> CreateMonitoredItemsAsync(string serverUrl, MonitorableNode[] monitorableNodes,
                                                             string brokerUrl, string topic)
        {
            var session = await GetSessionAsync(serverUrl);

            MonitorPublishInfo monitorInfo;

            const string pattern  = @"^(mqtt|signalr):(.*)$";
            var          match    = Regex.Match(brokerUrl, pattern);
            var          protocol = match.Groups[1].Value;
            var          url      = match.Groups[2].Value;

            var publisher = PublisherFactory.GetPublisherForProtocol(protocol, url);

            //Set publishInterval to minimum samplinginterval
            var publishInterval = monitorableNodes.Select(elem => elem.SamplingInterval).Min();

            lock (_monitorPublishInfo)
            {
                //Check if a Subscription for the
                if (_monitorPublishInfo.ContainsKey(serverUrl))
                {
                    monitorInfo = _monitorPublishInfo[serverUrl].FirstOrDefault(info => info.Topic == topic && info.BrokerUrl == url);
                    if (monitorInfo == null)
                    {
                        monitorInfo = new MonitorPublishInfo()
                        {
                            Topic        = topic,
                            BrokerUrl    = url,
                            Subscription = CreateSubscription(session, publishInterval, 0),
                            Publisher    = publisher
                        };
                        _monitorPublishInfo[serverUrl].Add(monitorInfo);
                    }
                    else if (monitorInfo.Subscription.PublishingInterval > publishInterval)
                    {
                        monitorInfo.Subscription.PublishingInterval = publishInterval;
                        monitorInfo.Subscription.Modify();
                    }
                }
                else
                {
                    monitorInfo = new MonitorPublishInfo()
                    {
                        Topic        = topic,
                        BrokerUrl    = url,
                        Subscription = CreateSubscription(session, publishInterval, 0),
                        Publisher    = publisher
                    };
                    var list = new List <MonitorPublishInfo> {
                        monitorInfo
                    };
                    _monitorPublishInfo.Add(serverUrl, list);
                }
            }

            var createdMonitoredItems = new List <MonitoredItem>();

            foreach (var monitorableNode in monitorableNodes)
            {
                var mi = new MonitoredItem()
                {
                    StartNodeId      = PlatformUtils.ParsePlatformNodeIdString(monitorableNode.NodeId),
                    DisplayName      = monitorableNode.NodeId,
                    SamplingInterval = monitorableNode.SamplingInterval
                };

                if (monitorableNode.DeadBand != "none")
                {
                    mi.Filter = new DataChangeFilter()
                    {
                        Trigger       = DataChangeTrigger.StatusValue,
                        DeadbandType  = (uint)(DeadbandType)Enum.Parse(typeof(DeadbandType), monitorableNode.DeadBand, true),
                        DeadbandValue = monitorableNode.DeadBandValue
                    };
                }

                mi.Notification += OnMonitorNotification;
                monitorInfo.Subscription.AddItem(mi);
                var monitoredItems = monitorInfo.Subscription.CreateItems();
                createdMonitoredItems.AddRange(monitoredItems);
            }

            var results = createdMonitoredItems.Distinct().Select(m => m.Created).ToArray();

            foreach (var monitoredItem in createdMonitoredItems.Where(m => !m.Created))
            {
                monitorInfo.Subscription.RemoveItem(monitoredItem);
            }

            return(results);
        }