ElapsedEventHandler Delegasikan

Referensi

Definisi

Ruang nama:: System.Timers

Rakitan:: System.ComponentModel.TypeConverter.dll

Rakitan:: System.dll

Rakitan:: netstandard.dll

Penting

Beberapa informasi terkait produk prarilis yang dapat diubah secara signifikan sebelum dirilis. Microsoft tidak memberikan jaminan, tersirat maupun tersurat, sehubungan dengan informasi yang diberikan di sini.

Mewakili metode yang akan menangani Elapsed peristiwa 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)

Parameter

sender: Object

Sumber dari peristiwa tersebut.

e: ElapsedEventArgs

Objek ElapsedEventArgs yang berisi data peristiwa.

Contoh

Contoh kode berikut menyiapkan penanganan aktivitas untuk Timer.Elapsed peristiwa, membuat timer, dan memulai timer. Penanganan aktivitas memiliki tanda tangan yang sama dengan ElapsedEventHandler delegasi. Penanganan aktivitas menampilkan SignalTime properti setiap kali dinaikkan.

// 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

Keterangan

Saat Membuat ElapsedEventHandler delegasi, Anda mengidentifikasi metode yang akan menangani Timer.Elapsed peristiwa. Untuk mengaitkan peristiwa dengan penanganan aktivitas Anda, tambahkan instans delegasi ke peristiwa. Penanganan aktivitas dipanggil setiap kali peristiwa terjadi, kecuali Anda menghapus delegasi. Untuk informasi selengkapnya tentang delegasi penanganan aktivitas, lihat Menangani dan Menaikkan Peristiwa.

Metode Ekstensi

GetMethodInfo(Delegate)

Mendapatkan objek yang mewakili metode yang diwakili oleh delegasi yang ditentukan.

Berlaku untuk