어떻게</p> <pre><code>interface IFoo { void Do(); void Stuff(); } </code></pre> <p>이 (레거시) 클래스 FOO1, FOO2, Foo3 모든 IFoo가 구현하는 가정 해 봅시다 IFoo 인터페이스 주어

Question

완벽한 인터페이스를 만들기 위해 확장 방법을 사용합니다.

물건은 IFoo의 일부 방법을 사용하거나 더 새로운 클래스의 경우 DoStuff()를 사용하여 수행 할 수 있습니다. 사실, IFoo에서 DoStuff()가 "잊어 버린 것"처럼 보일 수 있습니다.

IFoo2를 구현 한 새로운 클래스 FooX (FooY, ...)가 있으며, 여기에는 DoStuff() 메서드가 있습니다.

IFoo 개체를 허용하고 해당 개체에 "할 일"을 할 수 있어야합니다.

//Let us assume foos = new IFoo[] {new Foo1(), new Foo2(), new Foo3(), new FooX()}; 

void MyMethod(IFoo[] foos){ 
    foreach(foo in foos){ 
     //DoStuff is not defined in IFoo 
     foo.DoStuff(); 
    } 
} 

그래서, 난 그냥도 FooX를 들어, 기존의 클래스

public static DoStuff(this IFoo self){ 
    self.Do(); 
    self.Stuff(); 
} 

불행하게도,이 확장 방법은 항상 호출

에 대한 IFoo에 확장 메서드 DoStuff()를 정의로 생각했다.

내가 그러나

public static DoSomeStuff(this IFoo self){ 
    if(self is IFoo2) { 
     (self as IFoo2).DoStuff() 
    } else { 
     self.Do(); 
     self.Stuff(); 
    } 
} 

void MyMethod(IFoo[] foos){ 
    foreach(foo in foos){    
     foo.DoSomeStuff(); 
    } 
} 

같은 일을 할 수 방법은 현재 아직, 레거시 프로젝트에 IFoo2 알고있는 MyMethod라는. IFoo2를 사용하지 않고도 해결책을 찾을 수 있습니까?

Answer 1

변수의 유형이 IFoo 인 경우 확장 방법 DoStuff이 호출됩니다. 이 문제를 해결하는 일반적인 방법은 마지막 단락에서 제안한 것 또는 최신 인터페이스 메서드를 호출 할 곳에서 IFoo 대신 IFoo2을 사용하도록하는 것입니다.

Answer 2

현재 구현하지 않은 클래스에 대해 Do 및 Stuff 메소드를 구현하는 추상 하위 클래스를 만들 수 있습니다. 당신이 다음이 추상 클래스

public class Foo: IFoo 
{ 
    // interface implementation required 
} 

becomes: 

public class Foo: abstractFoo 
{ 
    // interface implementation NOT required 
} 

Answer 3

에서 상속 할 수있는 경우

public abstract class abstractFoo : IFoo 
{ 
    public virtual void Do() {} 
    public virtual void Stuff(){} 
} 

당신은 그렇게, IFoo 인터페이스를 확장하지 않아야합니다. 그것은 Interface Segregation principle 휴식입니다.

이러한 개체가 코드에서 정확히 동일한 엔터티를 나타내면 다른 인터페이스를 사용하면 안됩니다. IFoo 인터페이스를 구현하지만 동일한 계약을 나타내는 두 번째 인터페이스를 만들지 않는 클래스의 기능을 확장하려면 확장 메서드를 만들 수 있습니다. 그러나 IFoo contract-refactor 레거시 객체를 변경하려는 경우 (누락 된 구현 추가)

Answer 4

IMHO FooX은 시작하기 전에 IFoo을 구현하면 안되며 현재 arquitecture에 대한 몇 가지 재검토가 이루어져야합니다.

그렇다면 정확히 어떤 한계를 알고 있는지 알지 못하면 IFooX을 래퍼를 통해 보낼 수 있습니까?다음과 같은 뭔가 :

public class FooXWrapper<T>: IFoo where T: FooX 
{ 
    readonly T foo; 
    bool doCalled; 

    public FooWrapper(T foo) 
    { 
     this.foo = foo; 
    } 

    public void Do() 
    { 
     doCalled = true; 
    } 

    public void Stuff() 
    { 
     if (!doCalled) 
      throw new InvalidOperationException("Must call Do"); 

     foo.DoStuff(); 
    } 
} 

그 추한 해킹,하지만 주어진 상황은 ...