ForcePropertyChanged does not fire interceptors

 

Unfortunately, there is no way to force the interceptors to fire.  You can, with some pain, obtain the interceptor actions and invoke them, but this is difficult because these methods take generic arguments and require that you already know the properties and data types (e.g, Employee.EmployeeIdDataProperty.GetterInterceptor.GetActions() or PropertyInterceptorManager.CurrentInstance.GetActions<TArgs>(type, property, mode)). 

 

A somewhat heavy handed approach would be to invoke the getters (and setters) to force the interceptors to be called.  (In the next release, setting a value to itself will not dirty the item as it does now.)   Something like this will invoke the getters for data properties (not navigation properties) -

 

      var props = _entityManager.MetadataStore.GetEntityMetadata(typeof(Employee)).DataProperties;
      foreach (DataEntityProperty p in props) {
        p.GetValue(anEmployee);
      }

var actions = AbstractEntity.IdEntityProperty.GetterInterceptor.GetActions();       var args = new DataEntityPropertyGetInterceptorArgs<AbstractEntity,int>(AbstractEntity.IdEntityProperty, anEntity, null);       foreach (var a in actions) {         a.Action(args);       }

After going to all this trouble, though, you're doing almost what the GetValue() call does - really everything but returning the property value - so it might be easier to call GetValue(), unless you what to exclude certain actions.

 

I've changed the code as suggested. But it still doesn't find any Interceptors. I guess it's because we don't have any 'Get' Interceptors. We only have 'After Set' interceptors in our ViewModel. Below is what we generate in the ViewModel to intercept the Set actions on the Model. These Actions take care of forwarding the Value of the Properties to the WPF UI.

 

Regards

Paul Sinnema

Diartis AG

   #region Add Actions for Getter/Setters
   
   // Allproperties Count      : 8
   // --------------------------------
            // Property                 : Id
            // MustGenerateInterceptor  : True
            // Navigation               : False
   m_IdAction = new PropertyInterceptorAction<DataEntityPropertySetInterceptorArgs<DomainModel.AbstractEntity, Int32>>(
          typeof(DomainModel.AbstractEntity),
          DomainModel.AbstractEntity.EntityPropertyNames.Id,
          PropertyInterceptorMode.AfterSet,
          IdSetter);
   PropertyInterceptorManager.CurrentInstance.AddAction(m_IdAction);
   m_Id.Value = m_AbstractEntity.Id;
   m_Id.ValueChanged += IdOnValueChanged;
            // Property                 : CreatedOn
            // MustGenerateInterceptor  : True
            // Navigation               : False
   m_CreatedOnAction = new PropertyInterceptorAction<DataEntityPropertySetInterceptorArgs<DomainModel.AbstractEntity, DateTime>>(
          typeof(DomainModel.AbstractEntity),
          DomainModel.AbstractEntity.EntityPropertyNames.CreatedOn,
          PropertyInterceptorMode.AfterSet,
          CreatedOnSetter);
   PropertyInterceptorManager.CurrentInstance.AddAction(m_CreatedOnAction);
   
            // Property                 : CreatedBy
            // MustGenerateInterceptor  : True
            // Navigation               : False
   m_CreatedByAction = new PropertyInterceptorAction<DataEntityPropertySetInterceptorArgs<DomainModel.AbstractEntity, Int32>>(
          typeof(DomainModel.AbstractEntity),
          DomainModel.AbstractEntity.EntityPropertyNames.CreatedBy,
          PropertyInterceptorMode.AfterSet,
          CreatedBySetter);
   PropertyInterceptorManager.CurrentInstance.AddAction(m_CreatedByAction);
   m_CreatedBy.Value = m_AbstractEntity.CreatedBy;
   
            // Property                 : ChangedOn
            // MustGenerateInterceptor  : True
            // Navigation               : False
   m_ChangedOnAction = new PropertyInterceptorAction<DataEntityPropertySetInterceptorArgs<DomainModel.AbstractEntity, DateTime>>(
          typeof(DomainModel.AbstractEntity),
          DomainModel.AbstractEntity.EntityPropertyNames.ChangedOn,
          PropertyInterceptorMode.AfterSet,
          ChangedOnSetter);
   PropertyInterceptorManager.CurrentInstance.AddAction(m_ChangedOnAction);
   
            // Property                 : ChangedBy
            // MustGenerateInterceptor  : True
            // Navigation               : False
   m_ChangedByAction = new PropertyInterceptorAction<DataEntityPropertySetInterceptorArgs<DomainModel.AbstractEntity, Int32>>(
          typeof(DomainModel.AbstractEntity),
          DomainModel.AbstractEntity.EntityPropertyNames.ChangedBy,
          PropertyInterceptorMode.AfterSet,
          ChangedBySetter);
   PropertyInterceptorManager.CurrentInstance.AddAction(m_ChangedByAction);
   m_ChangedBy.Value = m_AbstractEntity.ChangedBy;
   
            // Property                 : DeletedOn
            // MustGenerateInterceptor  : True
            // Navigation               : False
   m_DeletedOnAction = new PropertyInterceptorAction<DataEntityPropertySetInterceptorArgs<DomainModel.AbstractEntity, DateTime?>>(
          typeof(DomainModel.AbstractEntity),
          DomainModel.AbstractEntity.EntityPropertyNames.DeletedOn,
          PropertyInterceptorMode.AfterSet,
          DeletedOnSetter);
   PropertyInterceptorManager.CurrentInstance.AddAction(m_DeletedOnAction);
   
            // Property                 : DeletedBy
            // MustGenerateInterceptor  : True
            // Navigation               : False
   m_DeletedByAction = new PropertyInterceptorAction<DataEntityPropertySetInterceptorArgs<DomainModel.AbstractEntity, Int32?>>(
          typeof(DomainModel.AbstractEntity),
          DomainModel.AbstractEntity.EntityPropertyNames.DeletedBy,
          PropertyInterceptorMode.AfterSet,
          DeletedBySetter);
   PropertyInterceptorManager.CurrentInstance.AddAction(m_DeletedByAction);
   m_DeletedBy.Value = m_AbstractEntity.DeletedBy;
   
            // Property                 : UserToken
            // MustGenerateInterceptor  : True
            // Navigation               : False
   m_UserTokenAction = new PropertyInterceptorAction<DataEntityPropertySetInterceptorArgs<DomainModel.AbstractEntity, Guid?>>(
          typeof(DomainModel.AbstractEntity),
          DomainModel.AbstractEntity.EntityPropertyNames.UserToken,
          PropertyInterceptorMode.AfterSet,
          UserTokenSetter);
   PropertyInterceptorManager.CurrentInstance.AddAction(m_UserTokenAction);
   m_UserToken.ValueChanged += UserTokenOnValueChanged;

   #endregion

 

==================================================================

 

This is what I generate now:

 

==================================================================

 

// [DebuggerNonUserCode]
  public void Refresh()
  {

   var actionsId = AbstractEntity.IdEntityProperty.GetterInterceptor.GetActions();
   var argsId = new DataEntityPropertyGetInterceptorArgs<AbstractEntity,Int32>(AbstractEntity.IdEntityProperty, this, null);
   foreach ( var a in actionsId) { a.Action(argsId); }
     
   var actionsCreatedOn = AbstractEntity.CreatedOnEntityProperty.GetterInterceptor.GetActions();
   var argsCreatedOn = new DataEntityPropertyGetInterceptorArgs<AbstractEntity,DateTime>(AbstractEntity.CreatedOnEntityProperty, this, null);
   foreach ( var a in actionsCreatedOn) { a.Action(argsCreatedOn); }
     
   var actionsCreatedBy = AbstractEntity.CreatedByEntityProperty.GetterInterceptor.GetActions();
   var argsCreatedBy = new DataEntityPropertyGetInterceptorArgs<AbstractEntity,Int32>(AbstractEntity.CreatedByEntityProperty, this, null);
   foreach ( var a in actionsCreatedBy) { a.Action(argsCreatedBy); }
     
   var actionsChangedOn = AbstractEntity.ChangedOnEntityProperty.GetterInterceptor.GetActions();
   var argsChangedOn = new DataEntityPropertyGetInterceptorArgs<AbstractEntity,DateTime>(AbstractEntity.ChangedOnEntityProperty, this, null);
   foreach ( var a in actionsChangedOn) { a.Action(argsChangedOn); }
     
   var actionsChangedBy = AbstractEntity.ChangedByEntityProperty.GetterInterceptor.GetActions();
   var argsChangedBy = new DataEntityPropertyGetInterceptorArgs<AbstractEntity,Int32>(AbstractEntity.ChangedByEntityProperty, this, null);
   foreach ( var a in actionsChangedBy) { a.Action(argsChangedBy); }
     
   var actionsDeletedOn = AbstractEntity.DeletedOnEntityProperty.GetterInterceptor.GetActions();
   var argsDeletedOn = new DataEntityPropertyGetInterceptorArgs<AbstractEntity,DateTime?>(AbstractEntity.DeletedOnEntityProperty, this, null);
   foreach ( var a in actionsDeletedOn) { a.Action(argsDeletedOn); }
     
   var actionsDeletedBy = AbstractEntity.DeletedByEntityProperty.GetterInterceptor.GetActions();
   var argsDeletedBy = new DataEntityPropertyGetInterceptorArgs<AbstractEntity,Int32?>(AbstractEntity.DeletedByEntityProperty, this, null);
   foreach ( var a in actionsDeletedBy) { a.Action(argsDeletedBy); }
     
   var actionsUserToken = AbstractEntity.UserTokenEntityProperty.GetterInterceptor.GetActions();
   var argsUserToken = new DataEntityPropertyGetInterceptorArgs<AbstractEntity,Guid?>(AbstractEntity.UserTokenEntityProperty, this, null);
   foreach ( var a in actionsUserToken) { a.Action(argsUserToken); }
     
  }

 

Entity properties have both a GetterInterceptor and a SetterInterceptor (except for NavigationListEntityProperties, which don't have setters) so you can always obtain the actions from the appropriate interceptor.  Calling setter actions is a little tricky, however, since you need to determine what property value, if any, you pass to the action.

 

Here's how to obtain and invoke the setter actions for a property.  

 

      var actions = AbstractEntity.IdEntityProperty.SetterInterceptor.GetActions();

 

      // Now set up arguments and invoke -
      var args = new DataEntityPropertySetInterceptorArgs<AbstractEntity, int>(AbstractEntity.IdEntityProperty, this, null);
      args.Value = ???????
      args.Tag = "dummy call";
      foreach (var a in actions) {
        a.Action(args);
      }

 

I'm not really sure if this is what you need, though.  You said you want to "get the values from the properties without invoking any interceptors", which may be something entirely different.  Setter interceptor actions are code that runs before or after a property value is set, but the value comes from elsewhere.  Getter actions would be the code run before or after the value is obtained from the "backing store".  In both cases, if you invoke the interceptor actions separate from the actual property getter or setter, then you need to be careful with the arguments received by the action (e.g., post-get actions will not have an args.Value since the actual get wasn't performed).

 

It is possible to temporarily "skip" actions.  Using AddSkipKey and RemoveSkipKey on the interceptor you can indicate the named action to be skipped.  You must provide a key name on each action, and to add or remove multiple actions you need to call the method for each key.

 

      // Assume an action with a key name of "A"

      AbstractEntity.IdEntityProperty.GetterInterceptor.AddSkipKey("A");

      // Action won't be called when do the get now
      var name = anEntity.Id;

      // Add the action back
      AbstractEntity.IdEntityProperty.GetterInterceptor.RemoveSkipKey("A");

 

I'm not certain how the performance is with this, so you may need to do some timings if this is in a performance critical piece of your code. 

 

Another option is to use the Tags property in the getter or setter arguments to indicate what the action should do.  You could set the Tag when building the arguments, as shown at the beginning of this post.