PropertyChangedEventHandler est null dans FirePropertyChanged

Question

J'ai un viewmodel nommé EmployeeViewModel qui est hérité de ViewModelBase. voici l'implémentation de ViewModelBase.

public event PropertyChangedEventHandler PropertyChanged; 
    public void FirePropertyChanged(string propertyname) 
    { 
     var handler = PropertyChanged; 
     if (handler != null) 
      handler(this, new PropertyChangedEventArgs(propertyname)); 
    } 
    public void FirePropertyChanged<TValue>(Expression<Func<TValue>> propertySelector) 
    { 
     if (PropertyChanged != null) 
     { 
      var memberExpression = propertySelector.Body as MemberExpression; 
      if (memberExpression != null) 
      { 
       PropertyChanged(this, new PropertyChangedEventArgs(memberExpression.Member.Name)); 
      } 
     } 
    } 

Mon EmployeeViewModel a un nom de propriété GridResults, qui est lié à la grille View, voici la définition de la propriété.

public PagedCollectionView GridResults 
    { 
     get { return _gridResults; } 
     set 
     { 
      _gridResults = value; 
      FirePropertyChanged(()=>GridResults); 
     } 
    } 

Maintenant, quand je mets la valeur de GridResults quelque part dans le code EmployeeViewModel, il déclenche l'événement de changement de propriété et va dans

FirePropertyChanged (Expression> propertySelector)

mais à l'intérieur de cette méthode son PropertyChangedEventHandler reste toujours nul et empêche l'exécution complète de la méthode. En fin de compte, ma Grid on View reste inaperçue que ses sources sous-jacentes ont été modifiées.

Ai-je raté quelque chose ??

Thankx à l'avance

-K9

Answer 1

Est-ce que votre ViewModelBase vraiment mettre en œuvre INotifyPropertyChanged?

Si oui, essayez le paramètre FirePropertyChanged avec string.

public PagedCollectionView GridResults 
{ 
    get { return _gridResults; } 
    set 
    { 
     _gridResults = value; 
     FirePropertyChanged("GridResults"); 
    } 
} 

BTW ici est la classe INPCBase j'utilise:

/// <summary> 
/// Basisklasse für INotifyPropertyChanged. 
/// </summary> 
public class INPCBase : INotifyPropertyChanged 
{ 
    #region INotifyPropertyChanged Members 

    public event PropertyChangedEventHandler PropertyChanged; 

    /// <summary> 
    /// Notify mittels PropertyInfo. HINWEIS: diese Variante ist ungefähr 3x langsamer wie 
    /// <see cref="NotifyPropertyChanged(string)"/> bzw. <see cref="NotifyPropertyChanged(System.ComponentModel.PropertyChangedEventArgs)"/>. 
    /// </summary> 
    /// <example> 
    /// <code> 
    /// public string InfoMessage 
    /// { 
    ///  get {return this.infomessage;} 
    ///  set 
    ///  { 
    ///   this.infomessage = value; 
    ///   this.NotifyPropertyChanged(()=> this.InfoMessage); 
    ///  } 
    /// } 
    /// </code> 
    /// </example> 
    /// <typeparam name="T"></typeparam> 
    /// <param name="property"></param> 
    protected void NotifyPropertyChanged<T>(Expression<Func<T>> property) 
    { 
     var propertyInfo = ((MemberExpression)property.Body).Member as PropertyInfo; 

     if (propertyInfo == null) 
     { 
      throw new ArgumentException("The lambda expression 'property' should point to a valid Property"); 
     } 

     this.VerifyPropertyName(propertyInfo.Name); 

     var handler = PropertyChanged; 

     if (handler != null) 
      handler(this, new PropertyChangedEventArgs(propertyInfo.Name)); 
    } 

    /// <summary> 
    /// Notify using pre-made PropertyChangedEventArgs 
    /// </summary> 
    /// <param name="args"></param> 
    protected void NotifyPropertyChanged(PropertyChangedEventArgs args) 
    { 
     this.VerifyPropertyName(args.PropertyName); 

     var handler = PropertyChanged; 

     if (handler != null) 
     { 
      handler(this, args); 
     } 
    } 

    /// <summary> 
    /// Notify using String property name 
    /// </summary> 
    protected void NotifyPropertyChanged(String propertyName) 
    { 
     this.VerifyPropertyName(propertyName); 

     var handler = PropertyChanged; 

     if (handler != null) 
     { 
      handler(this, new PropertyChangedEventArgs(propertyName)); 
     } 
    } 

    #endregion 

    #region Debugging Aides 

    /// <summary> 
    /// Warns the developer if this object does not have 
    /// a public property with the specified name. This 
    /// method does not exist in a Release build. 
    /// </summary> 
    [Conditional("DEBUG")] 
    [DebuggerStepThrough] 
    public void VerifyPropertyName(string propertyName) 
    { 
     // Verify that the property name matches a real, 
     // public, instance property on this object. 
     if (TypeDescriptor.GetProperties(this)[propertyName] != null) 
      return; 

     var msg = "Invalid property name: " + propertyName; 

     if (this.ThrowOnInvalidPropertyName) 
      throw new Exception(msg); 

     Debug.Fail(msg); 
    } 

    /// <summary> 
    /// Returns whether an exception is thrown, or if a Debug.Fail() is used 
    /// when an invalid property name is passed to the VerifyPropertyName method. 
    /// The default value is false, but subclasses used by unit tests might 
    /// override this property's getter to return true. 
    /// </summary> 
    protected virtual bool ThrowOnInvalidPropertyName { get; private set; } 

    #endregion // Debugging Aides 
}