Adding Aspects to Derived Classes - postsharp

Question

I had wrote an aspect that works fine, but only on base classes, on derived classes do nothing.
Please, what I am missing?
The code is as follow
public interface INotifyOnChange : INotifyPropertyChanged
{
void OnPropertyChanged(string propertyName);
}
[Serializable]
[AspectConfiguration(AspectPriority = 10)]
[IntroduceInterface(typeof(INotifyOnChange), OverrideAction = InterfaceOverrideAction.Ignore, AncestorOverrideAction = InterfaceOverrideAction.Ignore)]
[MulticastAttributeUsage(MulticastTargets.Class, Inheritance = MulticastInheritance.Strict, AllowMultiple = false)]
public sealed class NotifyPropertiesOnChange : InstanceLevelAspect, INotifyOnChange
{
[IntroduceMember(Visibility = Visibility.Family, IsVirtual = true, OverrideAction = MemberOverrideAction.Ignore)]
public void OnPropertyChanged(string propertyName)
=> PropertyChanged?.Invoke(Instance, new PropertyChangedEventArgs(propertyName));
[IntroduceMember(OverrideAction = MemberOverrideAction.Ignore)]
public event PropertyChangedEventHandler PropertyChanged;
[OnLocationSetValueAdvice, MulticastPointcut(Targets = MulticastTargets.Property, Attributes = MulticastAttributes.Public | MulticastAttributes.Instance)]
public void OnSetValue(LocationInterceptionArgs args)
{
if (args.Value == args.GetCurrentValue())
return;
args.ProceedSetValue();
var notifyOnChange = args.Instance as INotifyOnChange;
notifyOnChange?.OnPropertyChanged(args.Location.PropertyInfo.Name);
}
}
I had also tested with Inheritance = MulticastInheritance.Multicast without success.
However if I have a base class like the one here below it works
[NotifyOnChange]
public class EuroRate
{
public string Currency { get; set; }
public decimal Rate { get; set; }
public DateTime Date { get; set; }
}
but if try on a derived class (removing the aspect from the base class of course) it don't works
public class EuroRate
{
public string Currency { get; set; }
public decimal Rate { get; set; }
public DateTime Date { get; set; }
}
[NotifyPropertiesOnChange]
public class RateModel : EuroRate
{
}

Answer 1

An aspect can only alter the declaration on which it is applied. In case of your aspect (TypeLevelAspect) this means that when applied on RateModel class it can only apply advices on properties declared directly by this class. Properties declared by the base will not be transformed (as you would need to transform the base itself).
In this case, the best option is to rely on the multicast inheritance itself, i.e. apply the aspect on the base class. This would mean that you need to work with the fact that the aspect is applied separately on each class and develop a mechanism for communication between these aspects.
Performance concerns
You might have noticed that this would cause multiple instances of the aspect to exist for a single instance of the target class (depending on levels of inheritance).
You can optimize this by using combination of an instance-level aspect that introduces the OnPropertyChanged method, the event and the interface. This aspect would not be applied directly but through IAspectProvider by the main aspect that would be mere TypeLevelAspect.
Ad your Multicast Inheritance note (see the documentation):
For TypeLevelAspect applied on type [MulticastInheritance.Strict] and [MulticastInheritance.Multicast] are essentially the same.
The reason is that multicast inheritance also takes into account the declaration on which it was multicasted (inherits the multicast itself); i.e. if you apply method level aspect on a type, multicast inheritance will cause derived classes to inherit the aspect for all of its methods.
On the other the strict inheritance will cause only the applied aspect to be inherited, i.e. only overriding methods will have the aspect.