如何使用抽象类创建通用列表？

Question

我有一个 Json 类“GetAllDevices()”。我的 JSON 响应由一个对象数组/列表组成，其中每个对象都具有以下常见属性。

public class GetAllDevices
{
    [JsonProperty("_id")]
    public string Id { get; set; }

    [JsonProperty("name")]
    public string Name { get; set; }

    [JsonProperty("type")]
    public string Type { get; set; }

    [JsonProperty("actions")]
    public Action[] Actions { get; set; }

    public class Action
    {
        public string _id { get; set; }
        public Action_Def action_def { get; set; }
    }

    public class Action_Def
    {
        public string _id { get; set; }
        public string name { get; set; }
    }
}

我想创建 2 个通用列表，其中包含基于其“类型”的所有上述属性。 lstfoo1 列表包含 type="foo1" 的所有属性（_id、名称类型和操作）。同样，lstfoo2 是一个 List，其中包含上述属性，其中 type="foo2"。

到目前为止我做了什么：

string strJson=getJSON();
Foo1 lstfoo1=new Foo1();
Foo2 lstfoo2=new Foo2();
List<Foo1> foo1list= lstfoo1.GetDeviceData(strJson);
List<Foo2> foo2list = lstfoo2.GetDeviceData(strJson);


public class AllFoo1: GetAllDevices
{
}

public class AllFoo2: GetAllDevices
{
}

public abstract class HomeDevices<T>
{
    public string type { get; set; }
    public string _id { get; set; }
    public List<AllFoo1> lstfoo1{ get; set; }
    public List<AllFoo2> lstfoo2{ get; set; }
    public abstract List<T> GetDeviceData(string jsonResult);
}

public class Foo1: HomeDevices<AllFoo1>
{
    public Foo1()
    {
        type = "foo1";
    }

    public override List<AllFoo1> GetDeviceData(string jsonResult)
    {
        var lst =Newtonsoft.Json.JsonConvert.DeserializeObject<List<AllFoo1>>(jsonResult);
        var lst1 = lst.Where(x => x.Type.Equals(type)).ToList();
        return lst1;
    }
}

public class Foo2: HomeDevices<AllFoo2>
{
    public Foo2()
    {
        type = "foo2";
    }

    public override List<AllFoo2> GetDeviceData(string jsonResult)
    {
        var lst = Newtonsoft.Json.JsonConvert.DeserializeObject<List<AllFoo2>>(jsonResult);
        var lst1 = lst.Where(x => x.Type.Equals(type)).ToList();
        return lst1;
    }
}

我的问题是，有没有更简单的方法可以使用抽象类来做到这一点？我可以直接将我的“GetAllDevices”类转换为抽象类并继承它并反序列化并创建一个通用列表吗？

Answer 1

如果我正确理解您的问题，这应该会有所帮助。让我知道您是否有任何问题或它不能按您的需要工作。我很快就把它组装好了，没有经过测试。

Type 属性的定义方式可以改进，但我保留了它。

public class MyApplication
{
    public void DoWork()
    {
        string json = getJSON();
        DeviceTypeOne foo1 = new DeviceTypeOne();
        DeviceTypeTwo foo2 = new DeviceTypeTwo();
        IList<DeviceTypeOne> foo1Results = foo1.GetDeviceData(json); // calls GetDeviceData extension method
        IList<DeviceTypeTwo> foo2Results = foo2.GetDeviceData(json); // calls GetDeviceData extension method
    }        
}

// implemented GetDeviceData as extension method of DeviceBase, instead of the abstract method within DeviceBase,
// it's slightly cleaner than the abstract method
public static class DeviceExtensions
{
    public static IList<T> GetDeviceData<T>(this T device, string jsonResult) where T : DeviceBase
    {
        IEnumerable<T> deviceDataList = JsonConvert.DeserializeObject<IEnumerable<T>>(jsonResult);
        IEnumerable<T> resultList = deviceDataList.Where(x => x.Type.Equals(typeof(T).Name));
        return resultList.ToList();
    }
}

// abstract base class only used to house common properties and control Type assignment
public abstract class DeviceBase : IDeviceData
{
    protected DeviceBase(string type)
    {
        if(string.IsNullOrEmpty(type)) { throw new ArgumentNullException(nameof(type));}

        Type = type; // type's value can only be set by classes that inherit and must be set at construction time
    }
    [JsonProperty("_id")]
    public string Id { get; set; }
    [JsonProperty("name")]
    public string Name { get; set; }
    [JsonProperty("type")]
    public string Type { get; private set;} 
    [JsonProperty("actions")]
    public DeviceAction[] Actions { get; set; }
}

public class DeviceTypeOne : DeviceBase
{
    public DeviceTypeOne() : base(nameof(DeviceTypeOne))
    {
    }
}

public class DeviceTypeTwo : DeviceBase
{
    public DeviceTypeTwo() : base(nameof(DeviceTypeTwo))
    {
    }
}

// implemented GetAllDevices class as IDeviceData interface
public interface IDeviceData
{
    string Id { get; set; }
    string Name { get; set; }
    string Type { get; }
    DeviceAction[] Actions { get; set; }
}

// renamed and relocated class Action to DeviceAction
public class DeviceAction
{
    public string Id { get; set; }
    public DeviceActionDefinition DeviceActionDefinition { get; set; }
}

// renamed and relocated Action_Def to DeviceActionDefinition
public class DeviceActionDefinition
{
    public string Id { get; set; }
    public string Name { get; set; }
}

Answer 2

将方法GetDeviceData()的实现移动到基类应该足够简单。

为此，您需要在T 上添加一个约束，以便编译器了解更多关于基本类型的信息。您还需要实现一个构造函数来填充您使用的具体类型的type 字符串。这是确保在相关方法中用于比较时始终填充该值的必要措施：

public abstract class HomeDevices<T> where T: GetAllDevices
{
    public HomeDevices(string concreteType)
    {
        type = concreteType;
    }

    public string type { get; set; }
    public string _id { get; set; }
    public List<AllFoo1> lstfoo1 { get; set; }
    public List<AllFoo2> lstfoo2 { get; set; }

    //This method is now generic and works for both.
    public List<T> GetDeviceData(string jsonResult)
    {
        var lst = Newtonsoft.Json.JsonConvert.DeserializeObject<List<T>>(jsonResult);
        var lst1 = lst.Where(x => x.Type.Equals(type)).ToList();
        return lst1;
    }
}

希望对你有帮助。