Question

In my project I have a controller that allows you to create multiple letters of different types. All of these letter types are stored in the database, but each letter type has different required fields and different views.

Right now I have a route set up for the following URL: /Letters/Create/{LetterType}. I currently have this mapped to the following controller action:

public ActionResult Create(string LetterType)
{
    var model = new SpecificLetterModel();

    return View(model); 
}

I also have a View called Create.cshtml and an EditorTemplate for my specific letter type. This all works fine right now because I have only implemented one Letter Type. Now I need to go ahead and add the rest but the way I have my action set up it is tied to the specific letter type that I implemented.

Since each Letter has its own model, its own set of validations, and its own view, what is the best way to implement these actions? Since adding new letter types requires coding for the model/validations and creating a view, does it make more sense to have individual controller actions:

 public ActionResult CreateABC(ABCLetterModel model);
 public ActionResult CreateXYZ(XYZLetterModel model);

Or is there a way I can have a single controller action and easily return the correct model/view?

Answer 1

You can do one of the following:

Have a different action method for each input. This is because the mvc framework will see the input of the action method, and use the default model binder to easily bind the properties of that type. You could then have a common private method that will do the processing, and return the view.

Assuming XYZLetterModel and ABCLetterModel are subclasses of some base model, your controller code could look like:

public class SomeController : Controller
    {
        private ISomeService _SomeService;

        public SomeController(ISomeService someService)
        {
            _SomeService = someService;
        }

        public ViewResult CreateABC(ABCLetterModel abcLetterModel)
        {
            // this action method exists to allow data binding to figure out the model type easily
            return PostToServiceAndReturnView(abcLetterModel);
        }

        public ViewResult CreateXYZ(XYZLetterModel xyzLetterModel)
        {
            // this action method exists to allow data binding to figure out the model type easily
            return PostToServiceAndReturnView(xyzLetterModel);
        }

        private ViewResult PostToServiceAndReturnView(BaseLetterModel model)
        {
            if (ModelState.IsValid)
            {
                // do conversion here to service input
                ServiceInput serviceInput = ToServiceInput(model);
                _SomeService.Create(serviceInput);

                return View("Success");
            }
            else
            {
                return View("Create", model);
            }
        }
    }

The View code could look like:

@model BaseLetterModel
@if (Model is ABCLetterModel)
{
    using (Html.BeginForm("CreateABC", "Some"))
    {
        @Html.EditorForModel("ABCLetter")
    }
}
else if (Model is XYZLetterModel)
{
    using (Html.BeginForm("CreateXYZ", "Some"))
    {
        @Html.EditorForModel("XYZLetter")
    }
}

You would still have an editor template for each model type.

Another option is to have a custom model binder that figures out the type, based on some value in a hidden field, and then serializes it using that type.

The first approach is much more preferred because the default model binder works well out of the box, and it’s a lot of maintenance to build custom model binders.