Question

我正在学习C＃，而且我来自Java。在Java中，我可以这样做：

public interface BasePresenterView<T extends BaseActivityPresenter> {}
public interface BaseActivityPresenter<T extends BasePresenterView> {}

在C＃中，我很难实现同样的目标。

Answer 1

这在.NET中被称为通用约束。

您在C＃中的示例将如下所示。

public interface BasePresenterView<T> where T: 'Interface or Type'{}
public interface BaseActivityPresenter<T> where T: 'Interface or Type' {}

更多信息：https://msdn.microsoft.com/en-us/library/d5x73970.aspx

编辑：如前所述，C＃中无法实现循环依赖，因此您不能以与示例相同的方式约束它们。

Answer 2

您可以使用generic type constraints，它使用继承来限制编译时类型。

public interface BasePresenterView<T> where T : IBaseView

因为继承不能是循环的，所以你不能像问题那样具有循环依赖性。

但是，如果它们声明了相同的方法或属性，它们可以继承相同的接口：

public interface BasePresenterView     : IBaseView
public interface BaseActivityPresenter : IBaseView

Answer 3

如果你使用的是抽象基类，你想要这样的东西......

public abstract class MyBasePresenter 
{
}
public abstract class MyBasePresenter<TView> : MyBasePresenter
    where TView : MyBaseView
{
}

public abstract class MyBaseView
{
}
public abstract class MyBaseView<TPresenter> : MyBaseView
    where TPresenter : MyBasePresenter
{
}

public class MyView : MyBaseView<MyPresenter>
{
}
public class MyPresenter : MyBasePresenter<MyView>
{
}

...如果你想要接口，请这样做......

public interface IMyPresenter 
{
}
public interface IMyPresenter<TView> : IMyPresenter
    where TView : IMyView
{
}

public interface IMyView
{
}
public interface IMyView<TPresenter> : IMyView
    where TPresenter : IMyPresenter
{
}

public class MyView : IMyView<MyPresenter>
{
}    
public class MyPresenter : IMyPresenter<MyView>
{
}

...你真的想要发疯，你甚至可以嵌套仿制药......

public class MyView : IMyView<IMyPresenter<IMyView>>
{
}

Answer 4

我想我已经解决了这个问题：）

public interface BaseActivityPresenter<T, K> 
        where T : BasePresenterView<T, K>
        where K : BaseActivityPresenter<T, K> {}

public interface BasePresenterView<T, K> 
        where T : BasePresenterView<T, K>
        where K : BaseActivityPresenter<T, K> {}

这似乎正在起作用......现在。我不知道这是否是一种正确的方法。

通过泛型相互结合的类

4 个答案: