c＃編程代碼優化

Question

我有大約20個類從ConvertApi類派生。每個班級從父母班級分享Convert方法，並擁有獨特的屬性SupportedFiles。我使用這些類的文件操作和我的代碼看起來像

if (fileEx=="txt") 
    new Text2Pdf().Convert(file) 
else 
    if (fileEx=="doc") 
    new Word2Pdf().Convert(file) 
    else 
    //and so on.. 

我知道，因爲20倍if運營商重複這看起來糟透了，這些代碼可以優化，但無法找到一個方法來做到這一點。任何人都可以幫我嗎？

class Text2Pdf : ConvertApi 
{ 
    enum SupportedFiles { txt, log }; 
} 

class Word2Pdf : ConvertApi 
{ 
    enum SupportedFiles { doc, docx }; 
} 

class Excel2Pdf : ConvertApi 
{ 
    enum SupportedFiles { xls, xlsx }; 
} 

class ConvertApi 
{ 
public void Convert(....); 
} 

Answer 1

在你的基類，有這樣的事情：

public abstract class ConvertApi 
{ 
    protected abstract string[] SupportedFilesImpl(); 

    public bool Supports(string ext) 
    { 
     return SupportedFilesImpl.Contains(ext); 
    } 
} 

現在，您的派生類可以實現此方法：

public class Text2PDF : ConvertApi 
{ 
    protected override string[] SupportedFilesImpl { return new string[] { "txt", "log"}; } 
} 

public class Doc2PDF : ConvertApi 
{ 
    protected override string[] SupportedFilesImpl { return new string[] { "doc", "docx"}; } 
} 

...等的轉換器的其餘部分。然後把這些在列表...

List<ConvertApi> converters = new List<ConvertApi>(); 
converters.Add(new Text2PDF()); 
converters.Add(new Doc2PDF()); 

（注意，我可能有一個包含這些，而不僅僅是一個列表的一類，但無論如何）。現在，找到一個轉換器：

foreach(ConvertApi api in converters) 
{ 
    if(api.Supports(fileExt)) 
    { 
     // woo! 
     break; 
    } 
} 

Answer 2

怎麼樣使用switch？

switch(fileEx){ 
    case "txt": new Text2Pdf().Convert(file); break; 
    case "doc": new Word2Pdf().Convert(file); break; 
} 

Answer 3

使用依賴注入，您可以在類的構造函數中傳遞支持的文件。

Answer 4

假設每個轉換器是無狀態的，這聽起來像你只是想要一個Dictionary<string, ConvertApi>：

private static readonly Dictionary<string, ConvertApi> ConverterByType = 
    new Dictionary<string, ConvertApi> 
{ 
    { "txt", new Text2PdfConverter() }, 
    { "doc", new Word2PdfConverter() }, 
    ... 
}; 

... 

ConvertApi converter; 
if (!ConverterByType.TryGetValue(fileEx, out converter)) 
{ 
    // No converter available... do whatever 
} 
else 
{ 
    converter.Convert(file); 
} 

（字典初始化最終將建立多個轉換器比你真的需要支持多個分機任何轉換，但是這另當別論）

如果你需要一個新的轉換器每一次，使之成爲Dictionary<string, Func<ConvertApi>>並填充它。

{ "txt",() => new Text2PdfConverter() }, 
{ "doc",() => new Word2PdfConverter() }, 

...然後在需要時調用委託來獲取轉換器。

當然，這將所有的初始化放在一個地方 - 您可能需要一種方法，讓轉換器到的寄存器他們可以通過某種類型的「轉換器提供者」瞭解的擴展名。

Answer 5

您需要在這裏使用abstract factory pattern。所有的文本轉換器應該來自實現你的Convert方法的通用接口ITextConverter。文件擴展名將是您工廠的參數。下面是一個示例（鍵入「即時」，有時從源代碼複製粘貼代碼，因此可能會出現拼寫錯誤。此處的目標是爲您提供靈活實現的一般想法）。

public interface IFileConverter 
{ 
    bool Convert(string filePath); 
} 


public static class FileConverterFactory 
{ 
    public static IFileConverter Create(string extension) 
    { 
     extension = type.ToUpper(); 

     Dictionary<string, ConverterConfig> availableConverters = GetConvertersConfig(); 

     if (!availableConverters.ContainsKey(extension)) 
      throw new ArgumentException(string.Format("Unknown extenstion type '{0}'. Check application configuration file.", extension)); 

     ConverterConfig cc = availableConverters[extension]; 
     Assembly runnerAssembly = Assembly.LoadFrom(cc.Assembly); 
     Type converterType = runnerAssembly.GetType(cc.Class); 

     IFileConverter converter = (IFileConverter) Activator.CreateInstance(converterType); 

     return converter; 
    } 


    private static Dictionary<string, ConverterConfig> GetConvertersConfig() 
    { 
     var configs = (Dictionary<string, ConverterConfig>) ConfigurationManager.GetSection("ConvertersConfig"); 

     return configs; 
    } 
} 


public class ConvertersConfigHandler : IConfigurationSectionHandler 
{ 
    public object Create(object parent, object configContext, XmlNode section) 
    { 
     Dictionary<string, ConverterConfig> converters = new KeyedList<string, ConverterConfig>(); 
     XmlNodeList converterList = section.SelectNodes("Converter"); 

     foreach (XmlNode converterNode in converterList) 
     { 
      XmlNode currentConverterNode = converterNode; 

      ConverterConfig cc = new ConverterConfig(); 
      cc.Type = XML.GetAttribute(ref currentConverterNode, "Type").ToUpper(); 
      cc.Assembly = XML.GetAttribute(ref currentConverterNode, "Assembly"); 
      cc.Class = XML.GetAttribute(ref currentConverterNode, "Class"); 

      converters[cc.Type] = cc; 
     } 

     return converters; 
    } 
} 


public class ConverterConfig 
{ 
    public string Type = ""; 
    public string Assembly = ""; 
    public string Class = ""; 
} 


public class TextConverter : IFileConverter 
{ 
    bool Convert(string filePath) { ... } 
} 


public class PdfConverter : IFileConverter 
{ 
    bool Convert(string filePath) { ... } 
} 

在您的應用中。配置文件，您添加到了configSections：

<section name = "ConvertersConfig" type = "ConvertersConfigConfigHandler, MyAssembly" /> 

，這下面你configSections：

<ConvertersConfig> 
    <Converter Type="txt" Assembly="MyAssembly" Class="MyAssembly.TextConverter" /> 
    <Converter Type="pdf" Assembly="MyAssembly" Class="MyAssembly.PdfConverter" /> 
</ConvertersConfig> 

然後調用會是這樣的：

IFileConverter converter = FileConverterFactory.Create("txt"); 
converter.Convert("c:\temp\myfile"); 

編輯的代碼給了一個更「通用」的解決方案。

Answer 6

更慢，但更動態...使用對象工廠。這是一篇很好的文章，似乎符合您的需求。

http://www.codeproject.com/Articles/12986/Generic-Object-Factory

從文章的重要的東西：

using System.Collections.Generic; 

public struct Factory < KeyType, GeneralProduct > 
{ 
    //Register a object with the factory 
    public void> Register<SpecificProduct>(KeyType key) 
     where SpecificProduct : GeneralProduct, new() 
    { 
     if(m_mapProducts == null) 
       { 
      m_mapProducts = new SortedList< KeyType, CreateFunctor >(); 
     } 
     CreateFunctor createFunctor = Creator<SpecificProduct>; 
     m_mapProducts.Add(key, createFunctor); 
    } 

    //Create a registered object 
    public GeneralProduct Create(KeyType key) 
    { 
     CreateFunctor createFunctor = m_mapProducts[ key ]; 
     return createFunctor(); 
    } 

    private GeneralProduct Creator <SpecificProduct>() 
     where SpecificProduct : GeneralProduct, new() 
    { 
     return new SpecificProduct(); 
    } 

    private delegate GeneralProduct CreateFunctor(); 

    private SortedList<KeyType, CreateFunctor> m_mapProducts; 
} 

用法：

class Fruit 
{ 
} 

class Apple : Fruit 
{ 
} 

class Orange : Fruit 
{ 
} 

class TestClass 
{ 
    static void Main(string[] args) 
    { 
     General.Factory< string, Fruit > factory; 

     //Register 
     factory.Register<Apple>("Apple"); 
     factory.Register< Orange>("Orange"); 

     //Create 
     Fruit fruit1 = factory.Create("Apple"); 
     Fruit fruit2 = factory.Create("Orange"); 
    } 
} 

Answer 7

1. C＃支持switch-case操作字符串，也就是說，如果你改變你的類的名稱對應於支持的擴展，那麼你將能夠建立他們使用反射，這樣的（錯誤代碼coud被改寫爲

   switch (fileEx) 
   { 
       case "txt" : new Text2Pdf().Convert(file); break; 
       case "doc": new Word2Pdf().Convert(file); break; 
       ... 
   } 
   

2. 檢查略去了）：

   var t = Type.GetType(fileEx + "2Pdf"); 
       var tConstructor = t.GetConstructor(Type.EmptyTypes); 
       var tInstance = tConstructor.Invoke(new object[0]); 
       ((ConvertApi)tInstance).Convert(...); 
   

這可能需要一些額外的工作（即爲每個擴展創建一個單獨的類，從某些基類中派生它們 - 例如Doc2Pdf和Docx2Pdf都來自Word2Pdf）。

好處是您不必再觸摸這部分代碼。如果您打算爲插件編寫一些界面，那麼它可能會派上用場。

上面的代碼還假定您的ConvertApi類都具有默認無參數構造函數。

Answer 8

你可以使用一些反思：

ConvertApi FindMatchingConverter(string _FileExt) 
     { 
      //Get all the converters available. 
      List<ConvertApi> converters = this.GetType() 
              .Assembly 
              .GetExportedTypes() 
              .Where(type => type.IsAssignableFrom(typeof(ConvertApi))) 
              .ToList(); 

      //Loop and find which converter to use 
      foreach (var converter in converters) 
      { 
       if (converter.SupportedFiles.Contains(_FileExt)) 
        return Activator.CreateInstance(converter); 
      } 
      throw new Exception("No converter found"); 
     } 

然後你只需要調用Convert()在ConvertApi返回。
當然，這需要您在您的基類中添加一個名爲SupportedFiles的virtual List<String>。

這使它看起來像

public abstract class ConvertApi 
{ 
    public abstract void Convert(); 

    public virtual List<String> SupportedFiles {get;set;} 
}