Timer Klass

Definition

public ref class Timer : System::ComponentModel::Component, System::ComponentModel::ISupportInitialize

public class Timer : System.ComponentModel.Component, System.ComponentModel.ISupportInitialize

type Timer = class
    inherit Component
    interface ISupportInitialize

Public Class Timer
Inherits Component
Implements ISupportInitialize

Arv

Object

MarshalByRefObject

Component

Timer

Implementeringar

ISupportInitialize

Exempel

I följande exempel instansierar ett System.Timers.Timer objekt som utlöser händelsen Timer.Elapsed varannan sekund (2 000 millisekunder), konfigurerar en händelsehanterare för händelsen och startar timern. Händelsehanteraren visar värdet för egenskapen varje gång den ElapsedEventArgs.SignalTime utlöses.

using System;
using System.Timers;

public class Example
{
   private static System.Timers.Timer aTimer;
   
   public static void Main()
   {
      SetTimer();

      Console.WriteLine("\nPress the Enter key to exit the application...\n");
      Console.WriteLine("The application started at {0:HH:mm:ss.fff}", DateTime.Now);
      Console.ReadLine();
      aTimer.Stop();
      aTimer.Dispose();
      
      Console.WriteLine("Terminating the application...");
   }

   private static void SetTimer()
   {
        // 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;
        aTimer.AutoReset = true;
        aTimer.Enabled = true;
    }

    private static void OnTimedEvent(Object source, ElapsedEventArgs e)
    {
        Console.WriteLine("The Elapsed event was raised at {0:HH:mm:ss.fff}",
                          e.SignalTime);
    }
}
// The example displays output like the following:
//       Press the Enter key to exit the application...
//
//       The application started at 09:40:29.068
//       The Elapsed event was raised at 09:40:31.084
//       The Elapsed event was raised at 09:40:33.100
//       The Elapsed event was raised at 09:40:35.100
//       The Elapsed event was raised at 09:40:37.116
//       The Elapsed event was raised at 09:40:39.116
//       The Elapsed event was raised at 09:40:41.117
//       The Elapsed event was raised at 09:40:43.132
//       The Elapsed event was raised at 09:40:45.133
//       The Elapsed event was raised at 09:40:47.148
//
//       Terminating the application...

open System
open System.Timers

let onTimedEvent source (e: ElapsedEventArgs) =
    printfn $"""The Elapsed event was raised at {e.SignalTime.ToString "HH:mm:ss.fff"}"""

// Create a timer with a two second interval.
let aTimer = new Timer 2000
// Hook up the Elapsed event for the timer. 
aTimer.Elapsed.AddHandler onTimedEvent
aTimer.AutoReset <- true
aTimer.Enabled <- true

printfn "\nPress the Enter key to exit the application...\n"
printfn $"""The application started at {DateTime.Now.ToString "HH:mm:ss.fff"}"""
stdin.ReadLine() |> ignore
aTimer.Stop()
aTimer.Dispose()

printfn "Terminating the application..."

// The example displays output like the following:
//       Press the Enter key to exit the application...
//
//       The application started at 09:40:29.068
//       The Elapsed event was raised at 09:40:31.084
//       The Elapsed event was raised at 09:40:33.100
//       The Elapsed event was raised at 09:40:35.100
//       The Elapsed event was raised at 09:40:37.116
//       The Elapsed event was raised at 09:40:39.116
//       The Elapsed event was raised at 09:40:41.117
//       The Elapsed event was raised at 09:40:43.132
//       The Elapsed event was raised at 09:40:45.133
//       The Elapsed event was raised at 09:40:47.148
//
//       Terminating the application...

Imports System.Timers

Public Module Example
    Private aTimer As System.Timers.Timer

    Public Sub Main()
        SetTimer()

      Console.WriteLine("{0}Press the Enter key to exit the application...{0}",
                        vbCrLf)
      Console.WriteLine("The application started at {0:HH:mm:ss.fff}",
                        DateTime.Now)
      Console.ReadLine()
      aTimer.Stop()
      aTimer.Dispose()

      Console.WriteLine("Terminating the application...")
    End Sub

    Private Sub SetTimer()
        ' Create a timer with a two second interval.
        aTimer = New System.Timers.Timer(2000)
        ' Hook up the Elapsed event for the timer. 
        AddHandler aTimer.Elapsed, AddressOf OnTimedEvent
        aTimer.AutoReset = True
        aTimer.Enabled = True
    End Sub

    ' The event handler for the Timer.Elapsed event. 
    Private Sub OnTimedEvent(source As Object, e As ElapsedEventArgs)
        Console.WriteLine("The Elapsed event was raised at {0:HH:mm:ss.fff}",
                          e.SignalTime)
    End Sub 
End Module
' The example displays output like the following:
'       Press the Enter key to exit the application...
'
'       The application started at 09:40:29.068
'       The Elapsed event was raised at 09:40:31.084
'       The Elapsed event was raised at 09:40:33.100
'       The Elapsed event was raised at 09:40:35.100
'       The Elapsed event was raised at 09:40:37.116
'       The Elapsed event was raised at 09:40:39.116
'       The Elapsed event was raised at 09:40:41.117
'       The Elapsed event was raised at 09:40:43.132
'       The Elapsed event was raised at 09:40:45.133
'       The Elapsed event was raised at 09:40:47.148
'
'       Terminating the application...

Kommentarer

Komponenten Timer är en serverbaserad timer som genererar en Elapsed händelse i ditt program efter att antalet millisekunder i Interval egenskapen har förflutit. Du kan konfigurera objektet Timer så att det bara genererar händelsen en gång eller flera gånger med hjälp av AutoReset egenskapen . Vanligtvis deklareras ett Timer objekt på klassnivå så att det förblir i omfånget så länge det behövs. Du kan sedan hantera händelsen Elapsed för att tillhandahålla regelbunden bearbetning. Anta till exempel att du har en kritisk server som måste köras 24 timmar om dygnet, 7 dagar i veckan. Du kan skapa en tjänst som använder ett Timer objekt för att regelbundet kontrollera servern och se till att systemet är igång. Om systemet inte svarar kan tjänsten försöka starta om servern eller meddela en administratör.

Den här typen implementerar IDisposable gränssnittet. När du har använt typen bör du kassera den på ett direkt eller indirekt sätt. Om du vill ta bort typen direkt anropar du dess Dispose metod i ett try/catch block. Om du vill ta bort det indirekt använder du en språkkonstruktion som using (i C#) eller Using (i Visual Basic). Mer information finns i avsnittet "Använda ett objekt som implementerar IDisposable" i IDisposable gränssnittet.

Den serverbaserade System.Timers.Timer klassen är utformad för användning med arbetstrådar i en flertrådad miljö. Servertimers kan flyttas mellan trådar för att hantera den upphöjda Elapsed händelsen, vilket resulterar i mer noggrannhet än Windows timers för att höja händelsen i tid.

Komponenten System.Timers.Timer genererar Elapsed händelsen baserat på värdet (i millisekunder) för Interval egenskapen. Du kan hantera den här händelsen för att utföra den bearbetning du behöver. Anta till exempel att du har ett onlineförsäljningsprogram som kontinuerligt publicerar försäljningsorder till en databas. Tjänsten som sammanställer instruktionerna för leverans fungerar på en batch med beställningar i stället för att bearbeta varje beställning individuellt. Du kan använda en Timer för att starta batchbearbetningen var 30:e minut.

När AutoReset är inställt på falsegenererar System.Timers.Timer ett Elapsed objekt händelsen bara en gång, efter att den första Interval har förflutit. Om du vill fortsätta att höja Elapsed händelsen regelbundet med det intervall som definieras av Interval, anger du AutoReset till true, vilket är standardvärdet.

Komponenten Timer fångar upp och undertrycker alla undantag som genereras av händelsehanterare för Elapsed händelsen. Det här beteendet kan komma att ändras i framtida versioner av .NET Framework. Observera dock att detta inte gäller för händelsehanterare som kör asynkront och inkluderar operatorn await (i C#) eller operatorn Await (i Visual Basic). Undantag som genereras i dessa händelsehanterare sprids tillbaka till den anropande tråden, vilket visas i följande exempel. Mer information om undantag som genereras i asynkrona metoder finns i Undantagshantering.

using System;
using System.Threading.Tasks;
using System.Timers;

class Example
{
   static void Main()
   {
      Timer timer = new Timer(1000);
      timer.Elapsed += async ( sender, e ) => await HandleTimer();
      timer.Start();
      Console.Write("Press any key to exit... ");
      Console.ReadKey();
   }

   private static Task HandleTimer()
   {
     Console.WriteLine("\nHandler not implemented..." );
     throw new NotImplementedException();
   }
}
// The example displays output like the following:
//   Press any key to exit...
//   Handler not implemented...
//   
//   Unhandled Exception: System.NotImplementedException: The method or operation is not implemented.
//      at Example.HandleTimer()
//      at Example.<<Main>b__0>d__2.MoveNext()
//   --- End of stack trace from previous location where exception was thrown ---
//      at System.Runtime.CompilerServices.AsyncMethodBuilderCore.<>c__DisplayClass2.<ThrowAsync>b__5(Object state)
//      at System.Threading.ExecutionContext.RunInternal(ExecutionContext executionContext, ContextCallback callback, Object state, Boolean preserveSyncCtx)
//      at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state, Boolean preserveSyncCtx)
//      at System.Threading.QueueUserWorkItemCallback.System.Threading.IThreadPoolWorkItem.ExecuteWorkItem()
//      at System.Threading.ThreadPoolWorkQueue.Dispatch()

open System
open System.Threading.Tasks
open System.Timers

let handleTimer () =
    printfn "\nHandler not implemented..."
    raise (NotImplementedException()): Task

let timer = new Timer 1000
timer.Elapsed.AddHandler(fun sender e -> task { do! handleTimer () } |> ignore)
timer.Start()
printf "Press any key to exit... "
Console.ReadKey() |> ignore

// The example displays output like the following:
//   Press any key to exit...
//   Handler not implemented...
//
//   Unhandled Exception: System.NotImplementedException: The method or operation is not implemented.
//      at Example.HandleTimer()
//      at Example.<<Main>b__0>d__2.MoveNext()
//   --- End of stack trace from previous location where exception was thrown ---
//      at System.Runtime.CompilerServices.AsyncMethodBuilderCore.<>c__DisplayClass2.<ThrowAsync>b__5(Object state)
//      at System.Threading.ExecutionContext.RunInternal(ExecutionContext executionContext, ContextCallback callback, Object state, Boolean preserveSyncCtx)
//      at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state, Boolean preserveSyncCtx)
//      at System.Threading.QueueUserWorkItemCallback.System.Threading.IThreadPoolWorkItem.ExecuteWorkItem()
//      at System.Threading.ThreadPoolWorkQueue.Dispatch()

Imports System.Threading.Tasks
Imports System.Timers

Public Module Example
   Public Sub Main()
      Dim timer As New Timer(1000)  
      AddHandler timer.Elapsed, AddressOf Example.HandleTimer     
      'timer.Elapsed = Async ( sender, e ) => await HandleTimer()
      timer.Start()
      Console.Write("Press any key to exit... ")
      Console.ReadKey()
   End Sub

   Private Async Sub HandleTimer(sender As Object, e As EventArgs)
      Await Task.Run(Sub()
                        Console.WriteLine()
                        Console.WriteLine("Handler not implemented..." )
                        Throw New NotImplementedException()
                     End Sub)   
   End Sub
End Module
' The example displays output like the following:
'   Press any key to exit...
'   Handler not implemented...
'   
'   Unhandled Exception: System.NotImplementedException: The method or operation is not implemented.
'      at Example._Lambda$__1()
'      at System.Threading.Tasks.Task.Execute()
'   --- End of stack trace from previous location where exception was thrown ---
'      at System.Runtime.CompilerServices.TaskAwaiter.ThrowForNonSuccess(Task task)
'      at System.Runtime.CompilerServices.TaskAwaiter.HandleNonSuccessAndDebuggerNotification(Task task)
'      at Example.VB$StateMachine_0_HandleTimer.MoveNext()
'   --- End of stack trace from previous location where exception was thrown ---
'      at System.Runtime.CompilerServices.AsyncMethodBuilderCore.<>c__DisplayClass2.<ThrowAsync>b__5(Object state)
'      at System.Threading.ExecutionContext.RunInternal(ExecutionContext executionContext, ContextCallback callback, Object state, Boolean preserveSyncCtx)
'      at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state, Boolean preserveSyncCtx)
'      at System.Threading.QueueUserWorkItemCallback.System.Threading.IThreadPoolWorkItem.ExecuteWorkItem()
'      at System.Threading.ThreadPoolWorkQueue.Dispatch()

Om egenskapen SynchronizingObject är nullgenereras Elapsed händelsen i en ThreadPool tråd. Om bearbetningen Elapsed av händelsen varar längre än Intervalkan händelsen aktiveras igen i en annan ThreadPool tråd. I det här fallet bör händelsehanteraren vara reentrant.

Även om SynchronizingObject inte nullElapsed kan händelser inträffa efter Dispose att metoden eller Stop har anropats eller efter Enabled att egenskapen har angetts till false, eftersom signalen för att höja Elapsed händelsen alltid står i kö för körning på en trådpooltråd. Ett sätt att lösa det här konkurrenstillståndet är att ange en flagga som talar om för Elapsed händelsehanteraren att händelsen ska ignorera efterföljande händelser.

Om du använder System.Timers.Timer klassen med ett användargränssnittselement, till exempel ett formulär eller en kontroll, utan att placera timern på användargränssnittselementet, tilldelar du formuläret eller kontrollen som innehåller Timer egenskapen SynchronizingObject så att händelsen konverteras till användargränssnittstråden.

En lista över standardegenskapsvärden för en instans av Timerfinns i Timer konstruktorn.

Trådsäkerhet

Alla offentliga static medlemmar av den här typen är trådsäkra. Vilka som helst instansmedlemmar garanteras inte att vara trådsäkra.

Se även

• AutoReset
• Interval
• Elapsed
• Timer()
• Timer