MVC - Polymorphic view binding possible?

Question

Can I have a single View in a MVC project that handles multiple derived ViewModel classes? I'm currently using ASP Core RC1 targetting 4.5 .NET framework.

My derived ViewModels have specific validation implemented with data annotations. If I pass a derived model class object to the View that references the base model (@model Models.BaseModel) none of the data annotations are rendered client side with the html 5 data-val tags.

If I use strongly typed views (@model Models.ChildModel) it works as expected. I cannot use more than one @model declaration in a View so I'm unable to check the type of the model in the View and choose the type of model being rendered.

However, I want to use a shared view because there are many fields and only the validation implementation needs to change based on which derived class is being used.

Here's an example implementation:

public abstract class BaseModel
{
    [Required]
    public abstract string FieldTest {get; set;}
}

public class ChildModel : BaseModel
{
    [Email]
    public override string FieldTest {get; set;}
}

public class AnotherChildModel : BaseModel
{
    [Phone]
    public override string FieldTest {get; set;}
}

Here's really what I'm trying to achieve in the View:

@if(Model is ChildModel)
{
    @model Models.ChildModel
}
else
{
    @model Models.AnotherChildModel
}

At present time my best solution is have a separate View for each derived class view model. The problem with that is the views are merely duplications with different @model references..

Answer 1

At present time my best solution is have a separate View for each derived class view model. The problem with that is the views are merely duplications with different @model references..

It seems that underlying problem is you want to eliminate duplicate codes between Views.

If so, you can create Partial View, and share between Views.

For example,

Edit.cshtml

@model UserCreateUpdateModel
@using (Html.BeginForm("Edit", "Users", FormMethod.Post))
{
    @Html.AntiForgeryToken()
    @Html.Partial("_CreateOrUpdate", Model)
}

Create.cshtml

@model UserCreateUpdateModel
@using (Html.BeginForm("Create", "Users", FormMethod.Post))
{
    @Html.Partial("_CreateOrUpdate", Model)
}

_CreateOrUpdate.cshtml

@model UserCreateUpdateModel
@if (Model.Id > 0)
{
   // Keep Edit only fields here, or place them in Edit.cshtml
}
else
{
   // Keep Create only fields here, or place them in Create.cshtml
}

// Keep shared fields for both Create and Edit mode

Update

I just notice that you are using same property for different purpose. Please do not do that. It hides the acknowledgement of property - inside any class other than ViewModel class. Maintenance will become nightmare.

It is ok to inherit ViewModel from BaseViewModel (we all do that), but not the way you are overriding it.

I suggest to use separate property - public string Email {get; set;} and public string Phone {get; set;}

public abstract class BaseModel
{
    [Required]
    public abstract string FieldTest {get; set;}
                            ^^^^^^^
}

public class ChildModel : BaseModel
{
    [Email]
    public override string FieldTest {get; set;}
                            ^^^^^^^
                          Store email
}

public class AnotherChildModel : BaseModel
{
    [Phone]
    public override string FieldTest {get; set;}
                            ^^^^^^^
                        Store phone number
}

Answer 2

Use Interface instead of concrete type. and everything will should be fine...

What i mean by that is

You can have a model of type interface , let's Say IBaseModel

@model IBaseModel
@using (Html.BeginForm("Create", "Users", FormMethod.Post))
{
    @Html.Partial("_CreateOrUpdate", IBaseModel)
}


// instead of this than all you need to do is cast to right model 
@if(Model is ChildModel)
{
    @model Models.ChildModel
}
else
{
    @model Models.AnotherChildModel
}

// in this case you will be able use both types and if your base class is implementing it you don't have to do much of refactoring.
IBaseModel as ChildModel.something 
IBaseModel as AnotherChildModel.something  

Answer 3

You can use the base type as the children can be referenced that way, I have previously done this myself using dynamic objects. I am assuming your model at the top is just an example of a model and not really representative of the final product.

@model basetype

@{
  dynamic testModel;
  if(Model.GetType().Name == typeof(ChildModel).Name)
       testModel = new ChildModel();
  else if(Model.GetType().Name == typeof(AnotherChildModel).Name)
       testModel = new AnotherChildModel();
}

You could also have a flag or enum to indicate which child it is throughout the page so that details may be changed on the page.

I haven't tested the below but you may be able to even use something like the below if there are only two options it could be:

var testModel = Model.getType().Name == typeof(ChildModel).Name ? new ChildModel() : new AnotherChildModel();

Answer 4

You can keep the view to accept the base type, which is BaseModel.

 @model Models.BaseModel

In the action method, you can send ChildModel or AnotherChildModel type objects from your action to the view. Since both are derived types of BaseModel , the view should be able to handle either of the derived types. You don't have to really set it the way you are doing in and if else manner. Just setting it to base type should be enough.

OR

You can also make use of templated view helper emthods like EditorFor() which are exactly for these kinds of situations where you want some amount of polymorphism carried over to your views as well.

You can see this link which may help you - Using a single view for derived mvc models

Answer 5

The model is set in the controller, so ideally the view shouldn't care which model it gets as long as the model is/inherits from/implements the @model. For handling which view to show depending on which model, the best way I've found is using partial views which are shown based on the name of the model.

Using a non-abstract base model...

@model MyApp.Models.BaseModel
@using (Html.BeginForm...
{
    @Html.DisplayFor(model => model.BaseProperty)

    @await Html.PartialAsync(String.Concat("_", Model.GetType().Name, "SomePartial"), Model);
}

This requires naming conventions for the partials that follow those of the models. So SquirrelModel would have its unique properties displayed in _SquirrelModelDetailsPartial.cshtml and so forth. This eliminates the need for checking in the view. ChipmunkModel would then trigger _ChipmunkModelDetailsPartial.cshtml and so forth.

I tried the abstract/interface approaches but ran into issues with testing controller actions that post data.