지옥 또는 수용 가능한 디자인?

Question

내가 case 문을 통해 반복해서 같은 일에 근접하고 있던 일부 레거시 코드 리팩토링 오전 :이

(SameInterfaceCast).SetProperties(Prop1,Prop2,Prop3); 

될 수 있도록 그래서

switch(identifier) 
    case firstIdentifier: 
     (SomeCast).SetProperties(Prop1,Prop2,Prop3); 
     break; 
    ... 
    case anotherIdentifier: 
     (SomeDifferentCast).SetProperties(Prop1, Prop2, Prop3); 
     break; 

을, 나는 고유의 인터페이스를 만들려고

그러나 일부 항목은 모든 속성을 사용하지 않는 것으로 나타났습니다. 그래서 나는 더 이런 일을 생각하기 시작했다 :

if(item is InterfaceForProp1) 
    (InterfaceForProp1).SetProp1(Prop1); 
if(item is InterfaceForProp2) 
    (InterfaceForProp2).SetProp2(Prop2); 
if(item is InterfaceForProp3) 
    (InterfaceForProp3).SetProp3(Prop3); 

하고이 같은 클래스를 만들 수 있습니다

public class MyClassUsesProp2And3 : InterfaceForProp2, InterfaceForProp3 

그러나, 내가 지나치게이 코드를 세분화하고 두렵다을하고 수 풍선 너무 많이. 어쩌면 본질적으로 하나의 방법 인터페이스가 될 것을 너무 두려워해서는 안되지만,이 길을 가기 전에 디자인 패턴을 놓치고 있는지 알고 싶습니다.

모든 속성이 고유 종류

UPDATE (꽤 권리 맞게 내 마음에 튀어하지만 있던 유일한 사람은 Decorator 또는 Composite 패턴이었다).

궁극적으로 이것은 의존성 주입의 한 형태입니다. 코드는 Ninject와 같은 것을 사용하기에는 너무 엉망이지만 나중에는 이들 중 일부를 없애고 주입 컨테이너를 사용할 수도 있습니다. 현재 변수를 설정하는 것 이상의 일을하는 논리가 있습니다. 이것은 모든 레거시 코드이며, 조금씩 조금씩 정리하려고하고 있습니다.

Answer 1

기본적으로 액터 (setProp 메소드로 유형)를 '액터'유형으로 만들고 속성 (prop1 ... n)에 'Prop'과 동일한 유형을 작성하려고합니다. 당신이 instanceof를, 내가 방문자 패턴으로 이동하는 것입니다 생각할 수있는 유일한 방법을 사용하지 않도록하려면이 '소유'방문자를 만드는

actor.setProp(prop) 

에 코드를 감소시킬 것이다. 내 인생을 더 편하게하기 위해 템플릿 방법을 사용합니다. Java에서는 (Prop의 두 실제 종류에 대해) 이렇게 보일 것입니다.

class Actor { 

    protected void set(Prop1 p1) { 
     // Template method, do nothing 
    } 

    protected void set(Prop2 p2) { 
     // Template method, do nothing 
    } 

    public void setProp(Prop p) { 
     p.visit(this); 
    } 

    public interface Prop { 
     void visit(Actor a); 
    } 

    public static Prop makeComposite(final Prop...props) { 
     return new Prop() { 

      @Override 
      public void visit(final Actor a) { 
       for (final Prop p : props) { 
        p.visit(a); 
       } 
      } 
     }; 
    } 

    public static class Prop1 implements Prop { 
     public void visit(Actor a) { 
      a.set(this); 
     } 
    } 

    public static class Prop2 implements Prop { 
     public void visit(Actor a) { 
      a.set(this); 
     } 
    } 
} 

이이 같은 물건을 수행 할 수 있습니다

ConcreteActor a = new ConcreteActor(); 
    Prop p = Actor.makeComposite(new ConcreteProp1(42), new ConcreteProp2(-5)); 
    a.setProp(p); 

을 ... 슈퍼 좋은이다!

Answer 2

"올바른 답변"이 있는지는 모르겠지만 여기에 내가 할 일이 있습니다.

class Properties { 
    prop1 
    prop2 
    prop3 
} 

interface PropertySetable { 
    setProperties(Properties prop); 
} 
public class MyClassUsesProp2And3 implements PropertySetable { 
    setProperties(Properties prop) { 
     //I know I need only 2 and 3 
     myProp2 = prop.prop2; 
     myProp3 = prop.prop3; 
    } 

} 

호출 함수에서는 캐스트가 없어야합니다.

someFunc(..., PropertySetable, Properties,...) { 
     PropertySetable.setProperties(Properties); 
} 

이것이 기본 구조입니다.

속성을 캡슐화해야합니다. 속성을 비공개로 만들고 관련 생성자를 사용해야합니다. 또는 Builder 패턴을 사용하여 Properties ... 및 더 많은 것을 빌드하십시오.

Answer 3

저는 처음부터 코드를 리팩터링하려는 이유에 따라 대답이 달라집니다.

• 스위치 블록을 완전히 없애려면 3 가지 인수를 취하는 하나의 방법으로 인터페이스를 구현해야합니다. 각 클래스는 어느 인수가 적용되는지, 그리고 그러한 인수를 어떻게 처리해야하는지 파악해야합니다.
• 전체 코드 양을 줄이려면 클래스 별 속성 설정 논리를 추가하는 것이 원래 switch 문보다 적다는 것을 확신하지 못합니다.
• 편집기의 코드 완성 기능을 이용하려면 속성의 정확한 수와 올바른 방법을 삽입/인수 후 바로 각 클래스의 올바른 방법 (들)을 구현하고 인터페이스를 피하기 모두

Answer 4

visitor pattern 당신이 switch 문에 직면 할 때 표준 용액이며, 형변환. 각 사례에 대한 코드는 방문자 클래스에서 별도의 메소드로 이동합니다. 그리고 클래스는 각각 하나의 인터페이스 만 구현합니다 - 방문자를 받아들이는 방법은 accept입니다. 지금까지했던 것보다 많은 코드로 끝나지 만, 훨씬 더 깨끗한 코드를 읽게 될 것입니다.