C＃中的泛型和继承类型

Question

I'm a little confused about the best way to handle this particular situation. I'm not 100% confident with using generics yet.

I have a class, Model , and it has two derived types, 3DModel and 2DModel .

I have an abstract property in Model of class View , which also has two derived types, 3DView and 2DView .

When 3DModel calls the View property, I'd like 3DView returned, which I understand is where the generics come in (currently the 2D and 3D versions just have their own properties with the derived types).

My problem is that to do this I think I need to change Model to Model<TView> and then provide a where in 3DModel and 2DModel . This requires changing every use of Model , 2DModel and 3DModel to accommodate this though, and it's used absolutely everywhere (including, as far as I can tell, making it impossible to convert instances of Model to either 3DModel or 2DModel ).

Am I right in thinking this is the only way to implement this? It seems like a lot of extra code for something so simple.

Edit:

Some example code

public class View
{    
}

public class 3DView : View
{
}

public class Model
{
    public abstract View _view {get; set;}
}

public class 3DModel : Model
{
    public override 3DView _view {get; set;}
}

I get the Visual Studio error "Cannot change return type when overriding property".

Answer 1

You can keep your non-generic Model class, and introduce an abstract generic Model class.

public abstract class Model<TView> : Model where TView : View
{
    public new TView _view
    {
        get { return base._view as TView; }
        set { base._view = value; }
    }
}

public class View3D : View { }

public class Model3D : Model<View3D> { }

public class View2D : View { }

public class Model2D : Model<View2D> { }

Answer 2

The best solution for me is to use generic class, indeed.

You have another solution (more ugly), is create an interface for your views, and define your method View() as following :

public IView View()

Then you can eventually create specific properties in your 2D/3D models :

public 2DView 2DView()
{
    return this.View() as 2DView;
}

But you can't have the same result than with a generic class...

Answer 3

There are two approaches here, I think.

First, you may use usual inheritance:

public abstract class View 
{
    public abstract void Hello();
}

public class _3DView : View
{
    public override void Hello() 
    {
        Console.WriteLine("Hello from 3D View");
    }
}

public class _2DView : View
{
    public override void Hello() 
    {
        Console.WriteLine("Hello from 2D View");
    }
}

public abstract class Model
{
    public abstract View { get; }
}

public _3DModel : Model 
{
    public override View  { get { return new _3DView; } }
}

public _2DModel : Model 
{
    public override View  { get { return new _2DView; } }
}

Model model = new _3DModel();
model.View.Hello(); // have "Hello from 3D View"

Model anotherModel = new _2DModel();
anotherModel.View.Hello();  // have "Hello from 2D View"

This way you can work with models and views polymorphically and still can cast a View to, say, _3DView when needed.

Or you can use generics like this:

// Views are declared the same way

public abstract class Model<TView>
    where TView: View
{
    public abstract TView View { get; }
}

public class _3DModel : Model<_3DView>
{
    public override _3DView View { get { return new _3DView; } }
}

public class _2DModel : Model<_2DView>
{
    public override _2DView View { get { return new _2DView; } }
}

Model<_3DView> model = new _3DModel();
model.View.Hello();

The downsize of generics approach is that you can't say something like this:

Model model = new _3DModel();

since there is no single model parent. To my mind, generics approach makes no sense in this situation.