AutoMapper on complicated Views (multiple looping)

Question

Earlier today, a helpful person (here on Stack Overflow) pointed me towards AutoMapper, I checked it out, and I liked it a lot! Now however I am a little stuck.

In my Code First MVC3 Application, on my [Home/Index] I need to display the following information from my Entities:

1. List of Posts [ int Id, string Body, int Likes, string p.User.FirstName, string p.User.LastName ]
2. List of Tags [int Id, string Name]
3. List of All Authors that exist on my Database [ string UrlFriendlyName ]

So far I have managed only point 1 in the list by doing the following for my Index ViewModel:

public class IndexVM
{
    public int Id { get; set; }
    public string Body { get; set; }
    public int Likes { get; set; }
    public string UserFirstName { get; set; }
    public string UserLastName { get; set; }
}

And on the Home Controller, Index ActionMethod I have:

public ActionResult Index()
{
    var Posts = postsRepository.Posts.ToList();
    Mapper.CreateMap<Post, IndexVM>();
    var IndexModel = Mapper.Map<List<Post>, List<IndexVM>>(Posts);
    return View(IndexModel);
}

Finally on my View I have it strongly typed to:

@model IEnumerable<BlogWeb.ViewModels.IndexVM>

And I am passing each Item in the IndexVM IEnumberable to a Partial View via:

@foreach (var item in Model)
{
    @Html.Partial("_PostDetails", item)
}

My question is, how can I also achieve point 2 and 3, whilst not breaking what I've achieved in point 1.

I tried putting the stuff I currently have for IndexVM into a SubClass, and having a List Property on the Parent class, but it didn't work.

Answer 1

As an alternative to including all of your lists of entities on a single viewmodel, you could use @Html.Action. Then, in your screen view:

@Html.Action("Index", "Posts")
@Html.Action("Index", "Tags")
@Html.Action("Index", "Authors")

This way, your Index / Screen view & model don't need to know about the other viewmodels. The partials are delivered by separate child action methods on separate controllers.

All of the automapper stuff still applies, but you would still map your entities to viewmodels individually. The difference is, instead of doing the mapping in HomeController.Index(), you would do it in PostsController.Index(), TagsController.Index(), and AuthorsController.Index().

Response to comment 1

public class IndexVM
{
    // need not implement anything for Posts, Tags, or Authors
}

Then, implement 3 different methods on 3 different controllers. Here is one example for the PostsController. Follow the same pattern for TagsController and AuthorsController

// on PostsController
public PartialViewResult Index()
{
    var posts = postsRepository.Posts.ToList();

    // as mentioned, should do this in bootstrapper, not action method
    Mapper.CreateMap<Post, PostModel>();

    // automapper2 doesn't need source type in generic args
    var postModels = Mapper.Map<List<PostModel>>(posts); 
    return PartialView(postModels);
}

You will have to create a corresponding partial view for this, strongly-typed as @model IEnumerable<BlogWeb.ViewModels.PostModel>. In that view, put the HTML that renders the Posts UI (move from your HomeController.Index view).

On your HomeController, just do this:

public ActionResult Index()
{
    return View(new IndexVM);
}

Keep your view strongly-typed on the IndexVM

@model IEnumerable<BlogWeb.ViewModels.IndexVM>

... and then get the Posts, Tags, and Authors like so:

@Html.Action("Index", "Posts")

Response to comment 2

Bootstrapping... your Mapper.CreateMap configurations only have to happen once per app domain. This means you should do all of your CreateMap calls from Application_Start. Putting them in the controller code just creates unnecessary overhead. Sure, the maps need to be created - but not during each request.

This also helps with unit testing. If you put all of your Mapper.CreateMap calls into a single static method, you can call that method from a unit test method as well as from Global.asax Application_Start. Then in the unit test, one method can test that your CreateMap calls are set up correctly:

AutoMapperBootStrapper.CreateAllMaps();
Mapper.AssertConfigurationIsValid();