리팩토링

Question

우리는 다음과 같은 클래스를 가지고, 이제 가정하자.

모두를 하나의 제네릭 클래스로 변환하는 좋은 방법이 있습니까? C 번호는 일반적인 수준의 전문화에 매개 변수화 ctors를 호출 허용하지

proxy = new ProxyA(data); 

때문에 (T 기준) : 핵심 문제는 라인입니다.

Answer 1

형식을 알고 있으면 (원하는 경우 제네릭을 사용하여) Activator.CreateInstance을 호출하여 원하는 생성자를 사용하여 해당 형식의 인스턴스를 만들 수 있습니다.

proxy = Activator.CreateInstance(typeof(TProxy), new[]{data}); 

이이 직접 문제를 해결할 수 있지만, 당신은 또한 ProxyA를 전달되는 대신에 대한 DataA을 알고하지 않습니다 ViewModelA 디자인에 대해 생각 할 수있다. 그것은 멋진 반영없이 모든 문제를 해결할 것입니다.

Answer 2

public interface IDoSomething 
{ 
    void DoSth(); 
} 

class ViewModel<T> where T : IDoSomething 
{ 
    private T proxy; 

    public ViewModel() 
    { 
     proxy = Activator.CreateInstance<T>(); 
    } 

    //public ViewModel(T data) 
    //{ 
    // proxy = data; 
    //} 

    public void DoSth() 
    { 
     proxy.DoSth(); 
    } 

    public T Proxy 
    { 
     get 
     { 
      return proxy; 
     } 
    } 
} 

Answer 3

언급 한대로 리플렉션을 사용하지 않고 매개 변수화 된 생성자에서는이 작업을 수행 할 수 없습니다. 그러나이 주제에 대한 하나의 가능한 변화 :

public interface IDataProxy<T> 
{ 
    T Data { get; set; } 
} 

public class ViewModel<TProxy, TData> 
    where TProxy : class, new, IDataProxy<TData> 
{ 
    public TProxy Proxy { get; private set; } 

    public ViewModel(TData data) 
    { 
     Proxy = new TProxy { Data = data }; 
    } 
} 

Answer 4

public interface IProxy 
{ 
    void DoSth(); 
} 

public class ProxyA : IProxy 
{ 
    public ProxyA(DataA dataA) 
    { 

    } 
    public void DoSth() 
    { } 
} 

public class ProxyB : IProxy 
{ 
    public ProxyB(DataB dataA) 
    { 

    } 
    public void DoSth() 
    { 

    } 
} 

public class ViewModel<T> where T : IProxy 
{ 
    private readonly IProxy _proxy; 
    public ViewModel(T proxy) 
    { 
     _proxy = proxy; 
    } 

    public void DoSth() 
    { 
     _proxy.DoSth(); 
    } 
} 

var vm = new ViewModel<ProxyA>(new ProxyA(new DataA())); 
vm.DoSth(); 

Answer 5

당신은 미리 구성된 ProxyA 또는 ProxyB 객체를 전달하여이 문제를 해결할 수 있습니다. 그 일의

한 가지 방법은 기본 생성자를 호출하기 전에 객체를 구성, 상속을 통해입니다 :

class ViewModel<TProxy, TData> 
{ 
    private TProxy proxy; 

    public ViewModel(TProxy proxy) 
    { 
     this.proxy = proxy; 
    } 

    public void DoSth() 
    { 
     proxy.DoSth(); 
    } 

    public TProxy Proxy 
    { 
     get 
     { 
      return proxy; 
     } 
    } 
} 

class ViewModelA : ViewModel<ProxyA, DataA> 
{ 
    public ViewModelA(DataA data) : base(new ProxyA(data)) 
    { 
    } 
} 

내가 DataA 및 DataB는 생략 한 메소드 서명 어딘가에서 발생하는 여기에 가정했습니다. 그렇지 않은 경우 TData 제네릭 유형 매개 변수를 생략 할 수 있습니다.

반사는 항상 옵션이지만, 이와 같은 해결책이 허용되는 경우에는 피해야합니다.

ViewModel(TData data, Func<TData, TProxy> factory) : this(factory(data)) 
{ 
} 

하는 등 사용 :

new ViewModel<ProxyA, DataA>(new DataA(), data => new ProxyA(data)); 

내가 잘 모르겠어요 다른 TProxy 및 TData을위한 새로운 유형을 만들 필요가 없도록하려는 경우, 당신은 대신 두 번째 생성자를 추가 할 수 있습니다 그러나 그것은 당신의 응용 프로그램에서 할 말이 있습니다.