public DataTransmitServerService() : base()
        {
            _cache = new Manager <string, Tag>();

            try
            {
                using (TransmitServerConnectService tscs = TransmitServerConnectService.Instance)
                {
                    tscs.DeleteAllTransmitServerConnect();
                }

                using (TransmitServerService tss = TransmitServerService.Instance)
                {
                    _transmitServer = tss.GetTransmitServer();
                    if (_transmitServer != null)
                    {
                        using (PublicTagService ptc = PublicTagService.Instance)
                        {
                            IList <TagConfig> publicTags = ptc.GetPublicTagsOfService(_transmitServer.Id);
                            foreach (TagConfig tc in publicTags)
                            {
                                TagConfigs.Add(tc);
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                OnServiceLog(ex.Message);
            }
        }
Beispiel #2
0
        public DataTransmitClientService() : base()
        {
            _cache          = new Manager <string, Tag>();
            _transmits      = new ConcurrentDictionary <TransmitClient, IList <TagConfig> >();
            _channelManager = new ChannelManager();
            _connDictionary = new ConcurrentDictionary <string, SocketAsyncEventArgs>();
            _transmitTasks  = new List <Thread>();

            using (TransmitClientService tcs = TransmitClientService.Instance)
            {
                IList <TransmitClient> tcList = tcs.GetAllTransmitClient();
                if (tcList.Count > 0)
                {
                    using (PublicTagService pts = PublicTagService.Instance)
                    {
                        foreach (TransmitClient tc in tcList)
                        {
                            IList <TagConfig> tagConfigs = pts.GetPublicTagsOfService(tc.Id);

                            foreach (TagConfig tag in tagConfigs)
                            {
                                if (TagConfigs.FirstOrDefault(t => t.Id == tag.Id) == null)
                                {
                                    TagConfigs.Add(tag);
                                }
                            }

                            _transmits.TryAdd(tc, tagConfigs);
                        }
                    }
                }
            }
        }
Beispiel #3
0
 public OPCServerService() : base()
 {
     try
     {
         using (PublicOpcServerService poss = PublicOpcServerService.Instance)
         {
             _posModel = poss.GetPublicOpcServer();
             if (_posModel != null)
             {
                 using (PublicTagService ptc = PublicTagService.Instance)
                 {
                     IList <TagConfig> publicTags = ptc.GetPublicTagsOfService(_posModel.Id);
                     foreach (TagConfig tc in publicTags)
                     {
                         TagConfigs.Add(tc);
                     }
                 }
             }
         }
     }
     catch (Exception ex)
     {
         OnServiceLog(ex.Message);
     }
 }