c＃ジェネリックベースクラスの具体的な実装のための工場

Question

私はジェネリックなBaseクラスを持っています。 私は基本クラスを実装する具象クラスを持っています。

さまざまな種類の具象クラスを提供するためのファクトリクラス/メソッドを作成するにはどうすればよいですか？ここで

例：

public class ReceiverBase<T> 
    where T : IInterpreter 
{ ... } 

public class SpecialReceiver : ReceiverBase<OwnInterpreter> { ... } 

public class ReceiverFactory<T> 
    where T : ReceiverBase<IInterpreter>, new() 

    public T Create(string type) { 
     switch(type) { 
      default: 
       return new SpecialReceiver(); 
     } 
    } 
} 

問題はReceiverBaseコンパイラが唯一の制約はなく、インターフェイスとしてクラスを望んでいるので、可能ではないと思われることです。 2番目の問題は、SpecialReceiverをTに変換できないということです。

これを実行する方法はありますか？

=== EDIT：最初の回答に係る実施例を追加しました===

public interface IInterpreter 
{ 
} 

public class OwnInterpreter : IInterpreter 
{ 
    public void Dispose() 
    { 
     throw new NotImplementedException(); 
    } 

    public void DoSomething() { } 
} 



public abstract class ReceiverBase<T> 
    where T : IInterpreter 
{ 
    public T MyReceiver { get; set; } 

    internal abstract void Start(); 
} 

public class SpecialReceiver<T> : ReceiverBase<T> 
    where T : IInterpreter, new() 
{ 
    public void CheckSomething() 
    { 
     MyReceiver.DoSomething(); 
    } 

    internal override void Start() 
    { 
     MyReceiver = new T(); 
    } 
} 

public class ReceiverFactory<T> 
    where T : IInterpreter, new() 
{ 
    public static ReceiverBase<T> Create(string type) 
    { 
     switch (type) 
     { 
      default: 
       return new SpecialReceiver<T>(); 
     } 
    } 
} 

問題は：MyReceiver.DoSomething（）;動作しないでしょう。 さらに、私はこのような工場を呼び出す必要があります：ReceiverFactory<OwnInterpreter>.Create("");私はそのようにしたいのです：

public class ReceiverBase<T> where T : IInterpreter 
    { 
    } 

    public interface IInterpreter 
    { 
    } 

    public class SpecialReceiver<T> : ReceiverBase<T> 
     where T : IInterpreter 
    { 
    } 

    public class OwnInterpreter : IInterpreter 
    { 
    } 

    public class ReceiverFactory<T> where T : IInterpreter, new() 
    { 
     public ReceiverBase<T> Create(string type) 
     { 
      switch (type) 
      { 
       default: 
        return new SpecialReceiver<T>(); 
      } 
     } 
    } 

あなたがいないだけでできる理由を：ReceiverFactory.Create("SpecialReceiver");

Answer 1

あなたの工場で一般的な方法を使用することができます：あなたが工場を使用しているため

が

class Program 
{ 
    static void Main(string[] args) 
    { 
     var own = ReceiverFactory.Create<OwnInterpreter>(); 
     var other = ReceiverFactory.Create<OtherInterpreter>(); 
     own.Start(); 
     other.Start(); 
     Console.ReadLine(); 
    } 
} 
interface IInterpreter 
{ 
    void DoSomething(); 
} 

class OwnInterpreter : IInterpreter 
{ 
    public void DoSomething() { Console.WriteLine("Own"); } 
} 

class OtherInterpreter : IInterpreter 
{ 
    public void DoSomething() { Console.WriteLine("Other"); } 
} 

abstract class ReceiverBase<T> where T: IInterpreter, new() 
{ 
    public T Interpreter { get; set; } 
    public ReceiverBase() 
    { 
     Interpreter = new T(); 
    } 
    public void Start() 
    { 
     Interpreter.DoSomething(); 
    } 
} 

class SpecialReceiver : ReceiverBase<OwnInterpreter> { } 
class OtherReceiver : ReceiverBase<OtherInterpreter> { } 

static class ReceiverFactory 
{ 
    private static Dictionary<string, object> factories = new Dictionary<string, object>(); 
    static ReceiverFactory() 
    { 
     RegisterFactory(() => new SpecialReceiver()); 
     RegisterFactory(() => new OtherReceiver()); 
    } 
    public static void RegisterFactory<T>(Func<ReceiverBase<T>> factory) where T : IInterpreter, new() 
    { 
     factories.Add(typeof(T).FullName, factory); 
    } 
    public static ReceiverBase<T> Create<T>() where T : IInterpreter, new() 
    { 
     var type = typeof(T); 
     return ((Func<ReceiverBase<T>>)factories[type.FullName]).Invoke(); 
    } 
} 

実際には、あなたは、ここで「新しい（）」制約を必要としません。

Answer 2

私はあなたがあなたのコードを変更することをお勧めあなたのケースでTを返すのは、SpecialReceiverとReceiverBase<IInterpreter>の間の暗黙の変換がないということです。

Answer 3

自分のニーズに合った解決策を見つけることができました。 私は本当に必要なプロパティとメンバーを定義する別のインターフェースIReciverを追加しました。ファクトリメソッドはIReceiverを返すので、ジェネリックのバインディングに関する問題はすべて省略できます。時にはそれは簡単です。 :)

public interface IInterpreter { } 

public interface IReceiver 
{ 
    bool Enabled { get; set; } 
} 

public class OwnInterpreter : IInterpreter 
{ 
    public void DoSomething() { } 
} 

public abstract class ReceiverBase<T> : IReceiver 
    where T : IInterpreter, new() 
{ 
    public T MyReceiver { get; set; } 

    internal abstract void Start(); 

    private bool _isEnabled; 
    public bool Enabled { get { return _isEnabled; } set { _isEnabled = value; OnEnable(value); } } 

    internal abstract void OnEnable(bool isEnabled); 

    protected ReceiverBase() 
    { 
     MyReceiver = new T(); 
    } 
} 

public class SpecialReceiver : ReceiverBase<OwnInterpreter> 
{ 
    public void CheckSomething() 
    { 
     MyReceiver.DoSomething(); 
    } 

    internal override void Start() 
    { 
     // just for testing puropses 
     MyReceiver = new OwnInterpreter(); 
    } 

    internal override void OnEnable(bool isEnabled) 
    { 
     MyReceiver = isEnabled ? new OwnInterpreter() : null; 
    } 
} 

public class ReceiverFactory 
{ 
    public static IReceiver Create(string type) 
    { 
     switch (type) 
     { 
      default: 
       return new SpecialReceiver(); 
     } 
    } 
} 

public class Program 
{ 
    [STAThread] 
    public static void Main() 
    { 
     ReceiverFactory.Create(""); 
    } 
}