Esempio n. 1
0
        private void PluginProcessing()
        {
            try
            {
                foreach (var handler in _limitHandlers)
                {
                    ProcessHandlerBase currentHandler = handler;
                    var thread = new Thread(() =>
                    {
                        while (_running)
                        {
                            if (currentHandler.CanProcess())
                            {
                                try
                                {
                                    currentHandler.Handle();
                                }
                                catch (Exception ex)
                                {
                                    if (BlockLimiterConfig.Instance.EnableLog)
                                    {
                                        Log.Warn("Handler Problems: {0} - {1}", currentHandler.GetUpdateResolution(),
                                                 ex);
                                    }
                                }

                                currentHandler.LastUpdate = DateTime.Now;
                            }

                            Thread.Sleep(100);
                        }
                    });
                    _processThreads.Add(thread);
                    thread.Start();
                }

                foreach (Thread thread in _processThreads)
                {
                    thread.Join();
                }
            }
            catch (ThreadAbortException ex)
            {
                if (BlockLimiterConfig.Instance.EnableLog)
                {
                    Log.Trace(ex);
                }
            }
            catch (Exception ex)
            {
                if (BlockLimiterConfig.Instance.EnableLog)
                {
                    Log.Error(ex);
                }
            }
        }
Esempio n. 2
0
        private void PluginProcessing()
        {
            try
            {
                foreach (ProcessHandlerBase handler in _processHandlers)
                {
                    ProcessHandlerBase currentHandler = handler;
                    var thread = new Thread(() =>
                    {
                        while (_running)
                        {
                            if (currentHandler.CanProcess())
                            {
                                try
                                {
                                    currentHandler.Handle();
                                }
                                catch (Exception ex)
                                {
                                    Log.Warn("Handler Problems: {0} - {1}", currentHandler.GetUpdateResolution(), ex);
                                }

                                // Let's make sure LastUpdate is set to now otherwise we may start processing too quickly
                                currentHandler.LastUpdate = DateTime.Now;
                            }

                            Thread.Sleep(100);
                        }
                    });

                    _processThreads.Add(thread);
                    thread.Start();
                }

                foreach (Thread thread in _processThreads)
                {
                    thread.Join();
                }
            }
            catch (ThreadAbortException ex)
            {
                Log.Trace(ex);
            }
            catch (Exception ex)
            {
                Log.Error(ex);
            }
            finally
            {
                MyEntities.OnEntityAdd    -= OnEntityAdd;
                MyEntities.OnEntityRemove -= OnEntityRemove;
            }
        }
Esempio n. 3
0
        private void ProcessLoop()
        {
            try
            {
                foreach (ProcessHandlerBase handler in _processHandlers)
                {
                    ProcessHandlerBase currentHandler = handler;
                    Thread             thread         = new Thread(() =>
                    {
                        while (_running)
                        {
                            if (currentHandler.CanProcess())
                            {
                                try
                                {
                                    currentHandler.Handle();
                                }
                                catch (Exception ex)
                                {
                                    Log.Error("Thread Exception: {0} - {1}", currentHandler.GetUpdateResolution(), ex);
                                }
                                currentHandler.LastUpdate = DateTime.Now;
                            }
                            Thread.Sleep(100);
                        }
                    });
                    _processThreads.Add(thread);
                    thread.Start();
                }
                foreach (Thread thread in _processThreads)
                {
                    thread.Join();
                }

                while (true)
                {
                    if (DateTime.Now - m_lastProcessUpdate > TimeSpan.FromMilliseconds(100))
                    {
                        m_lastProcessUpdate = DateTime.Now;
                    }
                    Thread.Sleep(25);
                }
            }
            catch (Exception ex)
            {
                Log.Error(ex);
            }
        }