WPF Zamanlayıcı C # Zamanlayıcı Gibi

WPF C # Zamanlayıcı Kontrolü gibi bir denetim nerede bulabilirim?

Her zamanki WPF zamanlayıcısı, DispatcherTimerbir kontrol değil, kodda kullanılır. Temelde WinForms zamanlayıcı ile aynı şekilde çalışır:

System.Windows.Threading.DispatcherTimer dispatcherTimer = new System.Windows.Threading.DispatcherTimer();
dispatcherTimer.Tick += dispatcherTimer_Tick;
dispatcherTimer.Interval = new TimeSpan(0,0,1);
dispatcherTimer.Start();


private void dispatcherTimer_Tick(object sender, EventArgs e)
{
  // code goes here
}

DispatcherTimer hakkında daha fazla bilgiyi burada bulabilirsiniz

Dispatcher ile şunları eklemeniz gerekecek

using System.Windows.Threading;

Ayrıca DispatcherTimer'ı sağ tıklatıp Çöz'ü tıklattığınızda uygun başvuruları eklemesi gerektiğini unutmayın.

Ayrıca kullanabilirsiniz

using System.Timers;
using System.Threading;

Zamanlayıcının özel işlevleri vardır.

1. Eşzamansız bir zamanlayıcı veya eşzamanlı zamanlayıcı çağırın.
2. Zaman aralığını değiştirme
3. İptal etme ve devam ettirme yeteneği  

StartAsync ()veya kullanırsanız Start (), iş parçacığı kullanıcı arabirimi öğesini engellemez

     namespace UITimer


     {
        using thread = System.Threading;
        public class Timer
        {

        public event Action<thread::SynchronizationContext> TaskAsyncTick;
        public event Action Tick;
        public event Action AsyncTick;
        public int Interval { get; set; } = 1;
        private bool canceled = false;
        private bool canceling = false;
        public async void Start()
        {
            while(true)
            {

                if (!canceled)
                {
                    if (!canceling)
                    {
                        await Task.Delay(Interval);
                        Tick.Invoke();
                    }
                }
                else
                {
                    canceled = false;
                    break;
                }
            }


        }
        public void Resume()
        {
            canceling = false;
        }
        public void Cancel()
        {
            canceling = true;
        }
        public async void StartAsyncTask(thread::SynchronizationContext 
        context)
        {

                while (true)
                {
                    if (!canceled)
                    {
                    if (!canceling)
                    {
                        await Task.Delay(Interval).ConfigureAwait(false);

                        TaskAsyncTick.Invoke(context);
                    }
                    }
                    else
                    {
                        canceled = false;
                        break;
                    }
                }

        }
        public void StartAsync()
        {
            thread::ThreadPool.QueueUserWorkItem((x) =>
            {
                while (true)
                {

                    if (!canceled)
                    {
                        if (!canceling)
                        {
                            thread::Thread.Sleep(Interval);

                    Application.Current.Dispatcher.Invoke(AsyncTick);
                        }
                    }
                    else
                    {
                        canceled = false;
                        break;
                    }
                }
            });
        }

        public void StartAsync(thread::SynchronizationContext context)
        {
            thread::ThreadPool.QueueUserWorkItem((x) =>
            {
                while(true)
                 {

                    if (!canceled)
                    {
                        if (!canceling)
                        {
                            thread::Thread.Sleep(Interval);
                            context.Post((xfail) => { AsyncTick.Invoke(); }, null);
                        }
                    }
                    else
                    {
                        canceled = false;
                        break;
                    }
                }
            });
        }
        public void Abort()
        {
            canceled = true;
        }
    }


     }