片鱗懐古のブログ: wpf : Bindingソースのパスをリファクターできるようにするためのコード

xamlではなく、C#のコードでのお話です。以前の投稿でINotifyPropertyChangedでの通知対象のプロパティ名をリファクターできるようにするためのコードを書きました。今回はそれを元に、Bindingするときのプロパティ名をリファクターできるようにしました。

考えるキッカケになったのはこんなコード。

public static Binding CreateBinding(object source, string path, IValueConverter converter = null, BindingMode mode = BindingMode.OneWay)
{
    var binding = new Binding();
    binding.Source = source;
    binding.Path = new PropertyPath(path);
    binding.Converter = converter;
    binding.Mode = mode;
    return binding;
}

C#のコード上でBindingをいくつか作ることになったので書きました。このコードのpathの部分が問題です。 pathは文字列なのでVisualStudioのリファクターの対象にはなりません。バインディングソースが自作クラスなら、プロパティ名を変更したときに変更もれがあってバグになってしまう可能性があります。

以前のコードを応用してリファクターが効くようにするとこうなります。 (IValueConverterとかBindingModeとかはネタに関係ないので省略。)

public static Binding CreateBinding<T>(object source, Expression<Func<T>> e)
{
    var member = e.Body as MemberExpression;
    var binding = new Binding();
    binding.Source = source;
    binding.Path = new PropertyPath(member.Member.Name);
    return binding;
}

使う側のコードは、

CreateBinding(instance, () => instance.Property);

こうすれば、リファクターを使ってプロパティ名を変えれば変更もれでバグになることはありません(xamlを除く)。短いコードで済むし、お勧めです。

しかし、ちょっと気になるところもあります。引数にinstanceが2回出てくるのがスッキリしません。「なんとかできないもんかなぁ」ってことでデバッガの表示を眺めながら適当に試行錯誤してたら、なんかできました。こんなふうになりました。

public static Binding CreateBinding<T>(Expression<Func<T>> e)
{
    var member = e.Body as MemberExpression;
    var propertyName = member.Member.Name;

    object instance = null;

    // ラムダ式の形が () => this.Property の場合のthisにあたるインスタンスを得る処理
    if (member.Expression.NodeType == ExpressionType.Constant)
    {
        var constant = member.Expression as ConstantExpression;
        instance = constant.Value;
    }
    else 
    {
        member = member.Expression as MemberExpression;
        var fieldName = member.Member.Name;
        object instanceOwner = null;
        Type instanceOwnerType;
        BindingFlags flag;

        // class.instanceというフィールド or プロパティがある場合について、
        // ラムダ式の形が () => instance.Property からインスタンスを得る処理。
        // instanceがローカル変数の場合もコレ。
        if (member.Expression != null)
        {
            var constant = member.Expression as ConstantExpression;
            instanceOwner = constant.Value;
            instanceOwnerType = instanceOwner.GetType();
            flag = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
        }
        // Class.staticInstanceという静的フィールド or プロパティがある場合について、
        // ラムダ式の形が () => staticInstance.Property からstaticInstanceにあたるインスタンスを得る処理。
        else
        {
            instanceOwnerType = member.Member.DeclaringType;
            flag = BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
        }

        var memberInfo = instanceOwnerType.GetMember(fieldName, flag)[0];
        if (memberInfo is FieldInfo)
        {
            instance = ((FieldInfo)memberInfo).GetValue(instanceOwner);
        }
        else // PropertyInfo
        {
            instance = ((PropertyInfo)memberInfo).GetValue(instanceOwner);
        }
    }

    var b = new Binding();
    b.Source = instance;
    b.Path = new PropertyPath(propertyName);

    return b;
}

「 () => instance.Property という形のラムダ式を解釈してinstanceの部分とProperty名を取り出そう」ってのが趣旨なんですが、instanceを格納した変数の種類がthisとかstaticとか「プロパティかフィールドか?」とかで場合分けするハメになってこの長さに。コード上の見た目は同じようでもinstanceを格納した変数の宣言のされかたで色々違うんですね。軽いネタのつもりだったのに疲れました。自分の使いそうなコードは書いたけど、多分網羅はしてないんだろうな...

Expressionを使った時点で重そうな気配はしてるんですが、実際どうなんでしょうね? リファクタリングでより重くなってますし... 例えば、ListViewに数千項目のListViewItemを登録するときとか、重くて使い物にならなかったりして?

そいういうときはExpression自体使わずに普通に文字列でプロパティ名を指定するしかないんでしょうねぇ。そういうときでもExpressionでプロパティ名を得るこのTipsは、Debug.Assertとかに仕込めば使えるっていえば使えるのかな? 例えばINotifyPropertyChangedでの例ですが、こんなふうに使えば名前の変換し忘れがあったらアサーションに失敗します。

private double _value3;
public double Value3
{
    get { return _value3; }
    set
    {
        if (_value3 != value)
        {
            _value3 = value;

            var propertyName = "Value2";
#if PROPERTY_NAME_ASSERTION
            Debug.Assert(propertyName == GetPropertyName(()=>this.Value3));
#endif
            NotifyPropertyChanged(propertyName);
        }
    }
}

性能テストをするときだけPROPERTY_NAME_ASSERTIONを無効にするとか、そういうやり方なら少なくともExpressionのせいで性能問題にはなりません。

オマケです。添付プロパティのBindingを作る場合について、そのときはExpressionとかは要りません。

public static Binding CreateBinding(object source, DependencyProperty dp)
{
    var b = new Binding();
    b.Source = source;
    b.Path = new PropertyPath("(" + dp.OwnerType.Name + '.' + dp.Name + ')');

    return b;
}

既存の添付プロパティの場合はこれだけでいいんですが、自作する場合は登録する部分でプロパティ名の文字列が必要になります。そんなときはコレ。

public static readonly DependencyProperty IsUselessProperty = DependencyProperty.Register(
        GetDependencyPropertyName(() => IsUselessProperty),
        typeof(Boolean),
        typeof(MainWindow),
        null
);

public static string GetDependencyPropertyName(Expression<Func<DependencyProperty>> e)
{
    var member = e.Body as MemberExpression;
    var propertyName = member.Member.Name;
    Debug.Assert(propertyName.EndsWith("Property"));
    return propertyName.Remove(propertyName.Length - "Property".Length);
}

一応、動作確認用のコードを載せておきます。コントロールをタイマー&バインディングで動かす簡単なサンプルです。 MainWindow.xamlです。

<Window x:Class="BindingRefactorSample.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="300" Width="300">
    <DockPanel>
        <Slider DockPanel.Dock="Top" Name="slider" Minimum="0" Maximum="100" />
        <Canvas>
            <Border Name="border" Background="Blue"/>
        </Canvas>
    </DockPanel>
</Window>

MainWindow.xaml.csです。

using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Linq.Expressions;
using System.Reflection;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Threading;

namespace BindingRefactorSample
{
    public partial class MainWindow : Window, INotifyPropertyChanged
    {
        private DispatcherTimer _timer;

        private Data _data1;
        //private Data _data1 { get; set; }
        private static Data _data2;
        //private static Data _data2 { get; set; }

        public MainWindow()
        {
            InitializeComponent();

            _data1 = new Data();
            _data2 = new Data();

            slider.SetBinding(Slider.ValueProperty, CreateBinding(() => Value1));
            border.SetBinding(Canvas.LeftProperty, CreateBinding(() => _data1.Value2));
            border.SetBinding(Border.HeightProperty, CreateBinding(border, Canvas.LeftProperty));
            border.SetBinding(Border.WidthProperty, CreateBinding(() => _data2.Value2));

            // 一応、ローカル変数をCreateBindingに渡したときも動くことをデバッガで確認。
            var d = new Data();
            CreateBinding(() => d.Value2);

            _timer = new DispatcherTimer();
            _timer.Interval = TimeSpan.FromSeconds(0.1);
            _timer.Tick += TimerTickEventHandler;
            _timer.Start();
        }

        void TimerTickEventHandler(object sender, EventArgs e)
        {
            Value1 += 1.0;
            if (100.0 <= Value1)
                Value1 = 0.0;

            _data1.Value2 = 100.0 - Value1;
            _data2.Value2 = Value1 * 2.0;
        }

        private double _value1;
        public double Value1
        {
            get { return _value1; }
            set
            {
                if (_value1 != value)
                {
                    _value1 = value;
                    NotifyPropertyChanged(() => this.Value1);
                }
            }
        }

        // 引数eは () => instance.Property という形式で書くこと。
        // その式の形が重要なので「プログラムを走らせたら同じ結果になるから」と
        // 書き方を変えるのはダメ。
        public static Binding CreateBinding<T>(Expression<Func<T>> e)
        {
            var member = e.Body as MemberExpression;
            var propertyName = member.Member.Name;

            object instance = null;

            // ラムダ式の形が () => this.Property の場合のthisにあたるインスタンスを得る処理
            if (member.Expression.NodeType == ExpressionType.Constant)
            {
                var constant = member.Expression as ConstantExpression;
                instance = constant.Value;
            }
            else 
            {
                member = member.Expression as MemberExpression;
                var fieldName = member.Member.Name;
                object instanceOwner = null;
                Type instanceOwnerType;
                BindingFlags flag;

                // class.instanceというフィールド or プロパティがある場合について、
                // ラムダ式の形が () => instance.Property からインスタンスを得る処理。
                // instanceがローカル変数の場合もコレ。
                if (member.Expression != null)
                {
                    var constant = member.Expression as ConstantExpression;
                    instanceOwner = constant.Value;
                    instanceOwnerType = instanceOwner.GetType();
                    flag = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
                }
                // Class.staticInstanceという静的フィールド or プロパティがある場合について、
                // ラムダ式の形が () => staticInstance.Property からstaticInstanceにあたるインスタンスを得る処理。
                else
                {
                    instanceOwnerType = member.Member.DeclaringType;
                    flag = BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
                }

                var memberInfo = instanceOwnerType.GetMember(fieldName, flag)[0];
                if (memberInfo is FieldInfo)
                {
                    instance = ((FieldInfo)memberInfo).GetValue(instanceOwner);
                }
                else // PropertyInfo
                {
                    instance = ((PropertyInfo)memberInfo).GetValue(instanceOwner);
                }
            }

            var b = new Binding();
            b.Source = instance;
            b.Path = new PropertyPath(propertyName);
            b.Mode = BindingMode.OneWay;

            return b;
        }

        public static Binding CreateBinding(object source, DependencyProperty dp)
        {
            var b = new Binding();
            b.Source = source;
            b.Path = new PropertyPath("(" + dp.OwnerType.Name + '.' + dp.Name + ')');
            b.Mode = BindingMode.OneWay;

            return b;
        }

        public event PropertyChangedEventHandler PropertyChanged;

        protected virtual void NotifyPropertyChanged<T>(Expression<Func<T>> e)
        {
            if (this.PropertyChanged != null)
            {
                var member = e.Body as MemberExpression;
                this.PropertyChanged(this, new PropertyChangedEventArgs(member.Member.Name));
            }
        }
    }
}

MainWindow自体にValue1プロパティを作ってそれに関するラムダ式を書いた場合のチェックと、DataクラスにValue2プロパティを作ってそれに関するラムダ式を書いた場合のチェックをします。あとは、プロパティの場合/フィールドの場合と静的メンバーの場合/インスタンスメンバーの場合のチェックがあります。

Data.csはこちら。

using System;
using System.ComponentModel;
using System.Linq.Expressions;

namespace BindingRefactorSample
{
    public class Data : INotifyPropertyChanged
    {
        private double _value2;
        public double Value2
        {
            get { return _value2; }
            set
            {
                if (_value2 != value)
                {
                    _value2 = value;
                    NotifyPropertyChanged(() => this.Value2);
                }
            }
        }

        public event PropertyChangedEventHandler PropertyChanged;

        protected virtual void NotifyPropertyChanged<T>(Expression<Func<T>> e)
        {
            if (this.PropertyChanged != null)
            {
                var member = e.Body as MemberExpression;
                this.PropertyChanged(this, new PropertyChangedEventArgs(member.Member.Name));
            }
        }
    }
}

片鱗懐古のブログ

2014年5月14日水曜日

wpf : Bindingソースのパスをリファクターできるようにするためのコード

閲覧数が多い投稿

ラベル

広告

投稿した動画

ブログアーカイブ