Czy istnieje sposób na opóźnienie obsługi zdarzeń (na przykład przez 1 sekundę) w systemie Windows Forms

Question

Potrzebuję być w stanie opóźnić obsługę zdarzeń dla niektórych elementów sterujących (takich jak przycisk), które mają zostać uruchomione, na przykład po upływie 1 sekundy faktycznego stanu zdarzenie (na przykład zdarzenie click) ... czy jest to możliwe w ramach .net?

Używam czasomierza i wywołuję mój kod z zdarzenia znacznika czasu, jak poniżej, ale nie jestem pewien, czy to jest najlepsze podejście!

void onButtonClick(..) 
{ 
    timer1.Enabled = true; 
} 

void onTimerTick(..) 
{ 
    timer.Enabled = false; 

    CallMyCodeNow(); 
} 

Answer 1

Zanim przyszedłem na twoje pytanie, po przeczytaniu podsumowania z głównej strony z pytaniami, zegar był dokładnie tym, co zamierzałem zasugerować.

To dla mnie wygląda całkiem nieźle. Oznacza to, że możesz łatwo "anulować" opóźnione zdarzenie, na przykład, wyłączając ponownie timer. Robi to również wszystko w obrębie wątku UI (ale bez reentrancy), co sprawia, że ​​życie jest trochę prostsze niż inne alternatywy.

Answer 2

Można użyć:

Thread.Sleep(1000); 

To będzie wstrzymać bieżącego wątku na jedną sekundę. Więc zrobiłbym to ...

Pozdrawiam!

Answer 3

Być może mógłbyś stworzyć metodę, która tworzy zegar?

void onButtonClick(object sender, EventArgs e) 
{ 
    Delay(1000, (o,a) => MessageBox.Show("Test")); 
} 

static void Delay(int ms, EventHandler action) 
{ 
    var tmp = new Timer {Interval = ms}; 
    tmp.Tick += new EventHandler((o, e) => tmp.Enabled = false); 
    tmp.Tick += action; 
    tmp.Enabled = true; 
} 

Answer 4

Jeśli robisz to tylko dla jednego elementu sterującego, metoda licznika czasu będzie działać poprawnie. Bardziej zdecydowane podejście obsługi wielu kontroli i rodzaje zdarzeń wygląda mniej więcej tak:

class Event 
{ 
    public DateTime StartTime { get; set; } 
    public Action Method { get; set; } 

    public Event(Action method) 
    { 
     Method = method; 
     StartTime = DateTime.Now + TimeSpan.FromSeconds(1); 
    } 
} 

utrzymać Queue<Event> w swojej formie i mieć zdarzenia UI, które muszą być opóźnione dodać je do kolejki, np:

void onButtonClick(..) 
{ 
    EventQueue.Enqueue(new Event(MethodToCall)); 
} 

Nakręć Tick timerów 10 razy na sekundę lub tak, i jego obsługi zdarzeń Tick wyglądać następująco:

void onTimerTick() 
{ 
    if (EventQueue.Any() && EventQueue.First().StartTime >= DateTime.Now) 
    { 
     Event e = EventQueue.Dequeue(); 
     e.Method; 
    } 
} 

Answer 5

Jeśli szukasz bardziej wyszukane rozwiązanie, możesz rzucić okiem na mój Reactive LINQ project. Łącze nie pokazuje, jak rozwiązać dany problem, ale powinno być możliwe rozwiązanie w dość eleganckim stylu przy użyciu techniki tam opisanej (w całej serii 4-artykułów).

Answer 6

Moje rozwiązanie wykorzystuje System.Threading.Timer:

public static class ExecuteWithDelay 
{ 
    class TimerState 
    { 
     public Timer Timer; 
    } 

    public static Timer Do(Action action, int dueTime) 
    { 
     var state = new TimerState(); 
     state.Timer = new Timer(o => 
     { 
      action(); 
      lock (o) // The locking should prevent the timer callback from trying to free the timer prior to the Timer field having been set. 
      { 
       ((TimerState)o).Timer.Dispose(); 
      } 
     }, state, dueTime, -1); 
     return state.Timer; 
    } 
} 

Answer 7

Dla tych, ogranicza się do .NET 2.0, tu jest inny wziąć na Bengt pomocne rozwiązanie:

/// <summary> 
/// Executes the specified method in a delayed context by utilizing 
/// a temporary timer. 
/// </summary> 
/// <param name="millisecondsToDelay">The milliseconds to delay.</param> 
/// <param name="methodToExecute">The method to execute.</param> 
public static void DelayedExecute(int millisecondsToDelay, MethodInvoker methodToExecute) 
{ 
    Timer timer = new Timer(); 
    timer.Interval = millisecondsToDelay; 
    timer.Tick += delegate 
         { 
          // This will be executed on a single (UI) thread, so lock is not necessary 
          // but multiple ticks may have been queued, so check for enabled. 
          if (timer.Enabled) 
          { 
           timer.Stop(); 

           methodToExecute.Invoke(); 

           timer.Dispose(); 
          } 
         }; 

    timer.Start(); 
} 

Answer 8

zastosowanie reaktywnych rozszerzeń:

Najpierw zainstaluj pakiet nuget

PM> Install-Package Rx-Main 

Kod:

private void CallMyCodeNow() 
    { 
     label1.Text = "reactivated!"; 
    } 

    private void Form1_Load(object sender, EventArgs e) 
    { 
     var o = Observable.FromEventPattern<EventHandler, EventArgs>(
      handler => button1.Click += handler 
      , handler => button1.Click -= handler 
      ) 
      .Delay(TimeSpan.FromSeconds(5)) 
      .ObserveOn(SynchronizationContext.Current) // ensure event fires on UI thread 
      .Subscribe(
       ev => CallMyCodeNow() 
       , ex => MessageBox.Show(ex.Message) 
      ); 
    }