기본 클래스에서 가상 함수를 재정의하기위한 리플렉션

Question

.NET Framework에서 정의 된 네임 스페이스가 클래스 계층 구조로 간주됩니다.

namespace OfficialDotnetNS 
{ 

    namespace officialNS.Bases 
    { 
     public class BaseOfA : IFakeA, IFakeB 
     { 
      protected void Driver(Stream stream){ this.DriveFoo(stream); }; 
      protected internal virtual void DriveFoo(Stream stream); 
     } 
    } 

    public abstract class A : officialNS.Bases.BaseofA 
    { 
     protected internal override void DriveFoo(Stream stream){ this.Foo(stream); }; 

     protected virtual void Foo(String stream); 
    } 

    public class B : A {} 

    public class C : A {} 

    public class D : A {} 

    // and 50+ similar classes derived from A 
} 

은 내가 BaseofA 개체가 나는 Driver(stream)를 호출 할 때 그것은 이후 A의 Foo 적합한 파생 클래스의 호출합니다.

지금, 그래서 모든 클래스가 A 상속이 사용자 정의 구현에서 파생 동일한 코드로 Foo()을 재정의합니다.

한 가지 방법은 각 클래스에 대한 사용자 지정 래퍼를 작성하는 것입니다 :

public class CustomB : B 
{ 
    protected override void Foo(Stream stream) 
    { 
     stream.Position = 12; 
     base.Foo(stream); 
    } 
} 

public class CustomC : C 
{ 
    protected override void Foo(Stream stream) 
    { 
     stream.Position = 12; 
     base.Foo(stream); 
    } 
} 

public class CustomD : D 
{ 
    protected override void Foo(Stream stream) 
    { 
     stream.Position = 12; 
     base.Foo(stream); 
    } 
} 

//.. for all 50+ classes 

우리가 사용하는 반사 또는 코드를 반복하지 않고 다른 기술을 할 수 있습니까?

Answer 1

예. 프록 싱이라고하며 엔티티 프레임 워크에서 사용되는 기법입니다. 이것을 달성하는 방법에는 여러 가지가 있지만 가장 좋은 IMO는 CastleProject DynamicProxy입니다.

예를 들어

(단순화 된 경우,하지만 난이 당신이 원하는 것을 생각) :

void Main() 
{ 
    var pg = new Castle.DynamicProxy.ProxyGenerator(); 
    var typeA = typeof(A); 
    var interceptor = 
     new FooInterceptor(
      str => Console.WriteLine("intercepted {0}", str)); 
    IEnumerable<A> objs = Assembly 
     .GetExecutingAssembly() 
     .GetTypes() 
     .Where(t => t.IsSubclassOf(typeA)) 
     .Select(t => (A)(pg.CreateClassProxy(t, interceptor))); 

    foreach(A a in objs) 
    { 
     a.CallFoo("hello world"); 
    } 
} 

public class A 
{ 
    public void CallFoo(string someString){ 
     Foo(someString); 
    } 
    protected virtual void Foo(string someString) 
    { 
     Console.WriteLine("base Foo {0}", someString); 
    } 
} 
public class B : A {} 

public class C : A {} 

public class D : A {} 

public class FooInterceptor : IInterceptor 
{ 
    Action<string> interceptorDelegate; 
    public Interceptor(Action<string> interceptorDelegate) 
    { 
     this.interceptorDelegate = interceptorDelegate; 
    } 
    public void Intercept(IInvocation invocation) 
    { 
     var isFooCall = invocation.Method.Name == "Foo"; 
     if(isFooCall) 
     { 
      interceptorDelegate 
       .Invoke((string)(invocation.Arguments[0])); 
     } 
     else 
     { 
      invocation.Proceed(); 
     } 
    } 
}