【WP8】LoopingSelector

WP8的WindowsPhoneToolkit工具包中有一个 LoopingSelector

可以想选择日期或时间一样进行选择

1、首先当然是引用WindowsPhoneToolkit

　　在Nuget控制台：

　PM> Install-Package WPtoolkit

2、LoopingSelector 的数据源是 ILoopingSelectorDataSource类型的，我们先实现两个类继承该接口

    public abstract class LoopingDataSourceBase : ILoopingSelectorDataSource
    {
        #region ILoopingSelectorDataSource Members

        public abstract object GetNext(object relativeTo);

        public abstract object GetPrevious(object relativeTo);

        private object _selectedItem;
        public object SelectedItem
        {
            get { return _selectedItem; }
            set
            {
                if (!Equals(_selectedItem, value))
                {
                    object previousSelectedItem = _selectedItem;
                    _selectedItem = value;

                    OnSelectionChanged(previousSelectedItem, _selectedItem);
                }
            }
        }

        public event EventHandler<SelectionChangedEventArgs> SelectionChanged;

        protected virtual void OnSelectionChanged(object oldSelectedItem, object newSelectedItem)
        {
            var handler = SelectionChanged;
            if (handler != null)
            {
                handler(this, new SelectionChangedEventArgs(new[] {oldSelectedItem}, new[] {newSelectedItem}));
            }
        }

        #endregion
    }

LoopingDataSourceBase 抽象类

    public class ListLoopingDataSource<T> : LoopingDataSourceBase
    {
        private IComparer<T> comparer;
        private LinkedList<T> linkedList;
        private NodeComparer nodeComparer;
        private List<LinkedListNode<T>> sortedList;

        public IEnumerable<T> Items
        {
            get { return linkedList; }
            set
            {
                SetItemCollection(value);
            }
        }

        public IComparer<T> Comparer
        {
            get { return comparer; }
            set { comparer = value; }
        }

        private void SetItemCollection(IEnumerable<T> collection)
        {
            linkedList = new LinkedList<T>(collection);

            sortedList = new List<LinkedListNode<T>>(linkedList.Count);

            LinkedListNode<T> currentNode = linkedList.First;
            while (currentNode != null)
            {
                sortedList.Add(currentNode);
                currentNode = currentNode.Next;
            }

            IComparer<T> comparer = this.comparer;
            if (comparer == null)
            {
                if (typeof (IComparable<T>).IsAssignableFrom(typeof (T)))
                {
                    comparer = Comparer<T>.Default;
                }
                else
                {
                    throw new InvalidOperationException(
                        "There is no default comparer for this type of item. You must set one.");
                }
            }

            nodeComparer = new NodeComparer(comparer);
            sortedList.Sort(nodeComparer);
        }

        public override object GetNext(object relativeTo)
        {
            int index = sortedList.BinarySearch(new LinkedListNode<T>((T) relativeTo), nodeComparer);
            if (index < )
            {
                return default(T);
            }

            LinkedListNode<T> node = sortedList[index].Next;
            if (node == null)
            {
                node = linkedList.First;
            }
            return node.Value;
        }

        public override object GetPrevious(object relativeTo)
        {
            int index = sortedList.BinarySearch(new LinkedListNode<T>((T) relativeTo), nodeComparer);
            if (index < )
            {
                return default(T);
            }
            LinkedListNode<T> node = sortedList[index].Previous;
            if (node == null)
            {
                node = linkedList.Last;
            }
            return node.Value;
        }

        private class NodeComparer : IComparer<LinkedListNode<T>>
        {
            private readonly IComparer<T> comparer;

            public NodeComparer(IComparer<T> comparer)
            {
                this.comparer = comparer;
            }

            #region IComparer<LinkedListNode<T>> Members

            public int Compare(LinkedListNode<T> x, LinkedListNode<T> y)
            {
                return comparer.Compare(x.Value, y.Value);
            }

            #endregion
        }
    }

ListLoopingDataSource

　　注意，数据源如果是对象，必须实现IComparer<T>接口，否则会抛出异常，当然，也可以重写ListLoopingDataSource类

下面是数据源对象，我们这里定义为Person

    public class Person : IComparable<Person>
    {
        public string Name { get; set; }
        public int Age { get; set; }

        public int CompareTo(Person other)
        {
            //比较两个对象：这里只比较名字
            return String.CompareOrdinal(Name, other.Name);
        }
    }

Person

3、接下来是数据绑定

            <toolkitPrimitives:LoopingSelector
                x:Name="LoopingSelector"
                    DataSource="{Binding Items}"
                    ItemMargin="2,3,3,2"
                    ItemSize="200,150"
                    FontSize="33" >
                <toolkitPrimitives:LoopingSelector.ItemTemplate>
                    <DataTemplate>
                        <Grid>
                            <StackPanel>
                                <TextBlock Text="{Binding Name}"></TextBlock>
                                <TextBlock Text="{Binding Age}"></TextBlock>
                            </StackPanel>
                        </Grid>
                    </DataTemplate>
                </toolkitPrimitives:LoopingSelector.ItemTemplate>
            </toolkitPrimitives:LoopingSelector>

    public partial class LoopSelectorPage : INotifyPropertyChanged
    {
        #region Items

        /// <summary>
        /// The <see cref="Items" /> property's name.
        /// </summary>
        public const string ItemsPropertyName = "Items";

        private ListLoopingDataSource<Person> _items;

        /// <summary>
        /// 用于绑定到LoopingSelector的数据源对象
        /// </summary>
        public ListLoopingDataSource<Person> Items
        {
            get
            {
                return _items;
            }

            set
            {
                if (_items == value)
                {
                    return;
                }

                _items = value;
                RaisePropertyChanged(ItemsPropertyName);
            }
        }

        #endregion

        public LoopSelectorPage()
        {
            InitializeComponent();
            LoadApplicationBar();
            LoadData();
        }

        private void LoadApplicationBar()
        {
            ApplicationBar = new ApplicationBar();

            var appBarButton = new ApplicationBarIconButton(new Uri("/Assets/AppBar/appbar.add.rest.png", UriKind.Relative))
            {
                Text = "test"
            };
            appBarButton.Click += appBarButton_Click;
            ApplicationBar.Buttons.Add(appBarButton);

        }

        private void appBarButton_Click(object sender, EventArgs e)
        {
            //改变数据源
            Items = new ListLoopingDataSource<Person>
            {
                Items = new ObservableCollection<Person>
                {
                    new Person{Name = "Cnblogs", Age = },
                    new Person{Name = "CodePlex", Age = },
                    new Person{Name = "CodeProject", Age = },
                    new Person{Name = "CSDN", Age = },
                    new Person{Name = "51CTO", Age = },
                },
            };
            //注意，如果改变了数据源，必须设置其SelectedItem属性
            Items.SelectedItem = Items.Items.First();
        }

        private void LoadData()
        {
            Items = new ListLoopingDataSource<Person>
            {
                Items = new ObservableCollection<Person>
                {
                    new Person{Name = "aaa", Age = },
                    new Person{Name = "bbb", Age = },
                    new Person{Name = "ccc", Age = },
                    new Person{Name = "ddd", Age = },
                    new Person{Name = "eee", Age = },
                },
            };

            //注意，如果改变了数据源，必须设置其SelectedItem属性
            Items.SelectedItem = Items.Items.First();

            //也可以监听选择改变的事件
            Items.SelectionChanged += Items_SelectionChanged;

        }

        void Items_SelectionChanged(object sender, System.Windows.Controls.SelectionChangedEventArgs e)
        {
            MessageBox.Show(string.Format("add:{0}", ((Person)e.AddedItems[]).Name));
        }

        #region INotifyPropertyChanged Members

        public event PropertyChangedEventHandler PropertyChanged;

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

        #endregion
    }

LoopSelectorPage.xaml.cs

好了，数据源的集合是用 IEnumerable<T>存放的，如果需要添加和删除该数据源，可以使用List<T>对象，或是ObservableCollection<T> 对象存储