Le gestionnaire de commandes.InvalidateRequerySuggested() n'est pas assez rapide. Que puis-je faire?

Cette solution est une version réduite de la solution proposée par Tomáš Kafka(merci à Tomas pour décrire sa solution dans le détail)dans ce fil.

Dans Tomas de la solution qu'il avait
1) DelegateCommand
2) CommandManagerHelper
3) DelegateCommandExtensions
4) NotifyPropertyChangedBaseExtensions
5) INotifyPropertyChangedWithRaise
6) ThreadTools

Cette solution a
1) DelegateCommand
2) DelegateCommandExtensions méthode et NotifyPropertyChangedBaseExtensions méthode de Déléguer le Commandement lui-même.

Note Depuis notre application wpf suit le pattern MVVM et nous nous occupons de commandes au dernier niveau qui s'exécute dans le thread de l'INTERFACE utilisateur nous n'avons pas besoin d'obtenir la référence de l'INTERFACE utilisateur disptacher.

   using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq.Expressions;
using System.Reflection;
using System.Windows.Input;
namespace ExampleForDelegateCommand
{
public class DelegateCommand : ICommand
{
public Predicate<object> CanExecuteDelegate { get; set; }
private List<INotifyPropertyChanged> propertiesToListenTo;
private List<WeakReference> ControlEvent;
public DelegateCommand()
{
ControlEvent= new List<WeakReference>();
}
public List<INotifyPropertyChanged> PropertiesToListenTo
{
get { return propertiesToListenTo; }
set
{
propertiesToListenTo = value;
}
}
private Action<object> executeDelegate;
public Action<object> ExecuteDelegate
{
get { return executeDelegate; }
set
{
executeDelegate = value;
ListenForNotificationFrom((INotifyPropertyChanged)executeDelegate.Target);
}
}
public static ICommand Create(Action<object> exec)
{
return new SimpleCommand { ExecuteDelegate = exec };
}
#region ICommand Members
public bool CanExecute(object parameter)
{
if (CanExecuteDelegate != null)
return CanExecuteDelegate(parameter);
return true; //if there is no can execute default to true
}
public event EventHandler CanExecuteChanged
{
add
{
CommandManager.RequerySuggested += value;
ControlEvent.Add(new WeakReference(value));
}
remove
{
CommandManager.RequerySuggested -= value;
ControlEvent.Remove(ControlEvent.Find(r => ((EventHandler) r.Target) == value));
}
}
public void Execute(object parameter)
{
if (ExecuteDelegate != null)
ExecuteDelegate(parameter);
}
#endregion
public void RaiseCanExecuteChanged()
{
if (ControlEvent != null && ControlEvent.Count > 0)
{
ControlEvent.ForEach(ce =>
{
if(ce.Target!=null)
((EventHandler) (ce.Target)).Invoke(null, EventArgs.Empty);
});
}
}
public DelegateCommand ListenOn<TObservedType, TPropertyType>(TObservedType viewModel, Expression<Func<TObservedType, TPropertyType>> propertyExpression) where TObservedType : INotifyPropertyChanged
{
string propertyName = GetPropertyName(propertyExpression);
viewModel.PropertyChanged += (PropertyChangedEventHandler)((sender, e) =>
{
if (e.PropertyName == propertyName) RaiseCanExecuteChanged();
});
return this;
}
public void ListenForNotificationFrom<TObservedType>(TObservedType viewModel) where TObservedType : INotifyPropertyChanged
{
viewModel.PropertyChanged += (PropertyChangedEventHandler)((sender, e) =>
{
RaiseCanExecuteChanged();
});
}
private string GetPropertyName<T, TProperty>(Expression<Func<T, TProperty>> expression) where T : INotifyPropertyChanged
{
var lambda = expression as LambdaExpression;
MemberInfo memberInfo = GetmemberExpression(lambda).Member;
return memberInfo.Name;
}
private MemberExpression GetmemberExpression(LambdaExpression lambda)
{
MemberExpression memberExpression;
if (lambda.Body is UnaryExpression)
{
var unaryExpression = lambda.Body as UnaryExpression;
memberExpression = unaryExpression.Operand as MemberExpression;
}
else
memberExpression = lambda.Body as MemberExpression;
return memberExpression;
}
}}

Explication de la solution:

Normalement, quand on la lier à un élément de l'INTERFACE utilisateur(Bouton)de la ICommand de mise en œuvre de la WPF Bouton de registres pour un Événement "CanExecuteChanged" ICommand mise en œuvre .Si votre Icommand mise en œuvre pour "CanExecuteChanged" crochet pour le Gestionnaire de commandes de RequesySuggest événement(lire cet article http://joshsmithonwpf.wordpress.com/2008/06/17/allowing-commandmanager-to-query-your-icommand-objects/) puis quand jamais Gestionnaire de commandes détecte les conditions susceptibles de modifier la capacité d'une commande à exécuter(changements, comme le Focus se déplace et certains événements de clavier) , Gestionnaire de commandes de RequerySuggested événement se produit qui à son tour provoque le Bouton e délégué à être appelé, car nous avons accroché le buttos de delgate de Gestionnaire de commandes de RequerySuggested dans la mise en œuvre de "CanExecuteChanged" dans notre DelegateCommand .

Mais le problème est que ComandManager n'est pas toujours en mesure de détecter les changements. Donc la solution pour augmenter "CanExecuteChanged" lors de notre commande de mise en œuvre(DelegateCommand) détecte un changement.Normalement, lorsque nous déclarons la delagate pour ICommand de CanExecute dans notre viewmodel nous lier à des propriétés déclarées dans notre viewmodel et notre ICommand mise en œuvre peut écouter "propertychanged" événements sur ces propriétés. C'est ce que le "ListenForNotificationFrom" méthode de la DelegateCommand n'. Dans le cas où le code du client n'enregistre pas les propriétés spécifiques des changements DelegateCommand par défaut à l'écoute de tout changement de propriété sur le modèle de vue où la commande est déclarée et définie.

"ControlEvent" dans DelegateCommand qui est liste du Gestionnaire d'événements qui stocke le Bouton
"CanExecuteChange EventHandler" est déclaré comme référence faible pour éviter les fuites de mémoire.

Comment ViewModel utiliser cette DelegateCommand
Il y a 2 façons de l'utiliser.
(le deuxième usage est plus spécifique pour les propriétés que vous souhaitez que la Commande écouter.

delegateCommand = new DelegateCommand
{
ExecuteDelegate = Search,
CanExecuteDelegate = (r) => !IsBusy
};
anotherDelegateCommand = new DelegateCommand
{
ExecuteDelegate = SearchOne,
CanExecuteDelegate = (r) => !IsBusyOne
}.ListenOn(this, n => n.IsBusyOne);

Détaillée ViewModel

  public class ExampleViewModel
{
public SearchViewModelBase()
{
delegateCommand = new DelegateCommand
{
ExecuteDelegate = Search,
CanExecuteDelegate = (r) => !IsBusy
};
anotherDelegateCommand = new DelegateCommand
{
ExecuteDelegate = SearchOne,
CanExecuteDelegate = (r) => !IsBusyOne
}.ListenOn(this, n => n.IsBusyOne);
}
private bool isBusy;
public virtual bool IsBusy
{
get { return isBusy; }
set
{
if (isBusy == value) return;
isBusy = value;
NotifyPropertyChanged(MethodBase.GetCurrentMethod());
}
}
private bool isBusyOne;
public virtual bool IsBusyOne
{
get { return isBusyOne; }
set
{
if (isBusyOne == value) return;
isBusyOne = value;
NotifyPropertyChanged(MethodBase.GetCurrentMethod());
}
}
private void Search(object obj)
{
IsBusy = true;
new SearchService().Search(Callback);
}  
public void Callback(ServiceResponse response)
{
IsBusy = false;
}  
private void Search(object obj)
{
IsBusyOne = true;
new SearchService().Search(CallbackOne);
}  
public void CallbackOne(ServiceResponse response)
{
IsBusyOne = false;
}          
private void NotifyPropertyChanged(string propertyName)
{
if (PropertyChanged != null)
{
PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
}
} 
private void NotifyPropertyChanged(MethodBase methodBase)
{
string methodName = methodBase.Name;
if (!methodName.StartsWith("set_"))
{
var ex = new ArgumentException("MethodBase must refer to a Property Setter method.");
throw ex;
}
NotifyPropertyChanged(methodName.Substring(4));
}

}

Je suggère de regarder dans ReactiveUI et spécifiquement à la ICommand mise en œuvre qu'il fournit, ReactiveCommand. Il utilise une approche différente de celle DelegateCommand/RelayCommand qui sont mis en œuvre avec les délégués pour CanExecute qui doit être activement évalué. ReactiveCommand de la valeur pour CanExecute est poussé à l'aide de IObservables.

Essayez d'écrire votre propre liaison qui appelle votre RaiseCanExecuteChanged() dans les convertit? il est plus facile