方法的通用接口重载？

Question

有没有一种好的，通用的方法可以执行以下操作，而无需求助于第二种方法或进行大量强制转换-我想使API尽可能轻便，在我看来，OO明智：

class Foo
{
  public T Bar<T>() where T: IAlpha
  {
    /* blahblahblah */
  }

  public T Bar<T>() where T: IBeta
  {
    /* blahblahblah */
  }
}

interface IAlpha
{
  string x {set;}
}

interface IBeta
{
  string y {set;}
}

谢谢

Answer 1

您不能仅通过返回值（泛型或非泛型）重载方法。 另外，将不可能解析对Bar调用，因为一个对象可以同时IAlpha和IBeta ，所以使用重载是不可能的。

public class AlphaBeta : IAlpha, IBeta
{
    string x {set;}
    string y {set;}
}

// too ambiguous
AlphaBeta parkingLot = myFoo.Bar<AlphaBeta>();

以下方法也不起作用，因为方法仅因返回类型而异

class Gar
{
    public string Foo()
    {
        return "";
    }

    public int Foo()
    {
        return 0;
    }
}

不幸的是，最好的解决方案是使用通用性较低的解决方案。 命令模式在这里可能会为您服务。

public class Foo
{
    private readonly static Dictionary<Type, Command> factories =
        new Dictionary<Type, Command>();

    static Foo()
    {
        factories.Add(typeof(IAlpha), new AlphaCreationCommand());
        factories.Add(typeof(IBeta), new BetaCreationCommand());
    }

    public T Bar<T>()
    {
        if (factories.ContainsKey(typeof(T)))
        {
            return (T) factories[typeof(T)].Execute();
        }
        throw new TypeNotSupportedException(typeof(T));
    }
}

// use it like this
IAlpha alphaInstance = myFoo.Bar<IAlpha>();
IBeta betaInstance = myFoo.Bar<IBeta>();

实现Bar而无需显式声明类型（在尖括号中）的方式调用Bar的另一种方法是使用out参数。 但是，我会避免使用它，因为100％管理的参数通常会导致不良设计。

public void Bar<T>(out T returnValue)
{
    if (factories.ContainsKey(typeof(T)))
    {
        returnValue = (T) factories[typeof(T)].Execute();
        return;
    }
    throw new TypeNotSupportedException(typeof(T));
}

// call it like this
// T is inferred from the parameter type
IAlpha alphaInstance;
IBeta betaInstance;
myFoo.Bar(out alphaInstance);
myFoo.Bar(out betaInstance);

我排除了Command ， AlphaCreationCommand ， BetaCreationCommand和TypeNotSupportedException 。 它们的实现应该是相当自我解释的。

或者，您可以使用Func代替Commands，但是这迫使您在Foo实现所有实例化代码，随着代码库的增加，这些实例化代码可能会失控。

Answer 2

这个怎么样？

class Foo
{
  public void Bar<T>(Action<T> @return) where T: IAlpha
  {
    @return(new AlphaImpl());
  }

  public void Bar<T>(Action<T> @return) where T: IBeta
  {
    @return(new BetaImpl());
  }
}

interface IAlpha
{
  string x {set;}
}

interface IBeta
{
  string y {set;}
}