Previously to learning about ViewModels and AutoMapper, my infrastructure project had the following classes defined:
namespace Venue.Infrastructure.Business.Presentations
{
public class ItemPresentation<T>
{
public T Item { get; protected set; }
public ItemPresentation(T item) { Item = item; }
}
}
using System.Collections.Generic;
namespace Venue.Infrastructure.Business.Presentations
{
public class ListPresentation<T>
{
public IEnumerable<T> Items { get; protected set; }
public ListPresentation(IEnumerable<T> items) { Items = items; }
}
}
The question is, should I stick solely with ViewModels, sending in either a single instance, or an enumerable of instances, to the View. Or should I populate a given presentation with such ViewModels?
The reason I ask is that I have several classes in my presentation layer that build on these presentation classes. Currently, they are still wired to accept my old Linq entities, but could be redone to accept my new pocos.
So it comes down to…
return View(someService.GetModelForId(id))
return View(someService.GetModels())
// and lose other elements that are always displayed
// leaving me to find another way to send them
or
return View(new SomePresentation(someService.GetModelForId(id)));
return View(new SomePresentation(someService.GetModels()));
Thanks for any comments.
Personally I use the Presentation method because it seems simplest to me. Everything that the view needs will be in the 1 class and there is only one method of passing data that I need to worry about. Unless there is a good reason to deviate I go with the simplest solution.
Thore more data my Site.Master requires (and it’s gaining momentum), the more I am tempted to go this route also. So here’s my solution:
Presentation.cs
An abstract class with all the data elements required by the Site.Master, all the common data elements required by all Views, and all the overloaded methods like GetSelectList that I need.
ItemPresentation.cs
ListPresentation.cs
Extends Presentation and adds a typed item(s) property, so I can add data elements like:
SpecificItemPresentation : ItemPresentation<SpecificModel> - Exposes “SpecificModel Item { public get; }”.
SpecificListPresentation : ListPresentation<SpecificModel> - Exposes “IEnumerable<SpecificModel> Items { public get; }”.
The real question is, is this enough asbtraction to allow typing to entities instead of the models (Specific vs SpecificModel)?
At this level, especially in the Site.Master, I pass certain things from the presentation into custom htm extensions, whose output is based on methods present in the entities only. Do I stick with models, and then duplicate the entity methods locally?