Question

为什么：

public interface IServiceRecherche<T, U>
                    where T : IEntite
                    where U : ICritereRecherche
{
    IList<T> Rechercher(U critere);
}

public interface IServiceRechercheUnite :
                        IServiceRecherche<IUnite, ICritereRechercheUnite>,

{}

不同于：

public interface IServiceRechercheUnite                             
{
    IList<IUnite> Rechercher(ICritereRechercheUnite critere);
}

编译时？

使用第一个界面编译的应用程序无法识别第二个界面。我知道它们在代码中不一样，但最终在执行期间为什么它们不一样？

Answer 1

从CLR的角度来看，这些是不同的类型，因为第一个类型是封闭泛型类型，继承自IServiceRecherche<T, U>。

但最终在执行期间为什么不一样

原因是相同的，如：

public MyClass1
{
  public int MyProperty { get; set; }
}

public MyClass2
{
  public int MyProperty { get; set; }
}

尽管有类似的成员声明，但它们只是一种不同的类型声明。

CLR无法这样思考：“啊，MyClass1和MyClass2完全一样。让我们把它们视为同一类型。”

Answer 2

但是，您可以使用duck-typing将一个实例“转换”为另一个实例。为此，您需要一个代表您的鸭子的类：

public class LooksLikeAnIServiceRecherche : IServiceRecherche<IUnite, ICritereRechercheUnite>
{
    private readonly dynamic _duck;

    public LooksLikeAnIServiceRecherche (dynamic duck)
    {
        this._duck = duck;
    }

    public IList<IUnite> Rechercher(ICritereRechercheUnite critere)
    {
        return this._duck.Rechercher(critere);
    }
}

对Rechercher - 方法的调用在运行时验证，而不是在编译时验证，从而防止了您收到的编译器错误。

使用该代码很简单：

IServiceRechercheUnite rechercheUnite;
var serviceRecherche = new LooksLikeAnIServiceRecherche(rechercheUnite);

有关如何使用dynamic - 关键字的详细信息，请参阅MSDN: dynamic

.Net接口继承编译

2 个答案: