C# 在Windows Phone 7或Windows Phone 8中使用CollectionView进行LongListSelector分组

我面临的问题与下面标签中列出的问题相同

我使用以下代码将LongListSelector与分组绑定

CollectionViewSource cv = new CollectionViewSource();
cv.Source = comments;
cv.GroupDescriptions.Add(new PropertyGroupDescription("Filter"));

listSelector.HideEmptyGroups = true;
listSelector.ItemsSource = cv.View.Groups;

---

但它没有显示任何内容。有人能帮我吗？

它不支持ICollectionView的设计。该控件期望组实现IEnumerable，而CollectionViewGroup没有实现。CollectionViewGroup是所有ICollectionView组的基类

因此，您必须围绕ICollectionView制作一个包装器，以支持LongListSelector期望的接口或修改LongListSelector源代码

下面是我快速而肮脏的包装器实现：

namespace PresentationModel
{
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Collections.Specialized;
    using System.ComponentModel;
    using System.Linq;
    using System.Windows.Data;

    public class GroupViewItem : IList, INotifyCollectionChanged
    {
        private readonly CollectionViewGroup group;

        public GroupViewItem(CollectionViewGroup group)
        {
            this.group = group;
            ((INotifyCollectionChanged)this.group.Items).CollectionChanged += HandleCollectionViewGroupChanged;

        }

        private void HandleCollectionViewGroupChanged(object sender, NotifyCollectionChangedEventArgs e)
        {
            OnCollectionChanged(e);
        }

        public object Name { get { return this.group.Name; } }

        public int Count { get { return this.group.ItemCount; } }

        public IEnumerator GetEnumerator()
        {
            return this.group.Items.GetEnumerator();
        }

        public event NotifyCollectionChangedEventHandler CollectionChanged;

        private void OnCollectionChanged(NotifyCollectionChangedEventArgs args)
        {
            var collectionChanged = this.CollectionChanged;
            if (collectionChanged != null)
            {
                collectionChanged(this, args);
            }
        }

        int IList.Add(object value)
        {
            throw new NotSupportedException();
        }

        void IList.Clear()
        {
            throw new NotSupportedException();
        }

        bool IList.Contains(object value)
        {
            throw new NotSupportedException();
        }

        int IList.IndexOf(object value)
        {
            throw new NotSupportedException();
        }

        void IList.Insert(int index, object value)
        {
            throw new NotSupportedException();
        }

        bool IList.IsFixedSize
        {
            get
            {
                throw new NotSupportedException();
            }
        }

        bool IList.IsReadOnly
        {
            get
            {
                throw new NotSupportedException();
            }
        }

        void IList.Remove(object value)
        {
            throw new NotSupportedException();
        }

        void IList.RemoveAt(int index)
        {
            throw new NotSupportedException();
        }

        object IList.this[int index]
        {
            get
            {
                throw new NotSupportedException();
            }
            set
            {
                throw new NotSupportedException();
            }
        }

        void ICollection.CopyTo(System.Array array, int index)
        {
            throw new NotSupportedException();
        }

        bool ICollection.IsSynchronized
        {
            get
            {
                throw new NotSupportedException();
            }
        }

        object ICollection.SyncRoot
        {
            get
            {
                throw new NotSupportedException();
            }
        }
    }

    public class GroupView : IEnumerable, INotifyCollectionChanged
    {
        private readonly ICollectionView collectionView;
        private readonly List<GroupViewItem> items;

        public GroupView(ICollectionView collectionView)
        {
            this.items = new List<GroupViewItem>();

            this.collectionView = collectionView;
            ((INotifyCollectionChanged)this.collectionView.Groups).CollectionChanged += HandleCollectionViewGroupsChanged;
            ResetGroups(notify: false);
        }

        private void HandleCollectionViewGroupsChanged(object sender, NotifyCollectionChangedEventArgs e)
        {
            switch (e.Action)
            {
                case NotifyCollectionChangedAction.Add:
                    AddGroups(e);
                    break;
                case NotifyCollectionChangedAction.Remove:
                    RemoveGroups(e);
                    break;
                case NotifyCollectionChangedAction.Replace:
                    ReplaceGroups(e);
                    break;
                case NotifyCollectionChangedAction.Reset:
                    ResetGroups();
                    break;
            }
        }

        private IList<GroupViewItem> AddGroups(NotifyCollectionChangedEventArgs e, bool notify = true)
        {
            var newGroups = e.NewItems
                .Cast<CollectionViewGroup>()
                .Select(cvg => new GroupViewItem(cvg))
                .ToArray();

            this.items.InsertRange(e.NewStartingIndex, newGroups);

            if (notify)
            {
                for (var i = 0; i != newGroups.Length; ++i)
                {
                    OnCollectionChanged(new NotifyCollectionChangedEventArgs(
                        NotifyCollectionChangedAction.Add,
                        newGroups[i],
                        e.NewStartingIndex + i));
                }
            }

            return newGroups;
        }

        private IList<GroupViewItem> RemoveGroups(NotifyCollectionChangedEventArgs e, bool notify = true)
        {
            var oldGroups = this.items.GetRange(e.OldStartingIndex, e.OldItems.Count);

            this.items.RemoveRange(e.OldStartingIndex, e.OldItems.Count);

            if (notify)
            {
                for (var i = 0; i != oldGroups.Count; ++i)
                {
                    OnCollectionChanged(new NotifyCollectionChangedEventArgs(
                        NotifyCollectionChangedAction.Remove,
                        oldGroups[i],
                        e.OldStartingIndex + i));
                }
            }

            return oldGroups;
        }

        private void ReplaceGroups(NotifyCollectionChangedEventArgs e)
        {
            var oldGroups = RemoveGroups(e, notify: false);
            var newGroups = AddGroups(e, notify: false);

            if (oldGroups.Count != newGroups.Count)
            {
                OnCollectionChanged(new NotifyCollectionChangedEventArgs(
                    NotifyCollectionChangedAction.Reset));
            }
            else
            {
                for (var i = 0; i != newGroups.Count; ++i)
                {
                    OnCollectionChanged(new NotifyCollectionChangedEventArgs(
                        NotifyCollectionChangedAction.Replace,
                        newGroups[i], oldGroups[i],
                        e.NewStartingIndex + i));
                }
            }
        }

        private void ResetGroups(bool notify = true)
        {
            this.items.Clear();
            this.items.AddRange(
                this.collectionView.Groups
                    .Cast<CollectionViewGroup>()
                    .Select(cvg => new GroupViewItem(cvg)));

            if (notify)
            {
                OnCollectionChanged(new NotifyCollectionChangedEventArgs(
                    NotifyCollectionChangedAction.Reset));
            }
        }

        public event NotifyCollectionChangedEventHandler CollectionChanged;

        public IEnumerator GetEnumerator()
        {
            return this.items.GetEnumerator();
        }

        private void OnCollectionChanged(NotifyCollectionChangedEventArgs args)
        {
            var collectionChanged = this.CollectionChanged;
            if (collectionChanged != null)
            {
                collectionChanged(this, args);
            }
        }
    }
}

namespace PresentationModel
{
使用制度；
使用系统集合；
使用System.Collections.Generic；
使用System.Collections.Specialized；
使用系统组件模型；
使用System.Linq；
使用System.Windows.Data；
公共类GroupViewItem:IList，INotifyCollectionChanged
{
私有只读集合视图组；
公共组视图项（CollectionViewGroup组）
{
this.group=组；
（（INotifyCollectionChanged）this.group.Items）.CollectionChanged+=HandleCollectionViewGroupChanged；
}
私有void HandleCollectionViewGroupChanged（对象发送方，NotifyCollectionChangedEventArgs e）
{
非集合更改（e）；
}
公共对象名称{get{返回this.group.Name；}}
公共整数计数{get{返回this.group.ItemCount；}}
公共IEnumerator GetEnumerator（）
{
返回此.group.Items.GetEnumerator（）；
}
公共事件通知CollectionChangedEventHandler CollectionChanged；
CollectionChanged上的私有void（NotifyCollectionChangedEventArgs args）
{
var collectionChanged=this.collectionChanged；
如果（collectionChanged！=null）
{
collectionChanged（此参数为args）；
}
}
int IList.Add（对象值）
{
抛出新的NotSupportedException（）；
}
void IList.Clear（）
{
抛出新的NotSupportedException（）；
}
bool IList.Contains（对象值）
{
抛出新的NotSupportedException（）；
}
int IList.IndexOf（对象值）
{
抛出新的NotSupportedException（）；
}
void IList.Insert（int索引，对象值）
{
抛出新的NotSupportedException（）；
}
bool IList.IsFixedSize
{
得到
{
抛出新的NotSupportedException（）；
}
}
bool-IList.IsReadOnly
{
得到
{
抛出新的NotSupportedException（）；
}
}
void IList.Remove（对象值）
{
抛出新的NotSupportedException（）；
}
void IList.RemoveAt（int索引）
{
抛出新的NotSupportedException（）；
}
对象IList。此[int索引]
{
得到
{
抛出新的NotSupportedException（）；
}
设置
{
抛出新的NotSupportedException（）；
}
}
void ICollection.CopyTo（System.Array数组，int索引）
{
抛出新的NotSupportedException（）；
}
布尔ICollection.IsSynchronized
{
得到
{
抛出新的NotSupportedException（）；
}
}
对象ICollection.SyncRoot
{
得到
{
抛出新的NotSupportedException（）；
}
}
}
公共类组视图：IEnumerable，INotifyCollectionChanged
{
私有只读ICollectionView collectionView；
私有只读列表项；
公共组视图（ICollectionView集合视图）
{
this.items=新列表（）；
this.collectionView=collectionView；
（（INotifyCollectionChanged）this.collectionView.Groups）。CollectionChanged+=HandleCollectionViewGroupsChanged；
重置组（通知：false）；
}
私有void HandleCollectionViewGroupsChanged（对象发送方，NotifyCollectionChangedEventArgs e）
{
开关（电动）
{
案例NotifyCollectionChangedAction。添加：
各组（e）；
打破
案例NotifyCollectionChangedAction。删除：
移除组（e）；
打破
案例通知收集更改操作。替换：
三组（e）；
打破
案例通知CollectionChangedAction.Reset：
重置组（）；
打破
}
}
私有IList AddGroups（NotifyCollectionChangedEventArgs e，bool notify=true）
{
var newGroups=e.NewItems
.Cast（）
.选择（cvg=>new GroupViewItem（cvg））
.ToArray（）；
this.items.InsertRange（例如NewStartingIndex、newGroups）；
如果（通知）
{
对于（变量i=0；i！=newGroups.Length；++i）
{
OnCollectionChanged（新建NotifyCollectionChangedEventArgs(
NotifyCollectionChangedAction.Add，
新集团[i]，
e、 新闻开始索引+i）；
}
}
返回新组；
}
私有IList RemoveGroups（NotifyCollectionChangedEventArgs e，bool notify=true）
{
var oldGroups=this.items.GetRange（e.OldStartingIndex，e.OldItems.Count）；
this.items.RemoveRange（e.OldStartingIndex，e.OldItems.Count）；
我