ElapsedEventHandler Delegar

Referência

Definição

Namespace:: System.Timers

Assembly:: System.ComponentModel.TypeConverter.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Representa o método que manipulará o evento de Elapsed de Timer.

public delegate void ElapsedEventHandler(System::Object ^ sender, ElapsedEventArgs ^ e);

public delegate void ElapsedEventHandler(object sender, ElapsedEventArgs e);

public delegate void ElapsedEventHandler(object? sender, ElapsedEventArgs e);

type ElapsedEventHandler = delegate of obj * ElapsedEventArgs -> unit

Public Delegate Sub ElapsedEventHandler(sender As Object, e As ElapsedEventArgs)

Parâmetros

sender: Object

A fonte do evento.

e: ElapsedEventArgs

Um objeto ElapsedEventArgs que contém os dados do evento.

Exemplos

O exemplo de código a seguir configura um manipulador de eventos para o Timer.Elapsed evento, cria um temporizador e inicia o temporizador. O manipulador de eventos tem a mesma assinatura que o ElapsedEventHandler delegado. O manipulador de eventos exibe a SignalTime propriedade sempre que ela é gerada.

// Use this code inside a project created with the Visual C++ > CLR > CLR Console Application template. 
// Replace the code in the default .cpp file with this code. 

#include "stdafx.h"
#using <system.dll>

using namespace System;

// To avoid confusion with other Timer classes, this sample always uses the fully-qualified
// name of System::Timers::Timer instead of a using statement for System::Timer.

public ref class Example
{
private:
    static System::Timers::Timer^ aTimer;

public:
    static void Demo()
    {
        // Normally, the timer is declared at the class level, so that it stays in scope as long as it
        // is needed. If the timer is declared in a long-running method, KeepAlive must be used to prevent
        // the JIT compiler from allowing aggressive garbage collection to occur before the method ends.
        // You can experiment with this by commenting out the class-level declaration and uncommenting 
        // the declaration below; then uncomment the GC.KeepAlive(aTimer) at the end of the method.        
        //System::Timers::Timer^ aTimer; 

        // Create a timer and set a two second interval.
        aTimer = gcnew System::Timers::Timer();
        aTimer->Interval = 2000;

        // Alternate method: create a Timer with an interval argument to the constructor.
        //aTimer = gcnew System::Timers::Timer(2000);

        // Hook up the Elapsed event for the timer. 
        aTimer->Elapsed += gcnew System::Timers::ElapsedEventHandler(Example::OnTimedEvent);

        // Have the timer fire repeated events (true is the default)
        aTimer->AutoReset = true;

        // Start the timer
        aTimer->Enabled = true;

        Console::WriteLine("Press the Enter key to exit the program at any time... ");
        Console::ReadLine();

        // If the timer is declared in a long-running method, use KeepAlive to prevent garbage collection
        // from occurring before the method ends.  
        //GC::KeepAlive(aTimer);
    }

private:
    static void OnTimedEvent(Object^ source, System::Timers::ElapsedEventArgs^ e)
    {
        Console::WriteLine("The Elapsed event was raised at {0}", e->SignalTime);
    }

};

int main()
{
    Example::Demo();
}

// This example displays output like the following: 
//       Press the Enter key to exit the program at any time... 
//       The Elapsed event was raised at 5/20/2015 8:48:58 PM 
//       The Elapsed event was raised at 5/20/2015 8:49:00 PM 
//       The Elapsed event was raised at 5/20/2015 8:49:02 PM 
//       The Elapsed event was raised at 5/20/2015 8:49:04 PM 
//       The Elapsed event was raised at 5/20/2015 8:49:06 PM

// Use this code inside a project created with the Visual C# > Windows Desktop > Console Application template.
// Replace the code in Program.cs with this code.

using System;

// To avoid confusion with other Timer classes, this sample always uses the fully-qualified
// name of System.Timers.Timer instead of a using statement for System.Timers.

public class Example
{
    private static System.Timers.Timer aTimer;

    public static void Main()
    {
        // Normally, the timer is declared at the class level, so that it stays in scope as long as it
        // is needed. If the timer is declared in a long-running method, KeepAlive must be used to prevent
        // the JIT compiler from allowing aggressive garbage collection to occur before the method ends.
        // You can experiment with this by commenting out the class-level declaration and uncommenting
        // the declaration below; then uncomment the GC.KeepAlive(aTimer) at the end of the method.
        //System.Timers.Timer aTimer;

        // Create a timer and set a two second interval.
        aTimer = new System.Timers.Timer();
        aTimer.Interval = 2000;

        // Alternate method: create a Timer with an interval argument to the constructor.
        //aTimer = new System.Timers.Timer(2000);

        // Create a timer with a two second interval.
        aTimer = new System.Timers.Timer(2000);

        // Hook up the Elapsed event for the timer.
        aTimer.Elapsed += OnTimedEvent;

        // Have the timer fire repeated events (true is the default)
        aTimer.AutoReset = true;

        // Start the timer
        aTimer.Enabled = true;

        Console.WriteLine("Press the Enter key to exit the program at any time... ");
        Console.ReadLine();

        // If the timer is declared in a long-running method, use KeepAlive to prevent garbage collection
        // from occurring before the method ends.
        //GC.KeepAlive(aTimer)
    }

    private static void OnTimedEvent(Object source, System.Timers.ElapsedEventArgs e)
    {
        Console.WriteLine("The Elapsed event was raised at {0}", e.SignalTime);
    }
}

// This example displays output like the following:
//       Press the Enter key to exit the program at any time...
//       The Elapsed event was raised at 5/20/2015 8:48:58 PM
//       The Elapsed event was raised at 5/20/2015 8:49:00 PM
//       The Elapsed event was raised at 5/20/2015 8:49:02 PM
//       The Elapsed event was raised at 5/20/2015 8:49:04 PM
//       The Elapsed event was raised at 5/20/2015 8:49:06 PM

// To avoid confusion with other Timer classes, this sample always uses the fully-qualified
// name of System.Timers.Timer instead of a using statement for System.Timers.
module Example

let mutable aTimer = new System.Timers.Timer()

let onTimedEvent source (e: System.Timers.ElapsedEventArgs) =
    printfn $"The Elapsed event was raised at {e.SignalTime}"

[<EntryPoint>]
let main _ =
    // Normally, the timer is declared at the class level, so that it stays in scope as long as it
    // is needed. If the timer is declared in a long-running method, KeepAlive must be used to prevent
    // the JIT compiler from allowing aggressive garbage collection to occur before the method ends.
    // You can experiment with this by commenting out the class-level declaration and uncommenting
    // the declaration below then uncomment the GC.KeepAlive(aTimer) at the end of the method.
    //System.Timers.Timer aTimer

    // Set a two second interval.
    aTimer.Interval <- 2000

    // Alternate method: create a Timer with an interval argument to the constructor.
    //aTimer = new System.Timers.Timer(2000)

    // Create a timer with a two second interval.
    aTimer <- new System.Timers.Timer(2000)

    // Hook up the Elapsed event for the timer.
    aTimer.Elapsed.AddHandler onTimedEvent

    // Have the timer fire repeated events (true is the default)
    aTimer.AutoReset <- true

    // Start the timer
    aTimer.Enabled <- true

    printfn "Press the Enter key to exit the program at any time... "
    stdin.ReadLine() |> ignore

    // If the timer is declared in a long-running method, use KeepAlive to prevent garbage collection
    // from occurring before the method ends.
    //GC.KeepAlive(aTimer)
    0

// This example displays output like the following:
//       Press the Enter key to exit the program at any time...
//       The Elapsed event was raised at 5/20/2015 8:48:58 PM
//       The Elapsed event was raised at 5/20/2015 8:49:00 PM
//       The Elapsed event was raised at 5/20/2015 8:49:02 PM
//       The Elapsed event was raised at 5/20/2015 8:49:04 PM
//       The Elapsed event was raised at 5/20/2015 8:49:06 PM

' Use this code inside a project created with the Visual Basic > Windows Desktop > Console Application template. 
' Replace the default code in Module1.vb with this code. Then right click the project in Solution Explorer, 
' select Properties, and set the Startup Object to Timer1. 

' To avoid confusion with other Timer classes, this sample always uses the fully-qualified
' name of System.Timers.Timer.

Public Class Module1

    Private Shared aTimer As System.Timers.Timer

    Public Shared Sub Main()
        ' Normally, the timer is declared at the class level, so that it stays in scope as long as it
        ' is needed. If the timer is declared in a long-running method, KeepAlive must be used to prevent
        ' the JIT compiler from allowing aggressive garbage collection to occur before the method ends.
        ' You can experiment with this by commenting out the class-level declaration and uncommenting 
        ' the declaration below; then uncomment the GC.KeepAlive(aTimer) at the end of the method.        
        'Dim aTimer As System.Timers.Timer 

        ' Create a timer and set a two second interval.
        aTimer = New System.Timers.Timer()
        aTimer.Interval = 2000

        ' Alternate method: create a Timer with an interval argument to the constructor.
        ' aTimer = New System.Timers.Timer(2000)

        ' Hook up the Elapsed event for the timer.  
        AddHandler aTimer.Elapsed, AddressOf OnTimedEvent

        ' Have the timer fire repeated events (true is the default)
        aTimer.AutoReset = True

        ' Start the timer
        aTimer.Enabled = True

        Console.WriteLine("Press the Enter key to exit the program at any time... ")
        Console.ReadLine()

        ' If the timer is declared in a long-running method, use KeepAlive to prevent garbage collection
        ' from occurring before the method ends. 
        'GC.KeepAlive(aTimer) 
    End Sub

    Private Shared Sub OnTimedEvent(source As Object, e As System.Timers.ElapsedEventArgs)
        Console.WriteLine("The Elapsed event was raised at {0}", e.SignalTime)
    End Sub
End Class

' This example displays output like the following: 
'       Press the Enter key to exit the program at any time... 
'       The Elapsed event was raised at 5/20/2015 8:48:58 PM 
'       The Elapsed event was raised at 5/20/2015 8:49:00 PM 
'       The Elapsed event was raised at 5/20/2015 8:49:02 PM 
'       The Elapsed event was raised at 5/20/2015 8:49:04 PM 
'       The Elapsed event was raised at 5/20/2015 8:49:06 PM

Comentários

Ao criar um ElapsedEventHandler delegado, você identifica o método que manipulará o Timer.Elapsed evento. Para associar o evento ao manipulador de eventos, adicione uma instância do delegado ao evento. O manipulador de eventos é chamado sempre que o evento ocorre, a menos que você remova o representante. Para obter mais informações sobre representantes do manipulador de eventos, consulte Manipulando e gerando eventos.

Métodos de Extensão

GetMethodInfo(Delegate)

Obtém um objeto que representa o método representado pelo delegado especificado.

Aplica-se a

Compartilhar via