如何使不同类型的方法可重用

Question

我在 Visual Studio 2015 中使用 MVVM Light 来构建 WPF 应用程序。代码中有一种方法在代码中重复了 4 次，但略有变化；唯一的区别是被修改的ObservableCollection的类型和数据服务层调用的方法。

这是方法，它返回一个StatusViewModel对象的ObservableCollection，用于填充ComboBox； StatusVm 用于绑定到ComboBox 的SelectedItem，设置为集合中的第一项并且为“空白”：

private async Task<ObservableCollection<StatusViewModel>> GetStatuses()
{
    var result = new ObservableCollection<StatusViewModel>();
    var blank = new StatusViewModel
    {
        StatusId = -1,
        Status = null,
        Description = null,
        IsActive = false,
        CreatedDate = DateTime.Now
    };
    result.Add(blank);
    var dataService = new MyDataService();
    foreach (var c in await dataService.GetStatuses())
        result.Add(c);
    StatusVm =
        result.SingleOrDefault(c => c.StatusId.Equals(-1));
    return result;
}

这是StatusVm 的私有字段和公共属性：

private StatusViewModel _statusVm;
public StatusViewModel StatusVm
{
    get { return _statusVm; }
    set
    {
        if (Equals(value, _statusVm)) return;
        _statusVm = value;
        RaisePropertyChanged();
    }
}   

现在想象上面的内容再重复 3 次，还有 3 种 VM 类型！如何使GetStatuses() 成为可以采用不同视图模型类型并在数据服务上调用适当方法的方法？谢谢。

更新：下面是另一种类型的属性和方法：

private MroViewModel_mroVm;
public MroViewModel MroVm
{
    get { return _mroVm; }
    set
    {
        if (Equals(value, _mroVm)) return;
        _mroVm = value;
        RaisePropertyChanged();
    }
}   

private async Task<ObservableCollection<MroViewModel>> GetMro()
{
    var result = new ObservableCollection<MroViewModel>();
    var blank = new MroViewModel
    {
        StatusId = -1,
        Status = null,
        Description = null,
        IsActive = false,
        CreatedDate = DateTime.Now
    };
    result.Add(blank);
    var dataService = new MyDataService();
    foreach (var c in await dataService.GetMro())
        result.Add(c);
    MroVm =
        result.SingleOrDefault(c => c.StatusId.Equals(-1));
    return result;
}

Answer 1

您将为常用属性创建接口。

internal interface IStatusViewModel {
        int StatusId { get; set; }
        string Status { get; set; }
        string Description { get; set; }
        bool IsActive { get; set; }
        DateTime CreatedDate { get; set; }
}

在需要检索状态的类中实现接口

internal class MroViewModel : IStatusViewModel {
        public int StatusId { get; set; }
        public string Status { get; set; }
        public string Description { get; set; }
        public bool IsActive { get; set; }
        public DateTime CreatedDate { get; set; }
}

将方法设为静态并传递服务函数，该函数将调用适当的方法来检索旧状态。

public static async Task<ObservableCollection<T>> GetStatuses<T>(
    Func<MyDataService, Task<IEnumerable<T>>> retrieveStatusesAction)
    where T : IStatusViewModel, new()
{
    var result = new ObservableCollection<T>();
    var blank = new T
    {
        StatusId = -1,
        Status = null,
        Description = null,
        IsActive = false,
        CreatedDate = DateTime.Now
    };
    result.Add(blank);

    var dataService = new MyDataService();
    foreach (var c in await retrieveStatusesAction(dataService))
        result.Add(c);

    // TODO Implement Expression<Func<TSource, TResult>> projection for assigning to VM
    StatusVm = result.SingleOrDefault(c => c.StatusId.Equals(-1));

    return result;
}

然后你可以这样调用这个方法：

GetStatuses((service) => service.GetMro());

我没有对此进行测试，需要使用表达式编译来分配 StatusVm。我现在将看看如何做到这一点，但想法就在那里。

对于表达式和属性分配： Property selector Expression<Func<T>>. How to get/set value to selected property

-- 编辑--

VM 分配是这样的：

    public static async Task<ObservableCollection<T>> GetStatuses<T, TContainer>(
        TContainer instance,
        Expression<Func<TContainer, T>> viewModelProjection,
        Func<MyDataService, Task<IEnumerable<T>>> retrieveStatusesAction)
        where T : IStatusViewModel, new()
    {
        var result = new ObservableCollection<T>();
        var blank = new T
        {
            StatusId = -1,
            Status = null,
            Description = null,
            IsActive = false,
            CreatedDate = DateTime.Now
        };
        result.Add(blank);

        var dataService = new MyDataService();
        foreach (var c in await retrieveStatusesAction(dataService))
            result.Add(c);

        var vmStatus = result.SingleOrDefault(c => c.StatusId.Equals(-1));

        // Warning: Check casted values, this is unsafe
        var vm = (PropertyInfo)((MemberExpression)viewModelProjection.Body).Member;
        vm.SetValue(instance, vmStatus, null);

        return result;
    }

然后你会像这样调用方法：

await GetStatuses(this, inst => inst.MroVm, (service) => service.GetMro());

如果你不熟悉表达式，我会解释。 第一个参数是视图模型实例所在的对象。第二个参数从该对象中选择与需要更改的视图模型相对应的属性。最后一个参数是函数，它接受服务并返回检索状态的适当方法 - 这就像 C++ 中指向函数的指针。

这将编译，但不确定它是否会按预期运行。它应该。如果有问题，请写在cmets中。

Answer 2

您可以定义接口并尝试 Strategy 和 Factory 的组合，如下所示（为简单起见，我跳过了 async/await）：

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Starting");
        var mainVm = new MainViewModel();
        mainVm.GetStatuses();
        mainVm.GetMro();

        Console.WriteLine("Status: {0} {1}", mainVm.StatusVm.Name, mainVm.StatusVm.CreateDate);
        Console.WriteLine("MroVm: {0} {1}", mainVm.MroVm.Name, mainVm.MroVm.CreateDate);
    }
}

public class MainViewModel
{
    public StatusViewModel StatusVm { get; set; }
    public MroViewModel MroVm { get; set; }

    public void GetStatuses()
    {
        var result =  Get(VmKind.Status);
        StatusVm = result.SingleOrDefault(c => c.StatusId.Equals(-1)) as StatusViewModel;
    }
    public void GetMro()
    {
        var result = Get(VmKind.Mro);
        MroVm = result.SingleOrDefault(c => c.StatusId.Equals(-1)) as MroViewModel;
    }

    public IEnumerable<IVm> Get(VmKind vmKind)
    {
        var dataService = new MyDataService();
        return dataService.Get(vmKind);
    }


}

public interface IVm
{
    int StatusId { get; set; }
    DateTime CreateDate { get; set; }
    string Name { get; }
}

public class StatusViewModel : IVm
{
    public DateTime CreateDate { get; set; }
    public int StatusId { get; set; }
    public string Name { get { return "StatusViewModel"; } }
}

public class MroViewModel : IVm
{
    public DateTime CreateDate { get; set; }
    public int StatusId { get; set; }
    public string Name { get { return "MroViewModel"; } }
}

public enum VmKind    {Status, Mro }

#region Strategy

public interface IDataGetter
{
    IEnumerable<IVm> Get(VmKind vmKind);
}

public class MyDataService : IDataGetter {
    public IEnumerable<IVm> Get(VmKind vmKind)
    {
        switch (vmKind)
        {
            case VmKind.Status:
                return GetStatuses();
                //break;
            case VmKind.Mro:
                return GetMro();
                //break;
            default:
                throw new ArgumentException("Unknown VM type");
        }
    }

    private IEnumerable<IVm> GetMro()
    {
        return new List<MroViewModel> {
            new MroViewModel { StatusId = -1, CreateDate = DateTime.Now },
            new MroViewModel { StatusId = 2, CreateDate = DateTime.Now }
        };
    }

    private IEnumerable<StatusViewModel> GetStatuses()
    {
        return new List<StatusViewModel> {
            new StatusViewModel { StatusId = -1, CreateDate = DateTime.Now },
            new StatusViewModel { StatusId = 2, CreateDate = DateTime.Now }
        };
    }
}
#endregion

#region Factory
public class VmFactory {
    static IVm Create(VmKind vmKind)
    {
        IVm result = null;
        switch (vmKind)
        {
            case VmKind.Status:
                result = new StatusViewModel { StatusId = -1, CreateDate = DateTime.Now };
                break;
            case VmKind.Mro:
                result = new MroViewModel { StatusId = -1, CreateDate = DateTime.Now };
                break;
            default:
                throw new ArgumentException("Unknown VM type");
                //break;
        }
        return result;
    }
}
#endregion

我实际上并没有在这里使用 Factory，但您可以使用它来轻松创建 VM。