Sobre a classe temporizadora em C# Existem três classes temporizadoras em C#
1. Definir em System.Windows.Forms
2. Definido na classe System.Threading.Timer
3. Definido na classe System.Timers.Timer
System.Windows.Forms.Timer é aplicado ao WinForm, é implementado por meio do mecanismo de mensagens do Windows, semelhante ao controle Timer em VB ou Delphi, e é implementado internamente usando a API SetTimer. Sua principal desvantagem é que o tempo não é preciso e deve haver um loop de mensagens, que não está disponível para o Aplicativo de Console.
System.Timers.Timer é muito semelhante ao System.Threading.Timer, eles são implementados via .NET Thread Pool, com tempo leve e preciso, e sem requisitos especiais para aplicações e mensagens. System.Timers.Timer também pode ser aplicado ao WinForm, substituindo completamente o controle do Timer acima. A desvantagem deles é que não suportam arrastar e soltar direto e exigem codificação manual.
Exemplo:
Use a classe System.Timers.Timer
Temporizadores.Sistema.Temporizador t = novo Temporizador.Sistema(10000); Instaure a classe Timer e defina o intervalo para 10.000 milissegundos.
t.Elapsed += novo System.Timers.ElapsedEventHandler(theout); Executar eventos quando o tempo for atingido;
t.AutoReset = verdadeiro; Defina se executa uma vez (falso) ou o tempo todo (verdadeiro);
t.Enabled = verdadeiro; se executar o evento System.Timers.Timer.Elapsed;
public void theout (fonte do objeto, System.Timers.ElapsedEventArgs e)
{
MessageBox.Show("OK!");
}
Análise experimental das semelhanças e diferenças entre o uso de três temporizadores em C#
http://dotnet.chinaitlab.com/CSharp/737740.html
Existem três tipos de temporizadores disponíveis em C#:
1. Temporizador padrão baseado em Windows (System.Windows.Forms.Timer)
2. Temporizador baseado em servidor (System.Timers.Timer)
3. Temporizador de Threading (System.Threading.Timer)
Vamos fazer alguns pequenos experimentos para analisar as semelhanças e diferenças entre os três temporizadores, especialmente a parte relacionada à thread.
Captura de tela do exemplo experimental:
1. Temporizador padrão baseado em Windows (System.Windows.Forms.Timer)
A primeira coisa a notar é que o Windows Timer foi projetado para ambientes single-threaded
Esse temporizador está presente no produto desde a versão 1.0 do Visual Basic e permaneceu praticamente inalterado
Esse temporizador é o mais fácil de usar, basta arrastar o controle do Timer da caixa de ferramentas para o formulário e definir as propriedades como eventos e intervalos
Os resultados experimentais também são totalmente consistentes com as características da rosca única:
1. Quando esse temporizador é iniciado, o ID da thread filho será exibido na lista de ID de thread filho abaixo, e é o mesmo ID da thread principal
private void formsTimer_Tick(object sender, EventArgs e)
{
i++;
lblSubThread.Text += "Execução do Subthread, ID da Thread:" + System.Threading.Thread.CurrentThread.ManagedThreadId.ToString() + "\r\n";
}
2. Quando a thread principal é pausada por 5 segundos, a thread filho pausa a execução, e quando a thread filha suspensa não for executada após 5 segundos, a thread filho subsequente será executada diretamente (ou seja, gerará algumas linhas de valores).
System.Threading.Thread.Sleep(5000);
3. Pausar os eventos de um processo filho por 5 segundos fará com que a janela principal fique sem resposta por 5 segundos
4. Defina uma variável estática de thread:
[FioEstática]
Estática privada int i = 0;
Adicione um a cada evento de subthread e depois clique no valor da variável estática da thread para obter o valor i aumentado
2. Temporizador baseado em servidor (System.Timers.Timer)
System.Timers.Timer não depende de formulários, desperta threads do pool de threads e é uma versão atualizada do temporizador tradicional otimizada para rodar em um ambiente de servidor
Não há controles prontos para uso na caixa de ferramentas VS2005 e precisam ser codificados manualmente para usar esse temporizador
Existem duas formas de usá-lo,
1. Anexar ao formulário através da propriedade SynchronizingObject
Temporizadores.Temporizadores Temporizadores = novo Temporizador Temporizador();
timersTimer.Enabled = false;
timersTimer.Interval = 100;
timersTimer.Elapsed += novo System.Timers.ElapsedEventHandler(timersTimer_Elapsed);
timersTimer.SynchronizingObject = isto;
Dessa forma, o experimento funciona quase da mesma forma que um temporizador padrão baseado em Windows, exceto que no segundo experimento acima, embora a execução do subthread também seja pausada, após 5 segundos todas as tarefas previamente enfileiradas serão executadas (ou seja, algumas linhas de valor não estarão faltando).
2. Não use a propriedade SynchronizingObject
Esse método é multithread, ou seja, a thread filha inicial e a forma principal não estão na mesma thread. No entanto, também há um problema: como o subthread é uma thread separada, os controles no formulário não podem ser acessados, mas só podem ser acessados por meio de um proxy:
delegar void SetTextCallback(texto em string);
Fonte: (http://blog.sina.com.cn/s/blog_5aeeb8200100bhc4.html) - (Turn) Comparação de três objetos temporizadores no blog C#_dash_Sina
。
。
void timersTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
{
//使用代理
texto da string = "execução de thread filho, ID da thread:" + System.Threading.Thread.CurrentThread.ManagedThreadId.ToString() + "\r\n";
SetTextCallback d = novo SetTextCallback(SetText);
Isso. Invoke(d, novo objeto[] { texto });
i++;
}
private void SetText (texto em string)
{
lblSubThread.Text += texto;
}
Dessa forma, obteremos novamente os seguintes resultados do experimento:
1. Quando esse temporizador for iniciado, o ID da thread filho será exibido na lista de ID de thread filho abaixo, e ele é diferente do ID da thread principal
2. Quando você clica na thread principal para pausar por 5 segundos, a subthread continua sendo executada (pode não ser visível na interface, mas pode ser facilmente vista ao enviar o arquivo na subthread)
3. Pausar os eventos de um processo filho por 5 segundos não fará com que a janela principal fique sem resposta
4. Adicione um à variável estática da thread cada vez no evento da subthread, e então clique se a variável estática da thread vale 0 ou 0 (isso não alterará a variável estática da thread na janela principal).
3. Temporizador de Threading (System.Threading.Timer)
Os temporizadores de thread também não dependem de formulários, são temporizadores simples e leves que usam métodos de callback em vez de eventos, e são alimentados por threads pool.
Timers de thread são úteis em cenários onde mensagens não são enviadas em threads.
Veja como usar:
System.Threading.Timer threadTimer;
Public void ThreadMethod (Estado do objeto)
{
//使用代理
texto da string = "execução de thread filho, ID da thread:" + System.Threading.Thread.CurrentThread.ManagedThreadId.ToString() + "\r\n";
SetTextCallback d = novo SetTextCallback(SetText);
Isso. Invoke(d, novo objeto[] { texto });
i++;
}
private void Form1_Load(object sender, EventArgs e)
{
threadTimer = novo System.Threading.Timer(novo System.Threading.TimerCallback(ThreadMethod), nulo, -1, -1);
}
Código de pausa:
threadTimer.Change(-1, -1);
O efeito do experimento é o mesmo do segundo método do temporizador baseado em servidor (System.Timers.Timer),
Claro, os métodos e princípios de uso específicos são diferentes, o mais importante é que esse método usa o método agente em vez do método de eventos, e pode ser executado separadamente sem depender de formulários e componentes
A seguir está uma tabela resumida por estrangeiros (a diferença entre os três métodos):
Feature descrip{filter}tion System.Timers.Timer System.Threading.Timer System.Windows.Forms.Timer
Suporte para adicionar e remover ouvintes após o temporizador ser instanciado. Sim, não. Sim.
Suporta retornos de chamada na thread de interface do usuário Sim Não. Sim
Retornos de threads obtidos do pool de threads Sim Sim Sim Não
Suporta arrastar e soltar no Windows Forms Designer Sim Sim Sim
Adequado para rodar em um ambiente multithread de servidores. Sim, sim, não.
Inclui suporte para passar estados arbitrários da inicialização do temporizador para o callback. Não, não, não
Implementa IDisposável Sim Sim Sim Sim
Suporta callbacks pontuais, assim como callbacks repetidos periódicos Yes Yes Sim
Acessível através dos limites do domínio da aplicação Sim Sim Sim Sim
Suporta IComponent – hostável em IContainer Sim Não Sim |
Publicado em 12/10/2017 13:12:51
|
|
|
Publicado em 08/11/2017 14:02:44