Silverlight中创建自己的Behavior（为Silverlight添加鼠标双击和滚轮支持）

    Blend3中内置了8种Behavior，这里介绍一下如何创建自己的Behavior。

    1、创建一个新的项目或解决方案，选择Silverlight 类库，名称为MyBehaviors。
    2、添加“System.Windows.Interactivity.dll”引用。
    3、删除默认类Class1.cs，并新建类MouseDoubleClickBehavior.cs（实现鼠标双击）代码见表1：
    4、新建类MouseWheelScrollBehavior.cs（实现鼠标滚轮）代码见表2：
    5、编译生成MyBehaviors.dll；
    6、在Silverlight项目中添加“MyBehaviors.dll”引用，用Blend3打开项目，在Assets页中就可以显示自己的Behavior了。
    7、用法：直接在Blend中将Behavior拖拽到要使用的控件就可以了。
   

代码下载：https://files.cnblogs.com/zhaoxb/MyBehaviors.rar

表1：

namespace MyBehaviors
{
    public class MouseDoubleClickBehavior : Behavior<UIElement>
    {
        private AutomationPeer Peer { get; set; }

        protected override void OnAttached()
        {
            Peer = FrameworkElementAutomationPeer.FromElement(AssociatedObject) ??
                   FrameworkElementAutomationPeer.CreatePeerForElement(AssociatedObject);

            AssociatedObject.MouseLeftButtonUp += AssociatedObject_MouseLeftButtonUp;
            base.OnAttached();
        }

        protected override void OnDetaching()
        {
            AssociatedObject.MouseLeftButtonUp -= AssociatedObject_MouseLeftButtonUp;
            base.OnDetaching();
        }

        private bool _waiting;
        private DateTime _waitingSince;

        private void AssociatedObject_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
        {
            if (_waiting)
            {
                if (DateTime.Now.Subtract(_waitingSince).Milliseconds < Interval)
                    OnMouseDoubleClick(e);
                _waiting = false;
            }
            else
            {
                _waiting = true;
                _waitingSince = DateTime.Now;
            }
        }

        private void OnMouseDoubleClick(MouseButtonEventArgs args)
        {
            if (MouseDoubleClick != null)
                MouseDoubleClick(AssociatedObject, args);
        }

        public event MouseButtonEventHandler MouseDoubleClick;
        private int _interval = 500;
        public int Interval
        {
            get { return _interval; }
            set { _interval = value; }
        }
    }
}

    表2：

namespace MyBehaviors
{
    public enum ScrollOrientations
    {
        Auto = 0,
        None = 1,
        Vertical = 2,
        Horizontal = 3
    }

    public class MouseWheelScrollBehavior : Behavior<FrameworkElement>
    {
        public MouseWheelScrollBehavior()
        {
        }

        private ScrollViewer scrollObject = null;
        private ScrollViewer ScrollObject
        {
            get { return scrollObject; }
            set
            {
                if (scrollObject != value)
                {
                    scrollObject = value;
                    if (scrollObject != null)
                    {
                        var peer = FrameworkElementAutomationPeer.CreatePeerForElement(ScrollObject);
                        _scrollProvider = peer.GetPattern(PatternInterface.Scroll) as IScrollProvider;
                    }
                    else
                    {
                        _scrollProvider = null;
                    }
                }
            }
        }

        private IScrollProvider _scrollProvider = null;

        private ScrollViewer GetChildScrollViewer(DependencyObject parentObject)
        {
            ScrollViewer result = parentObject as ScrollViewer;

            if (result == null && parentObject != null)
            {
                if (parentObject is Popup)
                {
                    result = GetChildScrollViewer(((Popup)parentObject).Child);
                }
                else
                {
                    var total = VisualTreeHelper.GetChildrenCount(parentObject);
                    for (int i = 0; i < total; i++)
                    {
                        var child = VisualTreeHelper.GetChild(parentObject, i);
                        result = GetChildScrollViewer(child);
                        if (result != null) break;
                    }
                }
            }

            return result;
        }

        protected override void OnAttached()
        {
            base.OnAttached();

            if (this.AssociatedObject != null)
            {
                this.AssociatedObject.LayoutUpdated += AssociatedObject_LayoutUpdated;
            }

            LoadChildScrollViewer();
        }

        void AssociatedObject_LayoutUpdated(object sender, EventArgs e)
        {
            LoadChildScrollViewer();
        }

        private void LoadChildScrollViewer()
        {
            this.ScrollObject = GetChildScrollViewer(this.AssociatedObject);
            if (this.ScrollObject != null)
            {
                this.ScrollObject.MouseWheel += scrollObject_MouseWheel;
                if (this.AssociatedObject != null && !(this.AssociatedObject is ScrollViewer))
                {
                    this.AssociatedObject.LayoutUpdated -= AssociatedObject_LayoutUpdated;
                }
            }
        }

        private void scrollObject_MouseWheel(object sender, MouseWheelEventArgs e)
        {
            if (_scrollProvider != null)
            {
                int newDelta = InvertScrollDirection ? -e.Delta : e.Delta;
                ScrollAmount amount = newDelta < 0 ? 
                       ScrollAmount.SmallIncrement : ScrollAmount.SmallDecrement;
                switch (GetCurrentScrollOrientation())
                {
                    case ScrollOrientations.Vertical:
                        e.Handled = true;
                        _scrollProvider.Scroll(ScrollAmount.NoAmount, amount);
                        break;
                    case ScrollOrientations.Horizontal:
                        e.Handled = true;
                        _scrollProvider.Scroll(amount, ScrollAmount.NoAmount);
                        break;
                }
            }
        }

        private ScrollOrientations GetCurrentScrollOrientation()
        {
            ScrollOrientations result = ScrollOrientations.None;
            var scrl = this.ScrollObject;
            var sd = ScrollOrientation;
            if (scrl != null && sd != ScrollOrientations.None)
            {
                if (sd == ScrollOrientations.Auto)
                {
                    if (scrl.ScrollableHeight > 0)
                    {
                        result = ScrollOrientations.Vertical;
                    }
                    else if (scrl.ScrollableWidth > 0)
                    {
                        result = ScrollOrientations.Horizontal;
                    }
                }
                else
                {
                    result = sd;
                }
            }

            return result;
        }

        protected override void OnDetaching()
        {
            base.OnDetaching();

            if (this.ScrollObject != null)
            {
                this.ScrollObject.MouseWheel -= scrollObject_MouseWheel;
            }
        }

        public static readonly DependencyProperty ScrollOrientationProperty = 
                         DependencyProperty.Register("ScrollOrientation",
            typeof(ScrollOrientations), typeof(MouseWheelScrollBehavior), null);

        [DefaultValue(ScrollOrientations.Auto)]
        public ScrollOrientations ScrollOrientation
        {
            get { return (ScrollOrientations)GetValue(ScrollOrientationProperty); }
            set { SetValue(ScrollOrientationProperty, value); }
        }

        public static readonly DependencyProperty InvertScrollDirectionProperty = 
                         DependencyProperty.Register("InvertScrollDirection",
            typeof(bool), typeof(MouseWheelScrollBehavior), null);

        [DefaultValue(false)]
        public bool InvertScrollDirection
        {
            get { return (bool)GetValue(InvertScrollDirectionProperty); }
            set { SetValue(InvertScrollDirectionProperty, value); }
        }
    }
}