classe de item da thread
Наследование: IDisposable
Пример #1
0
        /// <summary>
        /// Evento executado quando a thread vai iniciar
        /// </summary>
        /// <param name="item"></param>
        protected void ThreadItem_OnStarted(ThreadItem item)
        {
#if DEBUG
            Debug.WriteLine(String.Format("Contagem em processamento: '{0}'.", FileSystemWatcher._pool.GetLifetimeService()));
#endif
            Auxiliar.WriteLog("O arquivo " + item.FileInfo.FullName + " iniciou o processamento (Data criação: " + item.FileInfo.LastWriteTime + ")", false);
            Processar(item);
        }
Пример #2
0
        /// <summary>
        /// Executa os passos do processamento do arquivo informado em item
        /// </summary>
        /// <param name="item">Item que deverá ser processado</param>
        private static void Processar(ThreadItem item)
        {
            FileSystemWatcher._pool.WaitOne();

            // A padding interval to make the output more orderly.
            int padding = Interlocked.Add(ref FileSystemWatcher._padding, 100);
            new Processar().ProcessaArquivo(item.Empresa, item.FileInfo.FullName);            
        }
Пример #3
0
        /// <summary>
        /// Inicia uma nova instancia e define o método de processamento
        /// </summary>
        /// <param name="processar">método que será chamado para processar o item</param>
        public BufferItem(ProcessarHandler processar)
        {
            Buffer = new Queue <ThreadItem>();

            if (timer == null)
            {
                //-------------------------------------------------------------------------
                // Inicia o timer com 500 milissegundos. Desta forma a execução será rápida
                // Como faz um "Stop" logo ao iniciar o método "Elapsed", não tem problema
                // de chamar com este tempo.
                //-------------------------------------------------------------------------
                timer = new System.Timers.Timer(500);

                timer.Elapsed += (s, e) =>
                {
                    lock (Buffer)
                    {
                        timer.Stop();

                        try
                        {
                            //-------------------------------------------------------------------------
                            // Recupera o threaditem e executa o mesmo
                            //-------------------------------------------------------------------------
                            while (Buffer.Count > 0)
                            {
                                ThreadItem item = Buffer.Dequeue();
                                if (item == null)
                                {
                                    continue;
                                }
                                Auxiliar.WriteLog("O arquivo " + item.FileInfo.FullName + " iniciou o processamento pelo Buffer (Data criação: " + item.FileInfo.LastWriteTime + ")", false);
                                processar.Invoke(item);
                                Thread.Sleep(0);
                                Auxiliar.WriteLog("O arquivo " + item.FileInfo.FullName + " finalizou o processamento pelo Buffer (Data criação: " + item.FileInfo.LastWriteTime + ")", false);
                                if (Disposed)
                                {
                                    return;          //cai fora ... foi descarregada
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            Auxiliar.WriteLog("ExceptionBuffer: " + ex.ToString(), false);
                        }
                        finally
                        {
                            //-------------------------------------------------------------------------
                            // Sair ... mas continuar executando de tempos em tempos
                            //-------------------------------------------------------------------------
                            timer.Start();
                        }
                    }
                };
            }

            timer.Start();
        }
Пример #4
0
        /// <summary>
        /// Executa os passos do processamento do arquivo informado em item
        /// </summary>
        /// <param name="item">Item que deverá ser processado</param>
        private static void Processar(ThreadItem item)
        {
            FileSystemWatcher._pool.WaitOne();

            // A padding interval to make the output more orderly.
            int padding = Interlocked.Add(ref FileSystemWatcher._padding, 100);

            new Processar().ProcessaArquivo(item.Empresa, item.FileInfo.FullName);
        }
Пример #5
0
        /// <summary>
        /// Evento executado quando o item é removido da fila de execução
        /// </summary>
        /// <param name="item"></param>
        protected void ThreadItem_OnReleased(ThreadItem item)
        {
            Auxiliar.WriteLog("O arquivo " + item.FileInfo.FullName + " foi descarregado da lista de processamento (Data criação: " + item.FileInfo.LastWriteTime + ")", false);

            //Se estiver reconfigurando o UniNFe, tem que reiniciar as threads
            if (item.FileInfo.FullName.IndexOf(Propriedade.ExtEnvio.AltCon_XML) >= 0 || item.FileInfo.FullName.IndexOf(Propriedade.ExtEnvio.AltCon_TXT) >= 0)
            {
                ThreadService.Stop();
                ThreadService.Start();
            }
        }
Пример #6
0
        /// <summary>
        /// Evento executado quando o item é removido da fila de execução
        /// </summary>
        /// <param name="item"></param>
        protected void ThreadItem_OnReleased(ThreadItem item)
        {
            Auxiliar.WriteLog("O arquivo " + item.FileInfo.FullName + " foi descarregado da lista de processamento (Data criação: " + item.FileInfo.LastWriteTime + ")", false);

            //Se estiver reconfigurando o UniNFe, tem que reiniciar as threads
            if (item.FileInfo.FullName.IndexOf(Propriedade.ExtEnvio.AltCon_XML) >= 0 || item.FileInfo.FullName.IndexOf(Propriedade.ExtEnvio.AltCon_TXT) >= 0)
            {
                ThreadService.Stop();
                ThreadService.Start();
            }
        }
Пример #7
0
        /// <summary>
        /// Evento executado quando a thread vai iniciar
        /// </summary>
        /// <param name="item"></param>
        protected void ThreadItem_OnStarted(ThreadItem item)
        {
            if (Empresas.Configuracoes.Count != 0)
            {
                Empresa empresa = Empresas.Configuracoes[item.Empresa];
            }

            //danasa 12/8/2011
            //mudei de posição e inclui o FullName
            Auxiliar.WriteLog("O arquivo " + item.FileInfo.FullName + " iniciou o processamento", false);
            Processar(item);
        }
Пример #8
0
        private void Processar(ThreadItem item)
        {
            if (String.IsNullOrEmpty(Thread.CurrentThread.Name))
            {
                if (item.FileInfo.DirectoryName.ToLower().EndsWith("geral\\temp"))
                {
                    item.Empresa = -1;
                }

                Thread.CurrentThread.Name = item.Empresa.ToString();
            }

            try
            {
                //avisa que vai iniciar
                if (OnStarted != null)
                {
                    OnStarted(item);
                }

                //avisa que vai finalizar
                if (OnEnded != null)
                {
                    OnEnded(item);
                }
            }
            catch (Exception ex)
            {
                Auxiliar.WriteLog("Ocorreu um erro na execução da thread que está sendo executada.\r\nThreadControl.cs (1)\r\n" + ex.Message, true);
            }
            finally
            {
                try
                {
                    //remove o item
                    //avisa que removeu o item
                    if (OnReleased != null)
                    {
                        OnReleased(item);
                    }
                }
                catch (Exception ex)
                {
                    Auxiliar.WriteLog("Ocorreu um erro ao tentar remover o item da Thread que está sendo executada.\r\nThreadControl.cs (2)\r\n" + ex.Message, true);
                }

                GC.Collect();
                GC.WaitForPendingFinalizers();
            }
        }
Пример #9
0
        /// <summary>
        /// Evento executado quando a thread vai iniciar
        /// </summary>
        /// <param name="item"></param>
        protected void ThreadItem_OnStarted(ThreadItem item)
        {
#if DEBUG
            Debug.WriteLine(String.Format("Contagem em processamento: '{0}'.", FileSystemWatcher._pool.GetLifetimeService()));
#endif
            if (Empresas.Configuracoes.Count != 0)
            {
                Empresa empresa = Empresas.Configuracoes[item.Empresa];
            }

            //danasa 12/8/2011
            //mudei de posição e inclui o FullName
            Auxiliar.WriteLog("O arquivo " + item.FileInfo.FullName + " iniciou o processamento (Data criação: " + item.FileInfo.LastWriteTime + ")", false);
            Processar(item);
        }
Пример #10
0
        /// <summary>
        /// Evento executado quando a thread vai iniciar
        /// </summary>
        /// <param name="item"></param>
        protected void ThreadItem_OnStarted(ThreadItem item)
        {
#if DEBUG
            Debug.WriteLine(String.Format("Contagem em processamento: '{0}'.", FileSystemWatcher._pool.GetLifetimeService()));
#endif
            if (Empresas.Configuracoes.Count != 0)
            {
                Empresa empresa = Empresas.Configuracoes[item.Empresa];
            }

            //danasa 12/8/2011
            //mudei de posição e inclui o FullName
            Auxiliar.WriteLog("O arquivo " + item.FileInfo.FullName + " iniciou o processamento (Data criação: " + item.FileInfo.LastWriteTime + ")", false);
            Processar(item);
        }
Пример #11
0
        /// <summary>
        /// Evento é executado quando a thread vai finalizar
        /// </summary>
        /// <param name="item"></param>
        protected void ThreadItem_OnEnded(ThreadItem item)
        {
            int listCount = FileSystemWatcher._pool.Release();

            Auxiliar.WriteLog("O arquivo " + item.FileInfo.FullName + " finalizou o processamento. Itens disponiveis no Semaforo (" + listCount.ToString() + "). (Data criação: " + item.FileInfo.LastWriteTime + ")", false);
        }
Пример #12
0
 /// <summary>
 /// Evento é executado quando a thread vai finalizar
 /// </summary>
 /// <param name="item"></param>
 protected void ThreadItem_OnEnded(ThreadItem item)
 {
     Auxiliar.WriteLog("O arquivo " + item.FileInfo.FullName + " finalizou o processamento", false);
 }
Пример #13
0
 /// <summary>
 /// Executa os passos do processamento do arquivo informado em item
 /// </summary>
 /// <param name="item">Item que deverá ser processado</param>
 private static void Processar(ThreadItem item)
 {
     //Serviços tipoServico = Auxiliar.DefinirTipoServico(item.Empresa, item.FileInfo.FullName);
     new Processar().ProcessaArquivo(item.Empresa, item.FileInfo.FullName);//, tipoServico);
 }
Пример #14
0
 /// <summary>
 /// Evento é executado quando a thread vai finalizar
 /// </summary>
 /// <param name="item"></param>
 protected void ThreadItem_OnEnded(ThreadItem item)
 {
     int listCount = FileSystemWatcher._pool.Release();
     Auxiliar.WriteLog("O arquivo " + item.FileInfo.FullName + " finalizou o processamento. Itens disponiveis no Semaforo (" + listCount.ToString() + "). (Data criação: " + item.FileInfo.LastWriteTime + ")", false);            
 }
Пример #15
0
        private void Processar(ThreadItem item)
        {
            if (String.IsNullOrEmpty(Thread.CurrentThread.Name))
                Thread.CurrentThread.Name = item.Empresa.ToString();

            try
            {
                //avisa que vai iniciar
                if (OnStarted != null) OnStarted(item);

                //avisa que vai finalizar
                if (OnEnded != null) OnEnded(item);
            }
            catch (Exception ex)
            {
                Auxiliar.WriteLog("Ocorreu um erro na execução da thread que está sendo executada.\r\nThreadControl.cs (1)\r\n" + ex.Message, true);
            }
            finally
            {
                try
                {
                    //remove o item                   
                    //avisa que removeu o item
                    if (OnReleased != null) OnReleased(item);
                }
                catch (Exception ex)
                {
                    Auxiliar.WriteLog("Ocorreu um erro ao tentar remover o item da Thread que está sendo executada.\r\nThreadControl.cs (2)\r\n" + ex.Message, true);
                }

                GC.Collect();
                GC.WaitForPendingFinalizers();
            }
        }