C # 타이머와 같은 WPF 타이머

WPF의 C # Timer Control과 같은 컨트롤을 어디에서 찾을 수 있습니까?

일반적인 WPF 타이머는 DispatcherTimer컨트롤이 아니라 코드에 사용되는입니다. 기본적으로 WinForms 타이머와 같은 방식으로 작동합니다.

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에 대한 자세한 내용은 여기를 참조하십시오.

Dispatcher를 사용하면 다음을 포함해야합니다.

using System.Windows.Threading;

또한 DispatcherTimer를 마우스 오른쪽 단추로 클릭하고 해결을 클릭하면 적절한 참조가 추가되어야합니다.

당신은 또한 사용할 수 있습니다

using System.Timers;
using System.Threading;

타이머에는 특별한 기능이 있습니다.

1. 비동기 타이머 또는 동기 타이머를 호출하십시오.
2. 시간 간격 변경
3. 취소 및 재개 가능  

당신이 사용하는 경우 StartAsync ()또는 Start ()스레드는 사용자 인터페이스 요소를 차단하지 않습니다

     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;
        }
    }


     }