Question

您好，我可以帮助我减少C＃中的代码吗？我有很多这样的功能我想减少一个带参数函数的函数的代码，稍后我会发送它。

    public void WriteTransportCurrectCategoryTypes()
    {
        var jStr = GetJSONString("GetBusTypes");
        var jArr = JArray.Parse(jStr);
        var tTypes = new List<TransportCurrentCategoryType>();
        foreach (dynamic d in jArr)
        {
            var tType = new TransportCurrentCategoryType();
            ParseTransportCurrentCategoryType(tType, d);
            tTypes.Add(tType);
        }
    }

    public void WriteBusModelSpecs()
    {
        var jStr = GetJSONString("GetBusModelSpecs");
        var jArr = JArray.Parse(jStr);
        var specs = new List<Characteristic>();
        foreach (dynamic d in jArr)
        {
            var spec = new Characteristic();
            ParseBusModelSpecs(spec, d);
            specs.Add(spec);
        }
    }

我尝试将委托与Generic一起使用，但它不起作用

    public delegate void ParseParameters<T>(T objectClass,dynamic a);
    private static void ParceBusClass(BusClass busClass,dynamic a)
    {
        busClass.Name = a.Name;
        busClass.Transport = new TransportCategory {Id = a.BusModelCategoryId};
    }

然后我称之为：

     GetCollectionFromJSON<BusClass>("", ParceBusClass);
       private static List<T> GetCollectionFromJSON<T>(string functionName,                       ParseParameters<T> parseFunk){
    /****/
     parseFunk<T>(busClass, a);
    /***/
     }

需要错误，

Answer 1

通常，您可以使用以下内容：

public List<T> Write<T>(string name, Func<T> factory, Action<T, dynamic> parser)
{
    var jStr = GetJSONString(name);
    var jArr = JArray.Parse(jStr);
    var result = new List<T>();
    foreach (dynamic d in jArr)
    {
        var item = factory();
        parser(item, d);
        result.Add(item);
    }
    return result;
}

你会这样称呼：

Write<Characteristic>(
    "GetBusModelSpecs", () => new Characteristic(), ParseBusModelSpecs);
Write<TransportCurrentCategoryType>(
    "GetBusTypes", () => new TransportCurrentCategoryType(),
    ParseTransportCurrentCategoryType);

如果您的大多数或所有类都有默认构造函数，您可以通过提供重载来缩短它：

public List<T> Write<T>(string name, Action<T, dynamic> parser)
    where T : new()
{
    return Write<T>(name, () => new T(), parser);
}

现在你可以这样称呼它：

Write<Characteristic>("GetBusModelSpecs", ParseBusModelSpecs);
Write<TransportCurrentCategoryType>(
    "GetBusTypes" ,ParseTransportCurrentCategoryType);

这个答案没有考虑到使用JSON库可能存在更好的方法。有关示例，请参阅I4V的评论。

Answer 2

使用factory method创建通用抽象父类Writer以解析json：

public abstract class Writer<T>        
{
    private readonly string _url;

    public Writer(string url)
    {
        _url = url;            
    }

    public void Write()
    {
        var jStr = GetJSONString(_url);
        var jArr = JArray.Parse(jStr);
        var tTypes = new List<T>();

        foreach (dynamic d in jArr)            
            tTypes.Add(Parse(d));           
        // other logic here            
    }

    protected abstract T Parse(object d); // implemented by concrete writers

    private string GetJSONString(string url)
    {
        // getting json string here
    }
}

然后为要处理的每个类型创建concreate子类（它们应指定用于加载JSON的url并覆盖抽象Parse方法）：

public class TransportCurrectCategoryWriter : Writer<TransportCurrectCategory>
{
    public TransportCurrectCategoryWriter()
        : base("GetBusTypes")
    {
    }

    protected override TransportCurrectCategory Parse(object d)
    {
        // parse TransportCurrectCategory and return parsed instance
    }
}

用法：

var writer = new TransportCurrectCategoryWriter();
writer.Write();

没有重复的代码。易于阅读和理解。

使用Generic委托或以其他方式减少代码

2 个答案: