通用接口

Question

我正在设计一个应用程序，其中相似的实体位于两个具有不同类型集合的位置，如下所示。

模型：

class PersonModel {
  public string Name { get;set;}
  public List<Address> Addresses { get;}
  public List<OtherType> OtherTypes { get;}
}

类似的视图模型：

class PersonViewModel {
   public string Name { get;set;}
   public ObservableCollection<Address> Addresses { get; }
   public ObservableCollection<OtherType> OtherTypes { get; }
}

为了使两个实体保持一致，我认为使用通用接口来确保两者都实现所有属性，所以我创建了这样的东西：

public interface IPerson<T> where T: ICollection<T> {
   string Name { get;set;}
   T<Address> Addresses { get;}
   T<OtherType> OtherTypes [ get; } 
}

类将是，

class PersonModel<List> {}
class personViewModel<ObservableCollection> {}

但编译器尚未准备好编译我的接口。 :( 表示类型参数“T”不能与类型参数一起使用。

我想要这个的原因是，我想最小化从/到模型和模型的类型转换。视图模型。

我的 viewModel 将是这样的，

class PersonViewModel<T> : IPerson<T> {
   public PersonViewModel(IPerson model){
      this.Model = model;
   }
   internal PersonModel Entity {
      get; set;
   }
   public string Name { 
      get{ return model.Name;} 
      set {model.Name = value;}
   }
   public T<Address> Addresses {
      get { return model.Addresses.Cast<T>(); }
   }
}

建议我更好的方式来拥有 Model & ViewModel 已同步。

Answer 1

ViewModel 的存在是为了为 View 提供数据。这意味着它应该根据视图的要求进行建模。通常，这些要求与模型的要求不同。这意味着，通常情况下，您的模型和视图模型不会同步，它们会有所不同。在您的方法中，ViewModel 没有添加任何值，可以删除。

要在 ViewModel 和 Model 之间进行映射，您可以使用 AutoMapper。

Answer 2

您的实现应如下所示：

class PersonModel : IPerson<List> {}
class PersonViewModel : IPerson<ObservableCollection> {}

您真的需要一个泛型类吗？ ObservableCollection 和 List 都实现 ICollection，因此您可以在接口中将 Addresses 和 OtherTypes 声明为分别是 ICollection

和 ICollection。

（什么是AddressView？）

Answer 3

您不能以这种方式使用泛型。你可以尝试这样的事情

public interface IPerson
{
    string Name { get; set; }
    ICollection<Address> Addresses { get; }
    ICollection<OtherType> OtherTypes { get; }
}

public class OtherType { }
public class Address { }

然后

class PersonModel : IPerson
{
    public PersonModel()
    {
        Addresses = new List<Address>();
        OtherTypes = new List<OtherType>();
    }

    public string Name { get; set; }
    public ICollection<Address> Addresses { get; private set; }
    public ICollection<OtherType> OtherTypes { get; private set; }
}

class PersonViewModel : IPerson
{
    public PersonViewModel()
    {
        Addresses = new ObservableCollection<Address>();
        OtherTypes = new ObservableCollection<OtherType>();
    }

    public string Name { get; set; }
    public ICollection<Address> Addresses { get; private set; }
    public ICollection<OtherType> OtherTypes { get; private set; }
}

Answer 4

您对 IPerson 的通用约束是强制 T 必须实现 T 的 ICollection 吗？这是无限递归的，这是不允许的。

您也不能在泛型类型上指定泛型参数，因此不允许使用 T

，这是因为不知道 T 是泛型类型还是不是。

您可以将您的界面更改为以下内容：

public interface IPerson<TAddressCol, TOtherCol> 
   where TAddressCol: ICollection<Address>
   where TOtherCol : ICollection<OtherType> 
{
   string Name { get;set;}
   TAddressCol Addresses { get;}
   TAddressCol OtherTypes [ get; } 
}

然后像这样使用它：

class PersonModel<List<Address>, List<OtherType>> {}
class personViewModel<ObservableCollection<Address>, ObservableCollection<OtherType>> {}

我认为这是获得您想要的方法的唯一真正方法。但我建议您的接口仅返回 ICollection

和 ICollection。然后，您的模型/视图模型必须通过接口公开集合，但是没有什么可以阻止您分别将支持实现作为 List 或 ObservableCollection 。