ASP.NET MVC Clean way to inject partial view from action

Question

I have an app with many widgets and their content depends on the user requesting specific route. Simply put: if widget action is requested, its content must be rendered, otherwise it's empty. Consider routes/actions like this:

• ~/MyApp/Index -> without model; app HTML, without any widgets
• ~/MyApp/Foo/{id} -> uses FooModel; if ModelState is valid, returns Index HTML with injected partial view of Foo's widget to div#foo; otherwise redirects to Index.
• ~/MyApp/Bar/{id} -> same as Foo, but different model and widget

My foo action :

public ActionResult Foo(string id) {
    if (ModelState.IsValid) {
        var response = FooService.GetData(id);
        // Inject Foo widget to Index
    }
    return RedirectToAction("Index");
}

I know that it is possible to use ViewBag or other means to send variables and using the condition to decide whether to render partial view or not. But... there should be a better way to do this, right?

Answer 1

I use MVC's Html.RenderActionResult when I want to build shared views with non-trivial binding logic (calling the database, composing complex objects, etc). The binding logic for each widget is contained in a PartialViewResult method, which is called from the *.cshtml file using Html.RenderAction().

ContentController:

    public ActionResult Index(int id)
    {
        var indexViewModel = new IndexViewModel
        {
            Id = id,
            Title = "My Title",
            SubHeader = "Wow its 2016"
        };

        return View(indexViewModel);
    }

    public PartialViewResult PopularContent(int id)
    {
        var popularContentViewModel = new List<PopularContentViewModel>();
        // query by id to get popular content items

        return PartialView("_PopularContent", popularContentViewModel);
    }

    public PartialViewResult Widget2(int id)
    {
        return PartialView("_Widget2Partial");
    }

Index.cshtml:

@model StackOverflow.RenderAction.ViewModels.IndexViewModel

<h1>@Model.Title</h1>
<h2>@Model.SubHeader</h2>
--RenderAction will call out to the specified route.
--Note the use of the Id parameter from the viewmodel.
@{Html.RenderAction("PopularContent", "Content", new {Model.Id});}

Answer 2

ASP.NET MVC Attribute Routing could a be a nice solution for this:

In your controller:

public class WidgetController : Controller
{
     [Route("myapp/foowidget", Name = "FooWidget")]
     public ActionResult FooWidget()
     {
          //create any model and return any view or partial or redirect
     }

     [Route("myapp/boowidget/{id:int}", Name = "BooWidget")]
     public ActionResult BooWidget(int id)
     {
          //create any model and return any view or partial or redirect
     }
}

And then in a View, you can call the Route by name:

@Url.RouteUrl("FooWidget")

or

@Url.RouteUrl("BooWidget")

or

@Html.RenderPartial("FooWidget")

@Url.RouteUrl("BooWidget") will render or concatenate the id that is in current url, if url is /myapp/something/id, because of your Route attribute definition: "myapp/boowidget/{id:int}". In fact @Url.RouteUrl("BooWidget") might extract the id from any current url of the format /controllerName/action/id, though you will have to test for sure.

And notice how you can have a separation of concerns with your WidgetController and your url Routes are not dependent on that controller's name in any way. That is a nice feature of Attribute Routing, you can declare custom routes as well as organize your controllers and break from nameing convention dependency of a controllerName being part of the url controllerName/action a user sees in their browser.

In regards to Html.RenderPartial, I am not sure if RenderPartial "connects" or will be able to route to your RouteName like "FooWidget". If it does great.

If not your solution is this:

public class WidgetController : Controller
{
     public ActionResult FooWidget()
     {
          //model, you choose, return a partial
     }

     public ActionResult RedirectUser()
     {
          //do a redirect
     }

     public ActionResult BooWidget()
     {
          //any model, any partial
     }

     public ActionResult BooWidget(int id)
     {
          //any model, any partial
     }
}

Each method in your controller is single purpose, has a distinct signature and does one thing, no conditions to pass in and no decisions required.