WP7 ListBox 滚动探测 以及 分页加载

public class ScrollBehavior
    {
        public static DependencyProperty AtEndCommandProperty
            = DependencyProperty.RegisterAttached(
                "AtEndCommand", typeof(ICommand),
                typeof(ScrollBehavior),
                new PropertyMetadata(null, OnCommandChanged));

        public static ICommand GetAtEndCommand(DependencyObject obj)
        {
            return (ICommand)obj.GetValue(AtEndCommandProperty);
        }

        public static void SetAtEndCommand(DependencyObject obj, ICommand value)
        {
            obj.SetValue(AtEndCommandProperty, value);
        }

        public static DependencyProperty AtTopCommandProperty
           = DependencyProperty.RegisterAttached(
               "AtTopCommand", typeof(ICommand),
               typeof(ScrollBehavior),
               new PropertyMetadata(null, OnCommandChanged));

        public static ICommand GetAtTopCommand(DependencyObject obj)
        {
            return (ICommand)obj.GetValue(AtTopCommandProperty);
        }

        public static void SetAtTopCommand(DependencyObject obj, ICommand value)
        {
            obj.SetValue(AtTopCommandProperty, value);
        }

        public static DependencyProperty AtScrollCommandProperty
        = DependencyProperty.RegisterAttached(
       "AtScrollCommand", typeof(ICommand),
       typeof(ScrollBehavior),
       new PropertyMetadata(null, OnCommandChanged));

        public static ICommand GetAtScrollCommand(DependencyObject obj)
        {
            return (ICommand)obj.GetValue(AtScrollCommandProperty);
        }

        public static void SetAtScrollCommand(DependencyObject obj, ICommand value)
        {
            obj.SetValue(AtScrollCommandProperty, value);
        }

        public static void OnCommandChanged(
            DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            FrameworkElement element = (FrameworkElement)d;
            if (element != null && element is ListBox)
            {
                element.Loaded -= element_Loaded;
                element.Loaded += element_Loaded;
            }
        }

        static void element_Loaded(object sender, RoutedEventArgs e)
        {
            ((FrameworkElement)sender).Loaded -= element_Loaded;
            ScrollViewer scrollViewer = FindChildOfType((FrameworkElement)sender);
            if (scrollViewer != null)
            {

                var listener = new Listener();
                listener.Changed += delegate
                {

                    if (scrollViewer.ScrollableHeight != 0)
                    {
                        //System.Diagnostics.Debug.WriteLine((scrollViewer.VerticalOffset - scrollViewer.ScrollableHeight).ToString());
                        if ((scrollViewer.VerticalOffset - scrollViewer.ScrollableHeight) >= -2)
                        {

                            CommandArg endCommandArg = new CommandArg();
                            endCommandArg.Key = "IsEnd";
                            endCommandArg.Value = true;

                            var endCommand = GetAtEndCommand((FrameworkElement)sender);

                            if (endCommand != null && endCommand.CanExecute(endCommandArg))
                            {
                                //System.Diagnostics.Debug.WriteLine("Scroll End");
                                endCommand.Execute(endCommandArg);
                            }
                        }

                        //System.Diagnostics.Debug.WriteLine(scrollViewer.VerticalOffset.ToString());
                        if (scrollViewer.VerticalOffset < 2)
                        {
                            CommandArg topCommandArg = new CommandArg();
                            topCommandArg.Key = "IsEnd";
                            topCommandArg.Value = false;

                            var topCommand = GetAtTopCommand((FrameworkElement)sender);
                            if (topCommand != null && topCommand.CanExecute(topCommandArg))
                            {

                                //System.Diagnostics.Debug.WriteLine("Scroll Top");
                                topCommand.Execute(topCommandArg);
                            }
                        }

                        CommandArg scrollCommandArg = new CommandArg();
                        scrollCommandArg.Key = "Sender";
                        scrollCommandArg.Value = scrollViewer;

                        var scrollCommand = GetAtScrollCommand((FrameworkElement)sender);
                        if (scrollCommand != null && scrollCommand.CanExecute(scrollCommandArg))
                        {
                            //System.Diagnostics.Debug.WriteLine("Scroll");
                            scrollCommand.Execute(scrollCommandArg);
                        }
                    }

                };

                Binding binding = new Binding("VerticalOffset");
                binding.Source = scrollViewer;
                listener.Attach(scrollViewer, binding);

            }

        }

        static T FindChildOfType(DependencyObject root) where T : class
        {
            var queue = new Queue();
            queue.Enqueue(root);

            while (queue.Count > 0)
            {
                DependencyObject current = queue.Dequeue();
                for (int i = VisualTreeHelper.GetChildrenCount(current) - 1; 0 <= i; i--)
                {
                    var child = VisualTreeHelper.GetChild(current, i);
                    var typedChild = child as T;
                    if (typedChild != null)
                    {
                        return typedChild;
                    }
                    queue.Enqueue(child);
                }
            }
            return null;
        }
    }

    public class Listener
    {
        public readonly DependencyProperty property;
        ScrollViewer target;

        public Listener()
        {
            property = DependencyProperty.RegisterAttached(
                "ListenValue",
                typeof(object),
                typeof(Listener),
                new PropertyMetadata(null, HandleValueChanged));
        }

        public event EventHandler Changed;

        void HandleValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {

            OnChanged(new ValueChangedEventArgs(e));
        }

        protected void OnChanged(ValueChangedEventArgs e)
        {

            if (Changed != null)
            {
                Changed(target, e);
            }
        }

        public void Attach(ScrollViewer element, Binding binding)
        {
            if (target != null)
            {
                throw new Exception(
                    "Cannot attach an already attached listener");
            }

            target = element;
            if (target.GetBindingExpression(property) == null)
            {
                target.SetBinding(property, binding);
            }

        }

        public void Detach()
        {
            target.ClearValue(property);
            target = null;
        }

    }

    public class ValueChangedEventArgs : EventArgs
    {
        public ValueChangedEventArgs(DependencyPropertyChangedEventArgs e)
        {
            EventArgs = e;
        }

        public DependencyPropertyChangedEventArgs EventArgs { get; private set; }
    }