INotifyPropertyChangedの実装をなるべく簡略化したい

Question

前提・実現したいこと

INotifyPropertyChangedの実装をなるべく短く書きたい(速度は度外視で)ので
次のようなViewModelBaseクラスを作成しました。

public abstract class ViewModelBase : INotifyPropertyChanged
{

    public event PropertyChangedEventHandler PropertyChanged;

    protected virtual void RaisePropertyChanged(string propertyName)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }

    protected virtual void RaisePropertyChanged(params string[] propertyNames)
    {
        foreach (var propertyName in propertyNames) RaisePropertyChanged(propertyName);
    }

    private Dictionary<string, object> PropertyDictionary = new Dictionary<string, object>();

    protected virtual void Setter(object value, [System.Runtime.CompilerServices.CallerMemberName] string PropertyName = "")
    {
        if (PropertyDictionary.ContainsKey(PropertyName))
        {
            if (PropertyDictionary[PropertyName] == value) return;
            PropertyDictionary[PropertyName] = value;
        }
        else
        {
            PropertyDictionary.Add(PropertyName, value);
        }
        RaisePropertyChanged(PropertyName);
    }

    protected virtual object Getter(string PropertyName)
    {
        return PropertyDictionary.TryGet(PropertyName);
    }

    protected virtual T Getter<T>([System.Runtime.CompilerServices.CallerMemberName] string PropertyName = "")
    {
        var ret = Getter(PropertyName);
        if (ret == null) return default(T);
        return (T)ret;
    }
}

文字数制限で省略(編集履歴参照)

プロパティ名をCallerMemberNameでもらって、Dictionary<string, object>にすべての値を入れる方式です。
取得と設定にはGetterとSetterを使用して、次のような書き方が出来ます。

public class Sample : ViewModelBase
{
    public bool IsExpanded { get => Getter<bool>(); set => Setter(value); }
    public bool? IsChecked { get => Getter<bool?>(); set => Setter(value); }
    public string Text { get => Getter<string>(); set => Setter(value); }
    public object Data { get => Getter<object>(); set => Setter(value); }
    public Sample Parent { get => Getter<Sample>(); set => Setter(value); }
    public ObservableCollection<Sample> Children { get => Getter<ObservableCollection<Sample>>(); set => Setter(value); }
}

###質問
基本的に使用する際は

public 型 名前 { get => Getter<型>(); set => Setter(value); }

これだけ書けばよいので短くて気に入っています。
ただ、同じ型名を2度書かないといけないため、ObservableCollectionだったりすると
かなり長くなってしまうのが気に入らないので、何か別の方法で、さらに短くできないかという質問です。
具体的には2度書いている型を1度にできないのか？returnでの型推論は効かせる方法はないのか？です。

###追記：仮想プロパティをオーバーライドするクラス動的生成

Zuishinさんの提案を参考に下記のように書き換えました。

public abstract class ViewModelBase : INotifyPropertyChanged
{

    public event PropertyChangedEventHandler PropertyChanged;

    protected virtual void RaisePropertyChanged(string propertyName)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }

    //ref:https://qiita.com/Zuishin/items/0b7080e6f7e277d9394b
    //ref:http://www.gutgames.com/post/Overridding-a-Property-With-ReflectionEmit.aspx
    private static Dictionary<Type, Type> typeDictionary = new Dictionary<Type, Type>();
    public static T Create<T>(params object[] parameters) where T : ViewModelBase
    {
        if (!typeDictionary.TryGetValue(typeof(T), out Type type))
        {
            var name = "ViewModel_" + Guid.NewGuid().ToString("N");
            var assemblyName = new AssemblyName(name);
            var assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(
                assemblyName,
                AssemblyBuilderAccess.RunAndCollect);
            var moduleBuilder = assemblyBuilder.DefineDynamicModule(name);
            var typeBuilder = moduleBuilder.DefineType(name, TypeAttributes.Public | TypeAttributes.Class, typeof(T));
            //プロパティはvirtualではなくアクセサがvirtualになる。
            var virtualProperties = typeof(T).GetProperties().Where(p => p.GetAccessors().Any(a => a.IsVirtual));
            foreach (var property in virtualProperties)
            {
                /* 
                    * プロパティのオーバーライドするときは、Getter/Setterだけオーバーライドしないといけないらしい
                    * DefinePropertyでプロパティまで作ってしまうと、新クラスとベースクラスに二つのプロパティが生まれて
                    * 正しく動作しなくなってしまった 
                    */

                //新しいプロパティ
                //var propertyBuilder = typeBuilder.DefineProperty(
                //    property.Name,
                //    PropertyAttributes.None,
                //    property.PropertyType,
                //    new Type[] { property.PropertyType }
                //    );
                //フィールド
                //バッキングフィールドは直接触れなかった
                //var field = typeof(T).GetField($"<{property.Name}>k__BackingField", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
                //なので新しいフィールド作成
                var field = typeBuilder.DefineField($"field_{property.PropertyType}", property.PropertyType, FieldAttributes.Private);

                var accessorAttr = MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig | MethodAttributes.Virtual;

                //Getter
                var getMethod = typeBuilder.DefineMethod($"get_{property.Name}", accessorAttr, property.PropertyType, Type.EmptyTypes);
                var getIL = getMethod.GetILGenerator();
                getIL.Emit(OpCodes.Ldarg_0);
                getIL.Emit(OpCodes.Ldfld, field);
                getIL.Emit(OpCodes.Ret);

                //propertyBuilder.SetGetMethod(getMethod);

                //Setter
                var setMethod = typeBuilder.DefineMethod($"set_{property.Name}", accessorAttr, null, new Type[] { property.PropertyType });
                var setIL = setMethod.GetILGenerator();
                setIL.Emit(OpCodes.Ldarg_0);
                setIL.Emit(OpCodes.Ldarg_1);
                setIL.Emit(OpCodes.Stfld, field);
                setIL.Emit(OpCodes.Ldarg_0);
                setIL.Emit(OpCodes.Ldstr, property.Name);
                var meth = typeof(T).GetMethod("RaisePropertyChanged", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public, Type.DefaultBinder, new Type[] { typeof(string) }, null);
                setIL.Emit(OpCodes.Callvirt, meth);
                setIL.Emit(OpCodes.Ret);

                //propertyBuilder.SetSetMethod(setMethod);
            }
            type = typeBuilder.CreateType();
            typeDictionary[typeof(T)] = type;
        }
        return (T)Activator.CreateInstance(type, parameters);
    }
}

public class CheckTreeSource : ViewModelBase
{
    public virtual bool IsExpanded { get; set; }
    public virtual bool? IsChecked { get; set; }
    public virtual string Text { get; set; }
    public virtual object Data { get; set; }
    public virtual CheckTreeSource Parent { get; set; }
    public virtual ObservableCollection<CheckTreeSource> Children { get; set; }
}

使用方法は

var item = ViewModelBase.Create<CheckTreeSource>();

動作確認に使用したコードは

<Window x:Class="ViewModelSample.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:ViewModelSample"
        mc:Ignorable="d"
        Title="MainWindow" Height="450" Width="800">
    <DockPanel>
        <Button DockPanel.Dock="Top" Content="CheckAllItems" Click="Button_Click"/>
        <TreeView Name="CheckTreeView">
            <TreeView.Resources>
                <Style TargetType="TreeViewItem">
                    <Setter Property="IsExpanded" Value="{Binding Path=IsExpanded,Mode=TwoWay}"/>
                </Style>
            </TreeView.Resources>
            <TreeView.ItemTemplate>
                <HierarchicalDataTemplate DataType="local:CheckTreeSource" ItemsSource="{Binding Children}">
                    <CheckBox Margin="1" IsChecked="{Binding IsChecked}">
                        <TextBlock Text="{Binding Text}"/>
                    </CheckBox>
                </HierarchicalDataTemplate>
            </TreeView.ItemTemplate>
        </TreeView>
    </DockPanel>
</Window>

public partial class MainWindow : Window
{
    private ObservableCollection<CheckTreeSource> checkItems = new ObservableCollection<CheckTreeSource>();
    public MainWindow()
    {
        InitializeComponent();
        var random = new Random();

            
        foreach (var i in Enumerable.Range(0, 20))
        {
            var item = ViewModelBase.Create<CheckTreeSource>();
            item.Text = $"Parent{i}";
            item.IsChecked = random.Next(2) == 0;
            item.IsExpanded = true;
            checkItems.Add(item);
        }

        foreach (var item in checkItems)
        {
            item.Children = new ObservableCollection<CheckTreeSource>();
            foreach (var i in Enumerable.Range(0, 3))
            {
                var childitem = ViewModelBase.Create<CheckTreeSource>();
                childitem.Parent = item;
                childitem.Text = $"Child{i}";
                childitem.IsChecked = item.IsChecked;
                item.Children.Add(childitem);
            }
        }

        CheckTreeView.ItemsSource = checkItems;
    }

    private void Button_Click(object sender, RoutedEventArgs e)
    {
        foreach(var item in checkItems)
        {
            item.IsChecked = true;
            foreach(var childitem in item.Children)
            {
                childitem.IsChecked = true;
            }
        }
    }
}

初めてILに触ったのでとても勉強になりました。
プロパティのオーバーライドもgetter/setterだけオーバーライドでいいと思わず、新発見でした。
値を入れてたDictionaryも無くなってとってもいい感じです。

Answer 1

まだありません。
しかし実装される可能性はあります。

[雑記] 型推論の是非

対案: 左辺から右辺の型推論

この通り、C#では、ローカル変数以外のvarによる型推論は、おそらくずっと認められることはないでしょう。 代わりと言ってはなんですが、「逆向きの型推論」が入る可能性はあります。 すなわち、以下のような書き方です。

中略

この構文は、早ければC# 8あたり(2017～2018年頃？)で入りそうです。

Comments

[sh_akira]

ありがとうございます。
returnの型は決まっているので、その型でジェネリックメソッドを呼び出すというのは、
逆向きの型推論になるというわけですね。
余り多用したくない構文な気がしますが、今回の場合やリンク先の例の時のような分かりやすい場合は
使えると嬉しそうです。

[Zuishin]

https://qiita.com/Zuishin/items/0b7080e6f7e277d9394b で「C# で無駄に難しくメモ化をしてみた」という記事を書きましたが、これは結局どうやっているかというとユーザーが作ったクラス(この質問の場合だと ViewModelBase)を継承した新しいクラスを動的に作成してメソッドをオーバーライドしています。
サブクラスはポリモーフィズムでスーパークラスと同じように働きますからインスタンスを作成してしまえば継承したことなど忘れて使うことができます。

同様に仮想プロパティを継承して INotifyPropertyChanged を自動的に実装するような仕組みを作れば最も簡単にできるかもしれませんね。
IL を組むのが面倒なので今は作りませんが後日暇だったらやるかもしれません。

[sh_akira]

その記事は以前読ませていただいてました。
確かに仮想プロパティを探して、INotifyPropertyChangedを自動で実装できれば短くできますね。
ちょっとやってみます。

[sh_akira]

やってみました。質問に追記しています。初めてIL触ってみましたが、動いているようです。
ViewModelBaseを継承して、プロパティにvirtualを付ければ、
ViewModelBase.Create<Sample>();とするだけで、自動でINotifyPropertyChangedのイベントが
各プロパティに実装されてオーバーライドできるようになりました。
プロパティ自体はオーバーライドせずにアクセサだけで良かったりと色々と発見があり、楽しかったです。
質問文の文字数制限でお礼まで入りませんでした。ありがとうございました。

[Zuishin]

おお、早かったですね。素晴らしい！

[Zuishin]

触発されて私も書いてみました。https://qiita.com/Zuishin/items/3f1e2997d72c56da23d1
CodeDom だとちょっと遅いですね。IL の方が軽いです。

Answer 2

INotifyPropertyChangedを書きたくないなら、ReactivePropertyを使えばいいじゃない。
https://qiita.com/YSRKEN/items/5a36fb8071104a989fb8

Comments

[Zuishin]

ReactiveProperty を使ってもINotifyPropertyChanged を書く必要があります。そうしないとメモリリークするからです。http://mobile.aridai.net/article/?p=15

[sh_akira]

普通に使うときはReactivePropertyでいいと思います。というより私も使ってます。
今回はどちらかというとこれ以上短く書けないのかという技術的興味です。

Answer 3

具体的には2度書いている型を1度にできないのか？

できますが、型名の代わりに型の値が引数に必要です。
例えば以下のようなメソッドをViewModelBaseに追加します。

/// <summary>
/// 現在のプロパティ値を取得
/// </summary>
/// <param name="initialValue">初期値</param>
protected T Getter<T>(T initialValue, [CallerMemberName]string propertyName = null)
{
    //キーに値が無かったら初期値を現在値に入力
    if (!PropertyDictionary.ContainsKey(propertyName))
        PropertyDictionary[propertyName] = initialValue;

    //Dictionaryから現在値を取得してプロパティの型に変換する
    return Getter<T>(propertyName);
}

使用する際はSampleクラスで

public bool IsExpanded { get => Getter(false); set => Setter(value); }

といった形になります。
注意点として、Getterよりも先にSetterを呼ぶと初期値が使用されなくなります。

Comments

[Zuishin]

私もそのような実装をしたことがありますが、初期値が null の場合が多くて使い物になりませんでした。
Setter を先に読んだ場合に初期値が使用されなくなるのはいいのですが、私の場合は IEditable も実装していたために初期値が BeginEdit() でバックアップされなくてはまりました。

[soi013]

> BeginEdit() でバックアップされなくて

IEditableは使用したことがないですが、初期化のタイミングによって問題が発生しそうですね。

> 初期値が null の場合が多くて

組み込み型以外では使いにくいかもしれませんね

[sh_akira]

確かに値から推論させれば型は1度で済みますが、nullを入れたい場面が多いですね。
new ObservableCollection<Sample>()とかだと余計長くなっちゃいます。
これは使うときに結局書くのでソース全体の文字数では少なくなりますが。。