[Silverlight入门系列]多重绑定MultiBinding有必要吗？

WPF里面是有多重绑定的，Silverlight里面没有，而且Silverlight5也不会有（SL5功能列表），网上有手工实现Silverlight多重绑定（MultiBinding）的，基本上源头是这篇文章。里面实现Silverlight多重绑定（MultiBinding）的基本是这么几个类：

IMultiValueConverter:

using System;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;
using System.Globalization;

namespace SLMultiBinding
{
  /// <summary>
  /// see: http://msdn.microsoft.com/en-us/library/system.windows.data.imultivalueconverter.aspx
  /// </summary>
  public interface IMultiValueConverter
  {
      object Convert(object[] values, Type targetType, object parameter, CultureInfo culture);

      object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture);

  }
}

示例TitleConverter：

using System;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;

namespace SLMultiBinding
{
  public class TitleConverter : IMultiValueConverter
  {
    #region IMultiValueConverter Members

    public object Convert(object[] values, Type targetType,
      object parameter, System.Globalization.CultureInfo culture)
    {
      string forename = values[0] as string;
      string surname = values[1] as string;

      return string.Format("{0}, {1}", surname, forename);
    }

    public object[] ConvertBack(object value, Type[] targetTypes,
      object parameter, System.Globalization.CultureInfo culture)
    {
      throw new NotImplementedException();
    }

    #endregion
  }
}

BindingUtil.cs:

using System;
using System.Net;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;
using System.Windows.Data;
using System.ComponentModel;
using System.Reflection;

namespace SLMultiBinding
{
  /// <summary>
  /// Provides a mechanism for attaching a MultiBinding to an element
  /// </summary>
  public class BindingUtil
  {
    #region DataContextPiggyBack attached property

    /// <summary>
    /// DataContextPiggyBack Attached Dependency Property, used as a mechanism for exposing
    /// DataContext changed events
    /// </summary>
    public static readonly DependencyProperty DataContextPiggyBackProperty =
        DependencyProperty.RegisterAttached("DataContextPiggyBack", typeof(object), typeof(BindingUtil),
            new PropertyMetadata(null, new PropertyChangedCallback(OnDataContextPiggyBackChanged)));

    public static object GetDataContextPiggyBack(DependencyObject d)
    {
      return (object)d.GetValue(DataContextPiggyBackProperty);
    }

    public static void SetDataContextPiggyBack(DependencyObject d, object value)
    {
      d.SetValue(DataContextPiggyBackProperty, value);
    }

    /// <summary>
    /// Handles changes to the DataContextPiggyBack property.
    /// </summary>
    private static void OnDataContextPiggyBackChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
      FrameworkElement targetElement = d as FrameworkElement;

      // whenever the targeElement DataContext is changed, copy the updated property
      // value to our MultiBinding.
      MultiBinding relay = GetMultiBinding(targetElement);
      relay.DataContext = targetElement.DataContext;
    }

    #endregion

    #region MultiBinding attached property

    public static MultiBinding GetMultiBinding(DependencyObject obj)
    {
      return (MultiBinding)obj.GetValue(MultiBindingProperty);
    }

    public static void SetMultiBinding(DependencyObject obj, MultiBinding value)
    {
      obj.SetValue(MultiBindingProperty, value);
    }

    public static readonly DependencyProperty MultiBindingProperty =
        DependencyProperty.RegisterAttached("MultiBinding",
        typeof(MultiBinding), typeof(BindingUtil), new PropertyMetadata(null, OnMultiBindingChanged));

    private static readonly BindingFlags dpFlags = BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy;

    /// <summary>
    /// Invoked when the MultiBinding property is set on a framework element
    /// </summary>
    private static void OnMultiBindingChanged(DependencyObject depObj,
      DependencyPropertyChangedEventArgs e)
    {
      FrameworkElement targetElement = depObj as FrameworkElement;

      // bind the target elements DataContext, to our DataContextPiggyBack property
      // this allows us to get property changed events when the targetElement
      // DataContext changes
      targetElement.SetBinding(BindingUtil.DataContextPiggyBackProperty, new Binding());

      MultiBinding relay = GetMultiBinding(targetElement);
      relay.Initialise();

      // find the target dependency property
      FieldInfo[] sourceFields = targetElement.GetType().GetFields(dpFlags);
      FieldInfo targetDependencyPropertyField =
          sourceFields.First(i => i.Name == relay.TargetProperty + "Property");
      DependencyProperty targetDependencyProperty =
          targetDependencyPropertyField.GetValue(null) as DependencyProperty;

      // bind the ConvertedValue of our MultiBinding instance to the target property
      // of our targetElement
      Binding binding = new Binding("ConvertedValue");
      binding.Source = relay;
      targetElement.SetBinding(targetDependencyProperty, binding);
    }

    #endregion

  }
}

MultiBinding.cs

using System;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;
using System.Windows.Data;
using System.Collections.ObjectModel;
using System.Windows.Markup;
using System.ComponentModel;
using System.Collections.Generic;
using System.Globalization;

namespace SLMultiBinding
{
  /// <summary>
  /// Allows multiple bindings to a single property.
  /// </summary>
  [ContentProperty("Bindings")]
  public class MultiBinding : Panel, INotifyPropertyChanged
  {

    #region ConvertedValue dependency property

    public static readonly DependencyProperty ConvertedValueProperty =
        DependencyProperty.Register("ConvertedValue", typeof(object), typeof(MultiBinding),
            new PropertyMetadata(null, OnConvertedValue));

    /// <summary>
    /// This dependency property is set to the resulting output of the
    /// associated Converter.
    /// </summary>
    public object ConvertedValue
    {
      get { return (object)GetValue(ConvertedValueProperty); }
      set { SetValue(ConvertedValueProperty, value); }
    }

    private static void OnConvertedValue(DependencyObject depObj, DependencyPropertyChangedEventArgs e)
    {
      MultiBinding relay = depObj as MultiBinding;
      relay.OnPropertyChanged("ConvertedValue");
    }

    #endregion

    #region CLR properties

    /// <summary>
    /// The target property on the element which this MultiBinding is assocaited with.
    /// </summary>
    public string TargetProperty { get; set; }

    /// <summary>
    /// The Converter which is invoked to compute the result of the multiple bindings
    /// </summary>
    public IMultiValueConverter Converter { get; set; }

    /// <summary>
    /// The configuration parameter supplied to the converter
    /// </summary>
    public object ConverterParameter { get; set; }

    /// <summary>
    /// The bindings, the result of which are supplied to the converter.
    /// </summary>
    public ObservableCollection<Binding> Bindings { get; set; }

    #endregion

    public MultiBinding()
    {
      Bindings = new ObservableCollection<Binding>();
    }

    /// <summary>
    /// Invoked when any of the BindingSlave's Value property changes.
    /// </summary>
    private void Slave_PropertyChanged(object sender, PropertyChangedEventArgs e)
    {
      UpdateConvertedValue();
    }

    /// <summary>
    /// Uses the Converter to update the ConvertedValue in order to reflect
    /// the current state of the bindings.
    /// </summary>
    private void UpdateConvertedValue()
    {
      List<object> values = new List<object>();
      foreach (BindingSlave slave in Children)
      {
        values.Add(slave.Value);
      }
      ConvertedValue = Converter.Convert(values.ToArray(), typeof(object), ConverterParameter,
        CultureInfo.CurrentCulture);
    }

    /// <summary>
    /// Creates a BindingSlave for each Binding and binds the Value
    /// accordingly.
    /// </summary>
    internal void Initialise()
    {
      foreach (Binding binding in Bindings)
      {
        BindingSlave slave = new BindingSlave();
        slave.SetBinding(BindingSlave.ValueProperty, binding);
        slave.PropertyChanged += new PropertyChangedEventHandler(Slave_PropertyChanged);
        Children.Add(slave);
      }
    }

    #region INotifyPropertyChanged Members

    public event PropertyChangedEventHandler PropertyChanged;

    protected void OnPropertyChanged(string name)
    {
      if (PropertyChanged != null)
      {
        PropertyChanged(this, new PropertyChangedEventArgs(name));
      }
    }

    #endregion
  }

  /// <summary>
  /// A simple element with a single Value property, used as a 'slave'
  /// for a Binding.
  /// </summary>
  public class BindingSlave : FrameworkElement, INotifyPropertyChanged
  {
    #region Value

    public static readonly DependencyProperty ValueProperty =
        DependencyProperty.Register("Value", typeof(object), typeof(BindingSlave),
            new PropertyMetadata(null, OnValueChanged));

    public object Value
    {
      get { return (object)GetValue(ValueProperty); }
      set { SetValue(ValueProperty, value); }
    }

    private static void OnValueChanged(DependencyObject depObj, DependencyPropertyChangedEventArgs e)
    {
      BindingSlave slave = depObj as BindingSlave;
      slave.OnPropertyChanged("Value");
    }

    #endregion

    #region INotifyPropertyChanged Members

    public event PropertyChangedEventHandler PropertyChanged;

    protected void OnPropertyChanged(string name)
    {
      if (PropertyChanged != null)
      {
        PropertyChanged(this, new PropertyChangedEventArgs(name));
      }
    }

    #endregion

  }
}

代码自己看，不解释。

最后使用起来就是这样，可以绑定N个域，逻辑在Converter里面实现：

<TextBlock Foreground="White" FontSize="13">
    <local:BindingUtil.MultiBinding>
        <local:MultiBinding TargetProperty="Text" Converter="{StaticResource TitleConverter}">
            <Binding Path="Surname"/>
            <Binding Path="Forename"/>
        </local:MultiBinding>
    </local:BindingUtil.MultiBinding>
</TextBlock>

是否有必要用多重绑定?

一般你要用到多重绑定的情况是：这个域需要根据多个域的值来计算（包含一定的业务逻辑），也就是多重绑定吗？就需要把业务逻辑放到ValueConverter里面吗？不一定。ValueConverter也不太合适。实现方法很多。如果我们用MVVM模式来开发Silverlight的话，那M-V-VM里面就有个M:Model，可以把这个需要根据多个域的值来计算（包含一定的业务逻辑）的域放到呈现模型里面，这样就能很方便的绑定到这个新的Field了。如果你的MVVM模式没有M，只有VM，这就是设计的问题了。一般来说，有很多业务逻辑需要放到这个M里面，包括本文说的复合域的情形，还有数据验证(Validation)的情形，都可能需要用到M。这个M设计的好，绑定才实现的完美。

反过来，本文所实现的方法是用多重绑定加ValueConverter，而把业务逻辑放到ValueConverter里面不太合适。Converter应该是薄薄的，也就是数据转换为适合显示的格式，比如bool转换为Visibility…..

总结

遇到问题，多思考，不要打破系统架构和层次设计，不要胡乱添加业务逻辑，这很容易导致系统的“破窗效应”。动手写代码之前写思考，思考的代价远比写代码、测试、重构的代价小！