# Un helper pour différer l’exécution d’une action

> Pour rendre nos applications fluides et réactives il faut contrôler le nombre d’accès aux opérations coûteuses en temps (appel à la base de donnée, sur le système…

- Auteur: Jérôme Giacomini
- Langue: fr
- URL canonique: [Un helper pour différer l’exécution d’une action](https://jeromegiacomini.net/fr/articles/un-helper-pour-differer-lexecution-dune-action)
- Dernière modification: 2026-09-05
- Thèmes: .NET, C#, Windows

Pour rendre nos applications fluides et réactives il faut contrôler le nombre d’accès aux opérations coûteuses en temps (appel à la base de donnée, sur le système de fichier, …), pour les effectuer le moins de fois possible.

Or dans certains cas on ne peut pas prédire à l'avance si une méthode va être appelée une fois ou plusieurs fois dans un court laps de temps.

Par exemple lorsque l'on s'abonne à l'évènement **CollectionChanged** d'une **ObservableCollection, **ou lorsque l’on veut déclencher une action lors d’un changement de texte.

## Une solution possible

Une des stratégies pour résoudre ce problème est de contrôler ces accès coûteux et les effectuer les moins de fois possible.

Dans cette optique j’ai développé un petit helper, qui retarde l’exécution d’une action, si entre ce délai une action est lancée la précédente ne sera jamais exécuté.

L’utilisation est très simple :

```csharp
_delayActionHelper.ExecuteActionAfterDelay(async () =>
{
    AMethodExecuteOnlyOneTime();
});
```


![DelayHelper](https://infiniteblogs.blob.core.windows.net/medias/6029/DelayHelper_thumb_7FAB74A0.gif)

## L’implémentation :

```csharp
/// <summary>
/// Helper which delay an action. 
/// If the same action is trigger wait to run it
/// </summary>
public class DelayActionHelper
{
    #region Fields
    DispatcherTimer _timer;
    Action _action;
    DateTime _dateToExecute;
    readonly int _delaySeconds;
    #endregion

    public DelayActionHelper(int delaySeconds = 3)
    {
        _delaySeconds = delaySeconds;
    }
    /// <summary>
    /// Enables the timer.
    /// </summary>
    void EnableTimer()
    {
        if (_timer == null)
        {
            _timer = new DispatcherTimer();
            _timer.Interval = TimeSpan.FromSeconds(_delaySeconds);
            _timer.Tick += _timer_Tick;
        }
        if (!_timer.IsEnabled)
            _timer.Start();
    }

    private void _timer_Tick(object sender, object e)
    {
        //Si on peut exécuté l’action alors on l’exécute…
        if (DateTime.Now > _dateToExecute)
        {
            var action = _action;
            //On a exécuté l’action on peut arrêter le timer
            _timer.Stop();
            if (action != null)
            {
                action();
                _action = null;
            }
        }
    }
    /// <summary>
    /// Execute action after a delay
    /// </summary>
    /// <param name="action">The action to execute.</param>
    public void ExecuteActionAfterDelay(Action action)
    {
        _action = action;
        _dateToExecute = DateTime.Now.AddSeconds(_delaySeconds);
        EnableTimer();
    }
}
```

Happy Coding 
![Rire](https://infiniteblogs.blob.core.windows.net/medias/6029/wlEmoticon-openmouthedsmile_4AD7D81A.png)