Cách dừng System.Threading.Timer trong phương thức gọi lại

Question

Làm cách nào để dừng System.Threading.Timer trong phương thức gọi lại của nó. Tôi đã tham chiếu MSDN, nhưng không thể tìm thấy bất kỳ điều gì hữu ích. Hãy giúp tôi.

Answer 1

timer.Change(Timeout.Infinite, Timeout.Infinite); 

Answer 2

Bạn chỉ cần gọi myTimer.Change(Timeout.Infinite, Timeout.Infinite).

Về mặt kỹ thuật, chỉ cần tham số đầu tiên (dueTime) là Timeout.Infinite để hẹn giờ dừng.

Để biết thêm thông tin, hãy xem Timer.Change Method.

Answer 3

Hãy thử điều này:

Nếu bạn muốn, bạn có thể cho phép timer tiếp tục bắn phương pháp gọi lại và bao gồm mã dưới đây

private void CreatorLoop(object state) 
{ 
    if (Monitor.TryEnter(lockObject) 
    { 
    try 
    { 
     // Work here 
    } 
    finally 
    { 
     Monitor.Exit(lockObject); 
    } 
    } 
} 

kiểm tra liên kết này quá:

Stopping timer in its callback method

Answer 4

Đầu tiên, phương thức gọi lại phải có cá thể bộ đếm thời gian trong phạm vi.

Sau đó, câu thần chú đơn giản

timerInstance.Change(Timeout.Infinite , Timeout.Infinite) ; 

sẽ tắt bộ đếm thời gian. Có thể bộ hẹn giờ có thể gọi lại phương thức gọi lại một lần nữa sau khi thay đổi, tôi tin rằng, tùy thuộc vào trạng thái của nó.

Answer 5

Tôi phát hiện ra một cách khó khăn mà Change (Timeout.Infinite, Timeout.Infinite) isn ' t khá đáng tin cậy, và chuyển sang System.Timers.Timer với AutoReset = false.

Answer 6

Sự cố với Bộ hẹn giờ là nó có thể được gọi sau khi xử lý lớp chủ sở hữu của nó. Việc thực hiện sau đây đã làm việc cho tôi bằng cách sử dụng đối tượng trạng thái của bộ khởi tạo Timer. Heap sẽ không loại bỏ đối tượng đó cho đến khi nó được tiêu thụ. Đây là cách duy nhất của tôi để dọn dẹp hẹn giờ một cách duyên dáng.

using System; 
using System.Threading; 

namespace TimerDispose 
{ 
    /// <summary> 
    /// A timer-containing class that can be disposed safely by allowing the timer 
    /// callback that it must exit/cancel its processes 
    /// </summary> 
    class TimerOwner : IDisposable 
    { 
     const int dueTime = 5 * 100;  //halve a second 
     const int timerPeriod = 1 * 1000; //Repeat timer every one second (make it Timeout.Inifinite if no repeating required) 

     private TimerCanceller timerCanceller = new TimerCanceller(); 

     private Timer timer; 

     public TimerOwner() 
     { 
      timerInit(dueTime); 
     } 

     byte[] dummy = new byte[100000]; 

     /// <summary> 
     /// 
     /// </summary> 
     /// <param name="dueTime">Pass dueTime for the first time, then TimerPeriod will be passed automatically</param> 
     private void timerInit(int dueTime) 
     { 

      timer = new Timer(timerCallback, 
       timerCanceller,  //this is the trick, it will be kept in the heap until it is consumed by the callback 
       dueTime, 
       Timeout.Infinite 
      ); 

     } 

     private void timerCallback(object state) 
     { 
      try 
      { 
       //First exit if the timer was stoped before calling callback. This info is saved in state 
       var canceller = (TimerCanceller)state; 
       if (canceller.Cancelled) 
       { 
        return; // 
       } 

       //Your logic goes here. Please take care ! the callback might have already been called before stoping the timer 
       //and we might be already here after intending of stoping the timer. In most cases it is fine but try not to consume 
       //an object of this class because it might be already disposed. If you have to do that, hopefully it will be catched by 
       //the ObjectDisposedException below 




       dummy[1] = 50; //just messing up with the object after it might be disposed/nulled 

       //Yes, we need to check again. Read above note 
       if (canceller.Cancelled) 
       { 
        //Dispose any resource that might have been initialized above 
        return; // 
       } 

       if (timerPeriod != Timeout.Infinite) 
       { 
        timerInit(timerPeriod); 
       } 
      } 
      catch (ObjectDisposedException ex) 
      { 
       Console.WriteLine("A disposed object accessed"); 
      } 
      catch (NullReferenceException ex) 
      { 
       Console.WriteLine("A nulled object accessed"); 
      } 
      catch (Exception ex) 
      { 

      } 
     } 

     public void releaseTimer() 
     { 
      timerCanceller.Cancelled = true; 
      timer.Change(Timeout.Infinite, Timeout.Infinite); 
      timer.Dispose(); 
     } 

     public void Dispose() 
     { 
      releaseTimer(); 
      dummy = null; //for testing 
      GC.SuppressFinalize(this); 
     } 
    } 

    class TimerCanceller 
    { 
     public bool Cancelled = false; 
    } 


    /// <summary> 
    /// Testing the implementation 
    /// </summary> 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      var list = new System.Collections.Generic.List<TimerOwner>(); 
      Console.WriteLine("Started initializing"); 
      for (int i = 0; i < 500000; i++) 
      { 
       list.Add(new TimerOwner()); 
      } 

      Console.WriteLine("Started releasing"); 
      foreach (var item in list) 
      { 
       item.Dispose(); 
      } 

      Console.WriteLine("Press any key to exit"); 
      Console.ReadKey(); 
     } 
    } 
}