0

我有多个返回方法的AsyncTask doInBackground嵌套条件，这使得代码非常复杂有没有其他方法来处理这个问题StringonPostExectue

现在我的代码看起来像这样

protected String doInBackground(Void... params){
    if (position == 0){ 
         return "Set1" 
    }
    else if(Position >something) { 
         return set 2 
    } .........and so on 
}

@Override
protected void onPostExecute(String result) {
    if (result.equals("set1")){
       // do some taskk
    }
    elseif(result.equal("Set2")){
        // do other task
    }
    else if(){
       // sooo onnnnnn
     }
}

在此先感谢您的帮助

4

3 回答 3

1

可以尝试在此处应用策略模式。你可以创建一个抽象类，比如说Action，带有一个抽象函数perform()。Action然后，您可以为可以在 onPostExecute 中执行的每个操作创建具体的子类。所以你有类说ActionForSet1等ActinForSet2 具有perform（）的具体实现。然后Action应该有一个静态方法String Action createfromString(String set)，它与 if/else 或 break 基本相同，但更易于维护。它将为每个字符串返回相应的 Action 子类。您可以在那里使用 Map 而不是 if/else，这样更容易添加/删除元素。然后在你Action返回你的对象之后，Action.createFromString你调用它perform()

onPostExecute(String result) {
   Action a = Action.actionForResult(result);
   a.perform();
}

abstract class Action {
  abstract void perform();

  static Action actionForResult(String result) {
      if(result.equals("res1") {
          return new ActionForRes1();
      } else if(result.equals("res2") {
          return new ActionForRes2();
      } else throw new IllegalArgumentException("No action for result " + result);
   }
}

class ActionForResult1 extends Action {
  @Override
  void perform() { Log.i("ACTION", "Here's action for result 1"); }
}

class ActionForResult2 extends Action {
  @Override
  void perform() { Log.i("ACTION", "Here's action for result 2"); }
}
于 2012-09-26T06:09:26.580 回答
1

简化涉及条件的代码的一种很好的 OO 方法是通过策略模式 (http://en.wikipedia.org/wiki/Strategy_pattern) 替换它们。您可以在此处找到有关此特定重构的一些信息：http: //www.industriallogic.com/xp/refactoring/conditionalWithStrategy.html。

基本思想是用策略封装每个条件案例的逻辑，然后委托给策略实例。这会产生比嵌套 if/then/else 或 switch 语句更清晰的代码。

为了说明这一点，假设您有一个复杂的条件逻辑，例如：

Entity e = // some entity
if ("TypeOne".equals(e.getType()) {
  // process entity of type one...
} else if ("TypeTwo".equals(e.getType()) {
  // process entity of type two...
} else if ("TypeThree".equals(e.getType()) {
  // process entity of type three...
} else {
  // default processing logic
}

我们可以使用策略模式将其分解为不同的实体处理策略，而不是按程序编写这段逻辑。首先，我们需要定义一个接口，该接口将从所有实体处理策略中共享：

public interface EntityProcessingStrategy {
  public void process(Entity e);
}

然后我们为我们的每一个条件案例创建一个具体的策略实现，封装了具体的处理逻辑：

public class TypeOneEntityProcessingStrategy {
  public void process(Entity e) {
    // process entity of type one...
  }
}

public class TypeTwoEntityProcessingStrategy {
  public void process(Entity e) {
    // process entity of type two...
  }
}

public class TypeThreeEntityProcessingStrategy {
  public void process(Entity e) {
    // process entity of type three...
  }
}

public class DefaultEntityProcessingStrategy {
  public void process(Entity e) {
    // default entity processing logic...
  }
}

因此，我们之前的代码可以简化为删除条件，如下所示：

Entity e = // our entity that needs to be processed
EntityProcessingStrategy strategy = EntityProcessingStrategies.getStrategyFor(e.getType);
strategy.process(e);

请注意，在我的最后一个示例中，我包含了一个 EntityProcessingStrategies 类，该类用作具体策略的工厂。更具体地说，它可以是：

public final class EntityProcessingStrategies {

  private EntityProcessingStrategies() { }

  public EntityProcessingStrategy getStrategyFor(String type) {
    if ("TypeOne".equals(type)) return new TypeOneEntityProcessingStrategy();
    if ("TypeTwo".equals(type)) return new TypeTwoEntityProcessingStrategy();
    if ("TypeThree".equals(type)) return new TypeThreeEntityProcessingStrategy();
    return new DefaultEntityProcessingStrategy();
  }
}

这是创建具体策略实例的一种方法，但绝不是唯一的方法。

于 2012-09-26T06:44:28.933 回答
0

如果您只使用这种类型的流程，那么

if(){
}
else if(){
}
else if(){
}

然后替代方案是它们类型流的开关盒。您需要从 doInBackground() 以整数而不是 String 的形式返回，并在 switch 中使用整数值。

switch(result){
case 0:
    break;
case 1:
    break;
....
}

正如你在这里提到的嵌套。它不是真正的嵌套。嵌套的块之一也有 if 条件

if(){
}
else{
    if(){
    }
    else{
        if(){
        } and so on..
    }
}
于 2012-09-26T05:18:36.557 回答