在MVVM中加载LongListSelector

我第一次使用MVVM Light，所以请容忍我

我的主页上有一个LongListSelector，在加载页面时，我使用RelayCommand从SQLCE数据库中加载数据

在我的MainViewModel中，我有一个属性：

public const string WorkoutsPropertyName = "Workouts";

private PublicGrouping<DateTime, Workout> _workouts;
public PublicGrouping,DateDime, Workout> Workouts
{
    get { return workouts; }
    set
    {
        if (_workouts == value) { return; }
        _workouts = value;
        RaisePropertyChanged(WorkoutsPropertyName);
    }
}

public const string Workouts属性name=“Workouts”；
私人健身活动；
公共分组、DateDime、训练>训练
{
获取{返回训练；}
设置
{
如果（_workouts==value）{return；}
_训练=价值；
RaisePropertyChanged（作业属性名称）；
}
}

然后，在构造函数中，我创建LoadedCommand：

public MainViewModel()
{
    LoadedCommand = new RelayCommand(() =>
    {
        context = new XLogDataContext();

        using (context)
        {
            if (context.Workouts.Count() > 0)
            {
                var workoutsByDate = from workout in context.Workouts
                                    group workout by workout.WorkoutDate
                                    into c
                                    orderby c.Key
                                    select c;
                Workouts = workoutsByDate as PublicGrouping<DateTime, Workout>;
            }
        }
    });
}

public主视图模型（）
{
LoadedCommand=新的RelayCommand（（）=>
{
context=new XLogDataContext（）；
使用（上下文）
{
如果（context.Workouts.Count（）>0）
{
var workoutsByDate=来自上下文中的训练。训练
按训练分组训练。训练日期
变成c
orderby c.Key
选择c；
训练=作为公共分组的训练日期；
}
}
});
}

当RelayCommand运行时，训练始终返回null。我知道有数据返回，所以我认为问题在于将LINQ查询转换为PublicGrouping。我还尝试将属性创建为

ObservableCollection<PublicGrouping<DateTime, Workout>>

observedcollection

但这也不行

更新：

我更改了RelayCommand以使用此行：

Workouts = new PublicGrouping<DateTime, Workout>(workoutsByDate);

Workouts=新的公共分组（workoutsByDate）；

并为PublicGrouping添加了此构造函数：

private readonly IGrouping<TKey, TElement> _internalGrouping;

public PublicGrouping(IOrderedQueryable<IGrouping<DateTime, Workout>> workoutsByDate)
{
    _internalGrouping = (IGrouping<TKey, TElement>) workoutsByDate;
}

private readonly iGroup\u internalGrouping；
公共分组（IOrderedQueryable workoutsByDate）
{
_internalGrouping=（i分组）workoutsByDate；
}

---

我仍然在构造函数中的_internalgroupingassignment上获得InvalidCastException。

实际上，您的强制转换将失败，并且在您的情况下，使用

as

操作符不会抛出

InvalidCastException

，因此它被屏蔽

创建

PublicGrouping

的构造函数，该构造函数接受

worksByDate

包含的任何内容的

IEnumerable

这种类型的转换（称为显式转换）：

如果无法将

o

的内部类型转换为字符串，则引发

InvalidCastException

。

as

运算符不会引发此异常，而是返回null。

这应该可以：

public const string WorkoutsPropertyName = "Workouts";

private List<PublicGrouping<DateTime, Workout>> _workouts;
public List<PublicGrouping<DateTime, Workout>> Workouts
{
    get { return _workouts; }
    set
    {
        if (_workouts == value)
        {
            return;
        }



         _workouts = value;

         RaisePropertyChanged(WorkoutsPropertyName);
        }
    }

    public MainViewModel()
    {
        LoadedCommand = new RelayCommand(() =>
            {
                context = new XLogDataContext();

                using (context)
                {
                    if (context.Workouts.Count() > 0)
                    {
                        var workoutsByDate = from workout in context.Workouts
                                            group workout by workout.WorkoutDate
                                            into c
                                            orderby c.Key
                                            select new PublicGrouping<DateTime, Workout>(c);
                        Workouts = workoutsByDate.ToList();
                    }
                }
            });
    }

public const string Workouts属性name=“Workouts”；
私人健身清单；
公开列表训练
{
获取{返回_训练；}
设置
{
如果（_训练==值）
{
返回；
}
_训练=价值；
RaisePropertyChanged（作业属性名称）；
}
}
公共主视图模型（）
{
LoadedCommand=新的RelayCommand（（）=>
{
context=new XLogDataContext（）；
使用（上下文）
{
如果（context.Workouts.Count（）>0）
{
var workoutsByDate=来自上下文中的训练。训练
按训练分组训练。训练日期
变成c
orderby c.Key
选择新分组（c）；
Workouts=workoutsByDate.ToList（）；
}
}
});
}

public const string WorkoutsPropertyName = "Workouts";

private List<PublicGrouping<DateTime, Workout>> _workouts;
public List<PublicGrouping<DateTime, Workout>> Workouts
{
    get { return _workouts; }
    set
    {
        if (_workouts == value)
        {
            return;
        }



         _workouts = value;

         RaisePropertyChanged(WorkoutsPropertyName);
        }
    }

    public MainViewModel()
    {
        LoadedCommand = new RelayCommand(() =>
            {
                context = new XLogDataContext();

                using (context)
                {
                    if (context.Workouts.Count() > 0)
                    {
                        var workoutsByDate = from workout in context.Workouts
                                            group workout by workout.WorkoutDate
                                            into c
                                            orderby c.Key
                                            select new PublicGrouping<DateTime, Workout>(c);
                        Workouts = workoutsByDate.ToList();
                    }
                }
            });
    }