As a WPF Developer, Fody has been an extremely vital component in my aresenal. It takes a lot of burden off me by injecting some of the boiler plate codes. Despite that, there is one unusually behavior of Fody, which I have difficulty in digesting.
For demonstration, let us create an example View for ourselves. For the sake of example here, am relying on Caliburn Micro for my MVVM.
<StackPanel>
<TextBlock Text="{Binding RandomNumber}" FontSize="16" HorizontalAlignment="Center"/>
<Button Content="Randomize" x:Name="Randomize"/>
</StackPanel>
The ViewModel, at the moment, looks like the following.
public class ShellViewModel:Screen
{
private Random _random;
public ShellViewModel()
{
_random = new Random();
}
public long RandomNumber { get; set; }
public void Randomize()
{
RandomNumber = _random.Next();
}
}
This works perfectly fine. If you examine the code via ILSpy, you could notice that Fody has injected the code correctly as one would expect.
public class ShellViewModel : Screen
{
private Random _random;
public long RandomNumber
{
[CompilerGenerated]
get
{
return <RandomNumber>k__BackingField;
}
[CompilerGenerated]
set
{
if (<RandomNumber>k__BackingField != value)
{
<RandomNumber>k__BackingField = value;
OnPropertyChanged(<>PropertyChangedEventArgs.RandomNumber);
}
}
}
public ShellViewModel()
{
_random = new Random();
}
public void Randomize()
{
RandomNumber = _random.Next();
}
}
The OnPropertyChanged call here points to the PropertyChangedBase.OnPropertyChanged method of Caliburn Micro (PropertyChangedBase implements INotifyPropertyChanged in Caliburn Micro)
protected void OnPropertyChanged(PropertyChangedEventArgs e)
{
this.PropertyChanged?.Invoke(this, e);
}
Let us add some more code to our ViewModel and see how Fody behaves. Assume that we need to do some special handling when the Property Changed event is triggered in our ViewModel. So we will go ahead and subscribe in our constructor.
public ShellViewModel()
{
_random = new Random();
PropertyChanged += HandlePropertyChanged;
}
private void HandlePropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
{
// Do something here
}
Fody, quite expectedly, handles the change gracefully.
public class ShellViewModel : Screen
{
private Random _random;
public long RandomNumber
{
[CompilerGenerated]
get
{
return <RandomNumber>k__BackingField;
}
[CompilerGenerated]
set
{
if (<RandomNumber>k__BackingField != value)
{
<RandomNumber>k__BackingField = value;
OnPropertyChanged(<>PropertyChangedEventArgs.RandomNumber);
}
}
}
public ShellViewModel()
{
_random = new Random();
PropertyChanged += HandlePropertyChanged;
}
private void HandlePropertyChanged(object sender, PropertyChangedEventArgs e)
{
}
public void Randomize()
{
RandomNumber = _random.Next();
}
}
So far, so good. This is exactly like one would expect. The injected code still calls the INotifyPropertyChanged implementation(in our base class).
set
{
if (<RandomNumber>k__BackingField != value)
{
<RandomNumber>k__BackingField = value;
OnPropertyChanged(<>PropertyChangedEventArgs.RandomNumber);
}
}
But this is also where things start to behave strangely (one could counter argue this, but i still feel the following behavior is strange). Let us rename our PropertyChanged event handler as HandlePropertyChanged.
public ShellViewModel()
{
_random = new Random();
PropertyChanged += OnPropertyChanged;
}
private void OnPropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
{
// Do something here
}
Let us examine the code generated by Fody now.
public long RandomNumber
{
[CompilerGenerated]
get
{
return <RandomNumber>k__BackingField;
}
[CompilerGenerated]
set
{
if (<RandomNumber>k__BackingField != value)
{
<RandomNumber>k__BackingField = value;
OnPropertyChanged(this, <>PropertyChangedEventArgs.RandomNumber);
}
}
}
public ShellViewModel()
{
_random = new Random();
PropertyChanged += OnPropertyChanged;
}
private void OnPropertyChanged(object sender, PropertyChangedEventArgs e)
{
}
The code injected by Fody has changed now and instead of calling the implementation of INotifyPropertyChanged, it is invoking the Event Handler of PropertyChanged.
set
{
if (<RandomNumber>k__BackingField != value)
{
<RandomNumber>k__BackingField = value;
OnPropertyChanged(this, <>PropertyChangedEventArgs.RandomNumber);
}
}
In a way, if one was to think about it, it is a good behavior. Fody, on sensing that we have subscribing to PropertyChanged handler, ensure we are calling the handler instead. But, then the behavior should have been same when the Handler name was HandlePropertyChanged.
The strange part, which am not comfortable with this, is that this call to Handler occurs only when the Handler is named OnPropertyChanged. In every other case the injected code points to the implementation of INotifyPropertyChanged. I would like to call this a bug – You could expect the behavior to be consistent.
One of the troubles with this behavior (other than the obvious inconsistency) is that is extremely hard to trace this issue (remember – Fody injects the code) unless one is aware of this strange naming convention followed by Fody. I hope Fody does something to correct, if not make the make the behavior more consistent.
ByteLanguage.Net 