将带有键值属性的对象[]映射到对象's属性，而不使用巨大的讨厌的切换

本文关键字：属性 对象 巨大 讨厌 键值 映射 | 更新日期: 2023-09-27 18:09:25

我有一个Key值的对象数组。

public class KeyValueStore
{
   public string Key {get;set;}
   public string Value {get;set;}
}

这个数组存储了一个对象的值，我试图像这样填充:

public class Customer
{
   public string Name {get;set;}
   public string Country {get;set}
}

所以我想映射这些键从KeyValueStore到客户属性

public Customer TransformToCustomer(KeyValueStore[] keyValueStore)
{
    var customer = new Customer();
    foreach (var keyValue in keyValueStore)
    {
        switch (keyValue.Key)
        {
            case "Name":
                customer.Name = keyValue.Value;
                break;
            case "Cntry":
                customer.Country = keyValue.Value;
                break;
        }
    }
    return customer;
}

有更好的方法吗?

将带有键值属性的对象[]映射到对象's属性，而不使用巨大的讨厌的切换

是的，假设目标类型有一个无参数的构造函数，您可以编写一个泛型方法来完成以下工作:

public T CreateAndPopulate<T>(IEnumerable<KeyValueStore> propStore,
                              IDictionary<string, string> mapping = null) 
                             where T:class,new()
{
    T item=new T();
    var type=typeof(T);
    foreach(var kvs in propStore)
    {
        var propName = kvs.Key;
        propName = mapping !=null && mapping.ContainsKey(propName) 
                       ? mapping[propName] 
                       : propName;
        var prop = type.GetProperty(propName);
        if(prop == null) //does the property exist?
        {
            continue;
        }
        var propMethodInfo = prop.GetSetMethod();
        if(propMethodInfo == null) //does it have a set method?
        {
            continue;
        }
        propMethodInfo.Invoke(item, new[]{ kvs.Value });
    }
    return item;
}

并使用:

IEnumerable<KeyValueStore> propStore = new KeyValueStore[]{
    new KeyValueStore{ Key = "Name", Value = "John" },
    new KeyValueStore{ Key = "Cntry", Value = "UK" }};
var mapping = new Dictionary<string,string>{{ "Cntry", "Country" }};
var customer = CreateAndPopulate<Customer>(propStore, mapping);

我还有另一个建议，很多时候大的开关块表明你在对象设计中缺少了一些东西，适当使用多态性可以代替开关的使用。

首先，我们将重新设计KeyValueStore类来分离ValueStore类，每个ValueStore类将实现公共接口IValueStore，接口看起来像这样:

public interface IValueStore
{
    void AddValueToCostumer(Customer customer);
}

现在NameValueStore看起来像这样:

public class NameValueStore : IValueStore
{
    private readonly string _name;       
    public NameValueStore(string name)
    {
        _name = name;
    }
    public void AddValueToCustomer(Costumer costumer)
    {
        customer.Name = _name;
    }
}

和CountryValueStore: 

public class CountryValueStore : IValueStore
{
    private readonly string _country;       
    public CountryNameValueStore(string country)
    {
        _country = country;
    }
    public void AddValueToCustomer(Costumer costumer)
    {
        customer.Country = _country;
    }
}

现在你的TransformToCustomer函数看起来像这样:

public Customer TransformToCustomer(IValueStore[] valueStores)
{
    var customer = new Customer();
    foreach (var valueStore in valueStores)
    {
        valueStore.AddValueToCustomer(customer);
    }
    return customer;
}

我觉得这个解决方案更可靠。

希望有帮助!

相关文章：