Süreölçerler

  • Makale

.NET, çok iş parçacıklı bir ortamda kullanmak için üç zamanlayıcı sağlar:

Not

Bazı .NET uygulamaları ek zamanlayıcılar içerebilir:

  • System.Windows.Forms.Timer: Bir olayı düzenli aralıklarla tetikleyen bir Windows Forms bileşeni. Bileşenin kullanıcı arabirimi yoktur ve tek iş parçacıklı bir ortamda kullanılmak üzere tasarlanmıştır.
  • System.Web.UI.Timer: zaman uyumsuz veya zaman uyumlu web sayfası geri gönderme işlemlerini düzenli aralıklarla gerçekleştiren bir ASP.NET bileşeni.
  • System.Windows.Threading.DispatcherTimer: belirli bir zaman aralığında ve belirtilen bir önceliğe göre işlenen kuyruğa tümleştirilmiş Dispatcher bir zamanlayıcı.

System.Threading.Timer sınıfı

sınıfı, System.Threading.Timer belirtilen zaman aralıklarında sürekli olarak bir temsilci çağırmanızı sağlar. Bu sınıfı, belirli bir zaman aralığında bir temsilciye tek bir çağrı zamanlamak için de kullanabilirsiniz. Temsilci bir ThreadPool iş parçacığında yürütülür.

Bir System.Threading.Timer nesne oluşturduğunuzda, geri çağırma yöntemini tanımlayan bir TimerCallback temsilci, geri çağırmaya geçirilen isteğe bağlı bir durum nesnesi, geri çağırmanın ilk çağrılmadan önce geciktirilmesi gereken süre ve geri çağırmalar arasındaki zaman aralığını belirtirsiniz. Bekleyen zamanlayıcıyı iptal etmek için yöntemini çağırın Timer.Dispose .

Aşağıdaki örnek, sağlanan temsilciyi bir saniye (1000 milisaniye) sonra ilk kez çağıran ve ardından iki saniyede bir çağıran bir zamanlayıcı oluşturur. Örnekteki durum nesnesi, temsilcinin kaç kez çağrıldığını saymak için kullanılır. Temsilci en az 10 kez çağrıldığında zamanlayıcı durdurulur.

using namespace System;
using namespace System::Threading;

ref class TimerState
{
public:
    int counter;
};

ref class Example
{
private:
    static Timer^ timer;

public:
    static void TimerTask(Object^ state)
    {
        Console::WriteLine("{0:HH:mm:ss.fff}: starting a new callback.", DateTime::Now);

        TimerState^ timerState = dynamic_cast<TimerState^>(state);
        Interlocked::Increment(timerState->counter);
    }

    static void Main()
    {
        TimerCallback^ tcb = gcnew TimerCallback(&TimerTask);
        TimerState^ state = gcnew TimerState();
        state->counter = 0;
        timer = gcnew Timer(tcb, state, 1000, 2000);

        while (state->counter <= 10)
        {
            Thread::Sleep(1000);
        }

        timer->~Timer();
        Console::WriteLine("{0:HH:mm:ss.fff}: done.", DateTime::Now);
    }
};

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

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

class Program
{
    private static Timer timer;

    static void Main(string[] args)
    {
        var timerState = new TimerState { Counter = 0 };

        timer = new Timer(
            callback: new TimerCallback(TimerTask),
            state: timerState,
            dueTime: 1000,
            period: 2000);

        while (timerState.Counter <= 10)
        {
            Task.Delay(1000).Wait();
        }

        timer.Dispose();
        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: done.");
    }

    private static void TimerTask(object timerState)
    {
        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: starting a new callback.");
        var state = timerState as TimerState;
        Interlocked.Increment(ref state.Counter);
    }

    class TimerState
    {
        public int Counter;
    }
}

Imports System.Threading

Module Program

    Private Timer As Timer

    Sub Main(args As String())

        Dim StateObj As New TimerState
        StateObj.Counter = 0

        Timer = New Timer(New TimerCallback(AddressOf TimerTask), StateObj, 1000, 2000)

        While StateObj.Counter <= 10
            Task.Delay(1000).Wait()
        End While

        Timer.Dispose()
        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: done.")
    End Sub

    Private Sub TimerTask(ByVal StateObj As Object)

        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: starting a new callback.")

        Dim State As TimerState = CType(StateObj, TimerState)
        Interlocked.Increment(State.Counter)
    End Sub

    Private Class TimerState
        Public Counter As Integer
    End Class
End Module

Daha fazla bilgi ve örnek için bkz System.Threading.Timer. .

System.Timers.Timer sınıfı

Çok iş parçacıklı bir ortamda kullanılabilecek başka bir zamanlayıcı, System.Timers.Timer varsayılan olarak bir iş parçacığında ThreadPool bir olay tetikler.

Bir System.Timers.Timer nesne oluşturduğunuzda, bir olayın tetiklendiği Elapsed zaman aralığını belirtebilirsiniz. Zamanlayıcının Enabled olay tetiklemesi Elapsed gerekip gerekmediğini belirtmek için özelliğini kullanın. Belirtilen aralık geçtikten sonra bir olayın yalnızca bir Elapsed kez yükseltilmesi gerekiyorsa, değerini AutoReset olarak falseayarlayın. özelliğinin AutoReset varsayılan değeri olan değeri, truebir Elapsed olayın özelliği tarafından Interval tanımlanan aralıkta düzenli olarak tetiklendiği anlamına gelir.

Daha fazla bilgi ve örnek için bkz System.Timers.Timer. .

System.Threading.PeriodicTimer sınıfı

sınıfı, System.Threading.PeriodicTimer çağrısından PeriodicTimer.WaitForNextTickAsyncsonra iş gerçekleştirerek belirli bir aralığın tek tek işaretlerini beklemenizi sağlar.

Bir System.Threading.PeriodicTimer nesne oluşturduğunuzda, zamanlayıcının her bir onay işareti arasındaki süreyi belirleyen bir TimeSpan belirtirsiniz. Önceki zamanlayıcı sınıflarında olduğu gibi bir geri çağırma geçirmek veya bir olay işleyicisi ayarlamak yerine, zamanlayıcıyı belirtilen zaman aralığına kadar ilerletmek için doğrudan WaitForNextTickAsync kapsam dahilinde çalışma gerçekleştirirsiniz.

WaitForNextTickAsync yöntemi, zamanlayıcının başarıyla tetiklendiğinde ve false zamanlayıcı çağrılarak PeriodicTimer.Disposeiptal edildiğinde bir ValueTask<bool>true döndürür. WaitForNextTickAsync isteğe bağlı olarak bir CancellationTokenkabul eder ve bu da iptal istendiğinde sonucu TaskCanceledException olarak elde eder.

Daha fazla bilgi için bkz. System.Threading.PeriodicTimer.

Ayrıca bkz.