I have a problem with my MVP structure that is built upon generic presenters, views etc. and I feel I'm violating DRY and I dont know how to get around it.

Example.

public class Presenter<TView, TModel>
  where TView : IView
  where TModel : Model
{}

So far everything is fine, but I want to have it like this

public class Presenter<TView, TModel>
  where TView : IView
开发者_JAVA技巧  where TModel : Model
{}

public class Model<T>
{
  public T Value { get;set; }
}

But that won't compile because the where for Model needs a generic parameter. The fix:

public class Presenter<TView, TModel, TModelType>
      where TView : IView
      where TModel : Model<TModelType>
    {}

And it's here I feel i violating dry, take for example

public class MyPresenter : Presenter<IMyView, MyModel, string>
{}

public class MyModel : Model<string>
{}

I feel uncomfortable specifying the string type twice, at the presenter AND at the model, I only wan't to specify that the presenter is using MyModel as Model, I don't care what type of Model (generics). One solution is to remove the generic constraint for the model but then I can't create a generic Model class hierarchy that I want.

Am I thinking wrong about the whole MVP/generics stuff?

In C++, this would be solved with a typedef -- which C# doesn't really have.

public class Model<T>
{
   typedef T TModelType; // this doesn't exist in C#
   public T Value { get;set; }
}

Then,

 public class Presenter<TView, TModel>
  where TView : IView
  where TModel : Model<TModel::TModelType>
{}

There is a type aliasing that you can do with using

using NewName = any_type<even_generics<with_generics>>

But it's file based -- you can't use it in a class.

I would probably do it like this

1. rename Model<T> to ModelOf<T>
2. Make a Model base class for ModelOf<T> (ModelOf<T> : Model)
3. Use where TModel : Model

Model itself will be useful to define the interface methods that don't depend on TModelType.

Working with similar solution for my Unity game. Here is my take on MVP architecture. Waiting for your tips to help me improve my code) I still not sure if it's OK that I have two empty interfaces and that my View creates both model and presenter in Awake()

IModel

public interface IModel
    {
        
    }

IView

    public interface IView
    {
        public virtual void OnInit() { }
    }

IPresenter

 public interface IPresenter
    {
        
    }

BaseModel

public class BaseModel<TP> : IModel
        where TP : IPresenter
    {
        public TP Presenter { get ; set; }

        public BaseModel() { }

    }

BaseView

 public class BaseView<TP> : MonoBehaviour, IView
        where TP : IPresenter
    {
        public TP Presenter { get; set; }

        public virtual void OnInit(){ }

    }

BasePresenter

public class BasePresenter<TV, TM> : IPresenter
        where TV : IView
        where TM : IModel
    {
        public TV View { get; set; }
        public TM Model { get; set; }

        public BasePresenter(TV view, TM model)
        {
            View = view;
            Model = model;
            View.OnInit();
        }
    }

BoardModel

 public class BoardModel : BaseModel<BoardPresenter>
    {
        public BoardModel() : base () { 
            
        }
    }

BoardView

 public class BoardView : BaseView<BoardPresenter>
    {
        public int RowsNumber => meshRenderers.Length;

        [SerializeField] private MeshRenderer[] meshRenderers;
        public override void OnInit()
        {
            foreach (var renderer in meshRenderers) {
                renderer.enabled = false;
            }
        }

        private void Awake()
        {
            Presenter = new BoardPresenter(this, new BoardModel());
        }

        public void OnLineSelected(int index) {
            for (int i = 0; i < RowsNumber; i++)
            {
                meshRenderers[i].enabled = index == i;
            }
        }
    }

BoardPresenter

 public class BoardPresenter : BasePresenter<BoardView, BoardModel>
    {
        public BoardPresenter(BoardView view, BoardModel model) : base(view, model) { }
    }