Discussion :

[shenron666]

Bonjour,

Je cherche à filtrer le traitement d'un event qui peut être déclenché plusieurs fois rapidement.
Je voudrai qu'une des tâches effectuées par le déclenchement de cet event ne s'effectue pas à chaque déclenchement.

Je me suis demandé si je pouvais utiliser Rx Framework et la méthode throttle pour arriver à mes fins mais je ne vois pas comment faire.
L'exemple du throttle est ici : http://rxwiki.wikidot.com/101samples#toc29

si quelqu'un connait RX et pouvait m'orienter vers la solution ce serai sympa
de plus, est-ce que Throttle est la bonne méthode ? :/

[tomlev]

Oui, c'est bien Throttle qu'il faut utiliser. Tu as un exemple ici :
http://www.japf.fr/2011/02/techdays-...d-source-code/

EDIT: tout bien réfléchi, je ne suis pas certain que Throttle soit ce que tu veux... Si tu mets un Throttle de 1 seconde, il va attendre 1 seconde après la réception du dernier évènement. Si un autre évènement se produit avant la fin de la seconde, le compteur repart à 0 et ça attend de nouveau une seconde. Autrement dit, si ton évènement se produit toutes les demi-secondes, le Throttle ne le laissera jamais passer... C'est utile par exemple pour faire un système d'auto-complétion au fur et à mesure de la saisie, mais ce n'est pas adapté pour limiter le nombre d'évènements par intervalle de temps. Pour faire ça il faut utiliser Sample plutôt que Throttle

[shenron666]

Merci pour ton lien Thomas
Je ne pense pas que Sample soit adapté, le comportement que je cherche à obtenir est le résultat d'un ou plusieurs clics de l'utilisateur

Je n'arrive pas à faire fonctionner Rx, je ne dois pas comprendre le fonctionnement

Voici un exemple simple où en cliquant sur un bouton, on ajoute un message dans une collection et Rx devrait recopier le dernier message dans une string :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
    public class MainViewModel : NotificationObject
    {
        private IObservable<string> _dummyObservable;
        private IDisposable _dummySubscription;
 
        public MainViewModel()
        {
            _dummyObservable = Messages.ToObservable()
                .Throttle(TimeSpan.FromSeconds(1));
            _dummySubscription = _dummyObservable.Subscribe(o => Message = o);
            InitializeCommands();
            Message = "Hello WPF";
        }
 
        private string _message = string.Empty;
        public string Message
        {
            get { return _message; }
            set
            {
                _message = value;
                RaisePropertyChanged(() => Message);
            }
        }
 
        private ObservableCollection<string> _messages = new ObservableCollection<string>();
        public ObservableCollection<string> Messages
        {
            get { return _messages; }
        }
 
        private void InitializeCommands()
        {
            AddItemCommand = new DelegateCommand(AddItemExecute);
        }
 
        public ICommand AddItemCommand { get; private set; }
        private int _counter = 0;
        private void AddItemExecute()
        {
            Messages.Add("Counter = " + ++_counter);
        }
    }

j'ai créé une fenêtre WPF dans laquelle j'ai :
- une TextBox qui affiche la string Message
- une ListBox qui affiche la collection Messages
- un Button qui execute la commande AddItemCommand

résultat ? il ne se passe rien
hormis le remplissage de la ListBox du fait du peuplement de la collection

[tomlev]

par conte, je ne pense pas que Sample soit adapté, vu que le comportement que je cherche à obtenir soit le résultat d'un ou plusieurs clic de l'utilisateur

Je comprends pas ce que tu veux dire...

par contre, je n'arrive pas à faire fonctionner Rx, je ne dois pas comprendre le fonctionnement

Tu ne peux pas te baser sur une collection comme tu le fais, ça ne fonctionne pas comme ça... Quand tu t'abonnes à l'observable renvoyé par Messages.ToObservable(), ça consomme immédiatement ce qu'il y a dans la collection, et les éléments ajoutés après ne sont pas pris en compte.

Le plus simple est de gérer ça au niveau du code-behind avec Observable.FromEvent, mais vu que c'est du MVVM tu préfères peut-être gérer ça entièrement dans le ViewModel. Dans ce cas le plus simple est d'utiliser un Subject<string> :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
    public class MainViewModel : NotificationObject
    {
        private IObservable<string> _dummyObservable;
        private IDisposable _dummySubscription;
        private Subject<string> _changes;
 
        public MainViewModel()
        {
            _changes = new Subject<string>();
            _dummyObservable = _changes.Throttle(TimeSpan.FromSeconds(1));
            _dummySubscription = _dummyObservable.Subscribe(o => Message = o);
            InitializeCommands();
            Message = "Hello WPF";
        }
 
        private string _message = string.Empty;
        public string Message
        {
            get { return _message; }
            set
            {
                _message = value;
                RaisePropertyChanged(() => Message);
            }
        }
 
        private ObservableCollection<string> _messages = new ObservableCollection<string>();
        public ObservableCollection<string> Messages
        {
            get { return _messages; }
        }
 
        private void InitializeCommands()
        {
            AddItemCommand = new DelegateCommand(AddItemExecute);
        }
 
        public ICommand AddItemCommand { get; private set; }
        private int _counter = 0;
        private void AddItemExecute()
        {
            string newValue = "Counter = " + ++_counter;
            Messages.Add(newValue);
            _changes.OnNext(newValue);
        }
    }

[shenron666]

Je comprends pas ce que tu veux dire...

j'ai édité mon post précédent pour être plus clair, enfin j'espère :p

merci pour ton exemple, ça fonctionne du tonnerre à l'aide de Subject
mieux qu'avec mon throttle "maison"

à part les exemples pas très explicites à mon goût, tu ne connaîtrais pas un tuto qui expliquerait plus concrètement le fonctionnement de Rx ?

[tomlev]

à part les exemples pas très explicites à mon goût, tu ne connaîtrais pas un tuto qui expliquerait plus concrètement le fonctionnement de Rx ?

Pas vraiment... En général quand je l'utilise j'y vais un peu à tatons, en fouillant la doc.

[shenron666]

ok, je vais me coltiner la doc
sinon j'ai trouvé un outil qui semble intéressant : RxSandbox
pas encore eu le temps de tester mais ça peut servir à d'autres

et encore merci pour ton aide

[tomlev]

ok, je vais me coltiner la doc

C'est pas si méchant que ça, vu qu'une grande partie des opérateurs sont les mêmes que dans Linq et ont la même signification . Il faut juste voir ceux qui sont spécifiques à Rx, et en général le nom indique assez clairement ce qu'ils font.

sinon j'ai trouvé un outil qui semble intéressant : RxSandbox

Sympa ce truc, je connaissais pas