A reusable component designed to allow only the most recent requests to update the UI

Sequencer.cs

public interface ISequencerToken 
{
  bool IsCurrent { get; }
}

public class Sequencer 
{
  private long _currentToken = 0;
  
  private long Bump() 
  { 
    return Interlocked.Increment(ref _currentToken); 
  }
    
  public ISequencerToken GetToken() 
  { 
    return new Token(this); 
  }

  private class Token : ISequencerToken 
  {
    private readonly long _val;
    private readonly Sequencer _sequencer;

    public Token(Sequencer sequencer) 
    { 
      _sequencer = sequencer; 
      _val = _sequencer.Bump(); 
    }

    public bool IsCurrent 
    { 
      get { return _sequencer._currentToken == _val; } }
  }
}

Usage.cs

class SomeViewModel
{
  private readonly Sequencer _seq = new Sequencer();

  public async void DoStuff()
  {
    var token = _seq.GetToken();
    var results = await _someService.GetResults();
    if(token.IsCurrent)
    {
      UI.UpdateWith(results);
    }
  }
}

So if you fire DoStuff() 1000 times only the last one will update the UI