Question

我有一些我正在尝试重写的代码。代码被设计为“通用”，因为它可以被需要不同“工作流程”的许多不同呼叫者使用。它是这样的：

string globalA;
int globalB;
bool globalC;
// Lots more globals in various shapes and forms

void TheOneAndOnlyMethod(XmlBasedConfig config) {

    // Set all of the globals based on XML configuration
    // ...

    if (globalA.Length > 0)
        // Do something relating to functionality 'a'
    }

    if (globalB > 0) {
        // Do something relating to functionality 'b'
    }

    if (globalC) {
        // You get the idea
    }
}

一些调用者将设置globalA和globalB，因此执行相关if块中的任何操作。其他呼叫者将有无数其他设置来做他们需要做的事情。调用者基本上只是一个带有设置的XML文件。

维护/修改此代码是一种大的痛苦。我知道必须有一个更清洁，更简单，更少大脑爆炸的方式来做到这一点！

Answer 1

它取决于您的XML文件结构。如果我可以单独访问A / B / C / ...我的c ++ / boost代码看起来像这样。

重构FunctionalityA类中的所有A相关内容，B函数B中的B相关内容，... FunctionalityProvider类是配置系统功能的类。 TheOneAndOnlyMethod向提供者询问所有功能并对其进行迭代。

class XmlFunctionality
{
public:
    virtual ~XmlFunctionality(){
    }
    virtual void loadFromConfig(XmlBasedConfig) = 0;
    virtual bool isEnabled() const = 0;
    virtual void execute() = 0; 

protected:
    XmlFunctionality(){
    };
}

class FunctionalityA : public XmlFunctionality
{
public:
    void loadFromConfig(XmlBasedConfig){
        // load A information from xml
    }
    bool isEnabled() const{
        return globalA.length()>0; // is A a global !?    
    }
    void execute(){
        // do you're a related stuff
    }
}

class FunctionalityB : public XmlFunctionality
{
public:
    void loadFromConfig(XmlBasedConfig){
        // load B information from xml
    }
    bool isEnabled() const{
        // when is b enabled ...    
    }
    void execute(){
        // do you're b related stuff
    }
}

// Map your question to the functions - 
class FunctionalityProvider
{
    Functionality functionalityList;
public:
    typedef std::vector<XmlFunctionality*> Functionality; 
    FunctionalityProvider() : functionalityList() {        
        functionalityList.push_back( new FunctionalityA);
        functionalityList.push_back( new FunctionalityB);
        functionalityList.push_back( ... );
    }

    ~FunctionalityProvider {        
        for_each( functionality.begin(), functionality.end(), delete_ptr() );
    }

    Functionality functionality() const {
        return functionalityList;
    }
}
void TheOneAndOnlyMethod(XmlBasedConfig config, const FunctionalityProvider& provider) {
    const FunctionalityProvider::Functionality functionality = provider.functionality();
    for_each( 
        functionality.begin(), 
        functionality.end(), 
        bind(&XmlFunctionality::loadFromConfig, _1, config)); // or some other way of parsing the file
    for_each( 
        functionality.begin(), 
        functionality.end(), 
        if_then( bind(&XmlFunctionality::isEnabled, _1), bind(&XmlFunctionality::execute, _1)));

}

如果我无法单独访问A / B / C，我会让解析器根据XML文件的内容撤回功能列表。

Answer 2

我首先将每个if语句转换为一个名称反映其功能的方法。然后，不是根据XML文件内容设置全局变量，而是解析文件并按顺序调用适当的方法，而不是通过变量进行通信。

Answer 3

您的方法的名称可以让您深入了解问题/解决方案：TheOneAndOnlyMethod。听起来你需要将代码分解成许多较小的方法，每个方法都处理非常特定的操作并且也可以重用。

string globalA;
int globalB;
bool globalC;
// Lots more globals in various shapes and forms

void TheOneAndOnlyMethod(XmlBasedConfig config) {
    // Set all of the globals based on XML configuration
    loadXmlAsGlobals(config);

    if (globalA.Length > 0)
        methodOne(globalA);
        methodTwo(globalA);
    }

    if (globalB > 0) {
        methodTwo(globalB);
        methodThree(globalB);
    }

    if (globalC) {
        methodOne(globalC);
        methodFour(globalC);
    }
}

重构重复的If语句块

3 个答案: