Generics 具有多个返回类型的泛型类

我知道我的问题问得并不完美，但相当难，因此我将举一个例子： 所以我有一个类抽象处理程序。我使用另一个类中的方法创建它：

class AbstractManager
{
    BinarySerializator binarySerializator; //just for the example    
    TextSerializator textSerializator;

    public AbstractManager(BinarySerializator binarySerializator) {
        this.binarySerializator = binarySerializator;
        this.textSerializator = null;
    }

    public AbstractManager(TextSerializator textSerializator) {
        this.textSerializator = textSerializator;
        this.binarySerializator = null;
    }

    public AbstractHandler createHandler() {
        if (this.binarySerializator != null) {
            return new AbstractHandler<byte[]>(this.binarySerializator);
        } else {
            return new AbstractHandler<String>(this.textSerializator);
        }
    }
}

我的问题是——这是这样做的吗？还有两个构造函数的解决方法，以及如何处理两个不同的AbstractHandler，我知道可以使用泛型而不是设计两个类（一个用于String，一个用于byte[]）。感谢您花时间阅读这篇长篇文章。

我有两个解决方案：

接口：

---

现在，在您的问题上应用这一点应该不会有麻烦。

听起来您应该使用策略模式和他的界面。

public T createSerializable(Object object) {
   if (binarySerializer != null) {
     return (T) binarySerializer.getSerializedType(object);
   }

   if (textSerializer != null) {
     return (T) textSerializer.getSerializedType(object);
   }
}

interface ISerializatorStategy
{
    object GetSerializedType(object obj);
}

// If you want generic classes
interface ISerializatorStategy<T> : ISerializatorStategy
{
    new T GetSerializedType(object obj);
}

// If you don't want generic classes
// you can inherit from the base interface and implement only its method
class TextSerializator : ISerializatorStategy<string>
{
    public string GetSerializedType(object obj)
    {
        return "Hello World";
    }

    object ISerializatorStategy.GetSerializedType(object obj)
    {
        return GetSerializedType(obj);
    }
}

class IntSerializator : ISerializatorStategy<int>
{
    public int GetSerializedType(object obj)
    {
        return 42;
    }

    object ISerializatorStategy.GetSerializedType(object obj)
    {
        return GetSerializedType(obj);
    }
}

class AbstractManager
{
    protected ISerializatorStategy SerializatorStrategy { get; set; }

    public AbstractManager(ISerializatorStategy serializatorStrategy)
    {
        SerializatorStrategy = serializatorStrategy;
    }

    public AbstractHandler CreateHandler()
    {
        return new AbstractHandler(SerializatorStrategy);
    }
}

// If you want generic classes
class AbstractManager<T> : AbstractManager
{
    // Note, if you allow this constructor,
    // you could encounter runtime errors
    public AbstractManager(ISerializatorStategy serializatorStrategy)
        : base(serializatorStrategy)
    {
    }

    public AbstractManager(ISerializatorStategy<T> serializatorStrategy)
        : base(serializatorStrategy)
    {
    }

    public new AbstractHandler<T> CreateHandler()
    {
        return new AbstractHandler<T>(SerializatorStrategy);
    }
}

class AbstractHandler
{
    private readonly ISerializatorStategy _serializatorStrategy;

    public AbstractHandler(ISerializatorStategy serializatorStrategy)
    {
        _serializatorStrategy = serializatorStrategy;
    }

    public object CreateSerializable(object obj)
    {
        return _serializatorStrategy.GetSerializedType(obj);
    }

    public void GetSerializable<T>(object obj, out T serializebleObject)
    {
        serializebleObject = (T)_serializatorStrategy.GetSerializedType(obj);
    }
}

// If you want generic classes
class AbstractHandler<T> : AbstractHandler
{
    // Note, if you allow this constructor,
    // you could encounter runtime errors
    public AbstractHandler(ISerializatorStategy serializatorStrategy)
        : base(serializatorStrategy)
    {
    }

    public AbstractHandler(ISerializatorStategy<T> serializatorStrategy)
        : base(serializatorStrategy)
    {
    }

    public new T CreateSerializable(object obj)
    {
        return (T)base.CreateSerializable(obj);
    }
}

class Program
{
    static void Main(string[] args)
    {
        var textManager = new AbstractManager<string>(new TextSerializator());
        var textHandler = textManager.CreateHandler();
        string textResult = textHandler.CreateSerializable(null); // or AbstractHandler<string> as type
        Console.WriteLine(textResult);

        var intManager = new AbstractManager<int>(new IntSerializator());
        var intHandler = intManager.CreateHandler(); // or AbstractHandler<int> as type
        int intResult = intHandler.CreateSerializable(null);
        Console.WriteLine(intResult);

        Console.ReadKey();
    }
}

class Program
{
    static void Main(string[] args)
    {
        AbstractManager manager = new AbstractManager(new TextSerializator());
        AbstractHandler handler = manager.createHandler();
        string textResult;
        handler.GetSerializable(null, out textResult);
        Console.WriteLine(textResult);

        manager = new AbstractManager(new IntSerializator());
        handler = manager.createHandler();
        int intResult;
        handler.GetSerializable(null, out intResult);
        Console.WriteLine(intResult);

        Console.ReadKey();
    }
}