如何从配置文件重构高度重复的阅读部分

Question

我需要将配置文件的多个部分转换为字典。这些字典的价值有不同的类型。以下两类工作，但他们几乎是相同的：

public class IntConfigSection 
{ 
    private static readonly ILog Log = LogManager.GetLogger(typeof(IntConfigSection)); 
    public static Dictionary<String, int> LoadSection(string sectionName) 
    { 
     var ret = new Dictionary<String, int>(); 
     try 
     { 
      var offsetsHash = (Hashtable)ConfigurationManager.GetSection(sectionName); 
      foreach (DictionaryEntry entry in offsetsHash) 
      { 
       ret.Add((String)entry.Key, int.Parse((String)entry.Value)); 
      } 
     } 
     catch(Exception e) 
     { 
      Log.ErrorFormat("LoadSection:" + e); 
     } 
     return ret; 
    } 
} 

public class StringConfigSection 
{ 
    private static readonly ILog Log = LogManager.GetLogger(typeof(StringConfigSection)); 
    public static Dictionary<String, String> LoadSection(string sectionName) 
    { 
     var ret = new Dictionary<String, String>(); 
     try 
     { 
      var offsetsHash = (Hashtable)ConfigurationManager.GetSection(sectionName); 
      foreach (DictionaryEntry entry in offsetsHash) 
      { 
       ret.Add((String)entry.Key, (String)entry.Value); 
      } 
     } 
     catch (Exception e) 
     { 
      Log.ErrorFormat("LoadSection:" + e); 
     } 
     return ret; 
    } 
} 

要求下面的代码不能正常工作，但它证明了什么，我试图完成：

public class ConfigSection<T> 
{ 
    private static readonly ILog Log = LogManager.GetLogger(typeof(StringConfigSection)); 
    public static Dictionary<String, T> LoadSection(string sectionName) 
    { 
     var ret = new Dictionary<String, T>(); 
     try 
     { 
      var offsetsHash = (Hashtable)ConfigurationManager.GetSection(sectionName); 
      foreach (DictionaryEntry entry in offsetsHash) 
      { 
       //builds but does not always do what I want 
       ret.Add((String)entry.Key, (T)entry.Value); 
       // does not compile 
       //ret.Add((String)entry.Key, T.Parse((String)entry.Value)); 
      } 
     } 
     catch (Exception e) 
     { 
      Log.ErrorFormat("LoadSection:" + e); 
     } 
     return ret; 
    } 
} 

编辑：我的最终版本看起来如下：

public class ConfigSectionLoader 
{ 
    public static Dictionary<String, int> LoadIntSection(string sectionName) 
    { 
     return ConfigSection<int>.LoadSection(sectionName, int.Parse); 
    } 

    public static Dictionary<String, String> LoadStringSection(string sectionName) 
    { 
     return ConfigSection<String>.LoadSection(sectionName, val => val); 
    } 
} 

internal class ConfigSection<T> 
{ 
    private static readonly ILog Log = LogManager.GetLogger(typeof(StringConfigSection)); 
    internal static Dictionary<String, T> LoadSection(string sectionName, Func<String, T> parseFunc) 
    { 
     var ret = new Dictionary<String, T>(); 
     try 
     { 
      var hash = (Hashtable)ConfigurationManager.GetSection(sectionName); 
      foreach (DictionaryEntry entry in hash) 
      { 
       ret.Add((String)entry.Key, parseFunc((String)entry.Value)); 
      } 
     } 
     catch (Exception e) 
     { 
      Log.ErrorFormat("LoadSection:" + e); 
     } 
     return ret; 
    } 
} 

我唯一关心的是：val => val最简单的lambda什么也不做？

Answer 1

你可以传递一个函数， ES该类型解析：（注：未经测试的代码，认为这是一个想法，而不是工作代码：d）

public class ConfigSection<T> 
{ 
    private static readonly ILog Log = LogManager.GetLogger(typeof(StringConfigSection)); 
    public static Dictionary<String, T> LoadSection(string sectionName, Func<String,T> parseFunc) 
    { 
     var ret = new Dictionary<String, T>(); 
     try 
     { 
      var offsetsHash = (Hashtable)ConfigurationManager.GetSection(sectionName); 
      foreach (DictionaryEntry entry in offsetsHash) 
      { 
       ret.Add((String)entry.Key, parseFunc((String)entry.Value)); 
      } 
     } 
     catch (Exception e) 
     { 
      Log.ErrorFormat("LoadSection:" + e); 
     } 
     return ret; 
    } 
} 

，然后传递到自己的实际解析器一个lambda（或类似的..）

或者你实际上可以将解析器包含在类的构造函数中，然后让它成为一个成员，所以你不必每次都传递它。

public class ConfigSection<T> 
{ 
    private Func<String, T> myParseFunc = null; 

    public ConfigSection<T>(Func<String,T> parParseFunc) 
    { 
     myParseFunc = parParseFunc; 
    } 

    private static readonly ILog Log = LogManager.GetLogger(typeof(StringConfigSection)); 
    public static Dictionary<String, T> LoadSection(string sectionName) 
    { 
     var ret = new Dictionary<String, T>(); 
     try 
     { 
      var offsetsHash = (Hashtable)ConfigurationManager.GetSection(sectionName); 
      foreach (DictionaryEntry entry in offsetsHash) 
      { 
       ret.Add((String)entry.Key, myParseFunc((String)entry.Value)); 
      } 
     } 
     catch (Exception e) 
     { 
      Log.ErrorFormat("LoadSection:" + e); 
     } 
     return ret; 
    } 
} 

，你可以把它像这样：

ConfigSection<int> = new ConfigSection<int>(int.Parse); 

Answer 2

我想提出以下几点建议：

public abstract class ConfigSectionBase<T> 
{ 
    public static Dictionary<String, T> LoadSection(string sectionName) 
    { 
     ... 
     //builds but does not always do what I want 
     ret.Add((String)entry.Key, Convert((string)entry.Value)); 
     ... 
    } 
    abstract T Convert(string v); 
} 

public class IntConfigSection: ConfigSectionBase<int> 
{ 
    override int Convert(string v) 
    { 
     return int.Parse(v); 
    } 
} 

public class StringConfigSection: ConfigSectionBase<string> 
{ 
    override string Convert(string v) 
    { 
     return v; 
    } 
} 

（声明：我没有尝试的代码）

编辑：
应该可以避免确定各类型的Convert功能单独使用Convert.ChangeType：

public abstract class ConfigSection<T> 
{ 
    public static Dictionary<String, T> LoadSection(string sectionName) 
    { 
     ... 
     //builds but does not always do what I want 
     ret.Add((String)entry.Key, 
       (T)Convert.ChangeType((string)entry.Value, typeof(T))); 
     ... 
    } 
} 

Answer 3

这是一个普遍的问题，你总是有一定程度的重复结束。诀窍是弄清楚你可以做出多少小小的重复以及你想要将其本地化。在这个特定的例子中，你可以：

1. 传递一个Func<string, T> parseMethod参数到你的泛型类的构造函数中。这允许您支持任何类型，甚至允许针对不同的配置节实例对相同类型进行不同的解析。
2. 获取类型的TypeConverter并尝试从字符串转换。
3. 要求类型支持IConvertible并将字符串转换为字符串。
4. 使用反射来查找类型上的静态Parse或TryParse方法。这并不理想，但BCL有使用类似hacky'魔术方法名称'的例子。