Question

I’m building CMS like application.

For example my BlogPost page contains several widget areas. Each widget hosts a serie of “related” blog posts.

All my views are pure presentational, i build urls, convert datetime and ints into strings in my service layer. I find this approach easier to maintain, since views have zer0 logic. All logic is consolidated into AutoMapper’s resolvers, converters and custom transformation logic.

So lets come closer to the problem at hand.
To create Url i need 2 parameters: BlogId and BlogSlug, my urls look like b/{id}/{slug}.html
Im quite happy with that.

In my CSM i use so called “source models”, a model that is not view model, but an intermediate representation of it. Why do i have to resort to such wicked solutions ?
Well, lets take a look how a typical data retrieval code can look like in my project:

.Select(x => 
{
    Id = x.Id,
    BlogId = x.Blog.Id,
    BlogSlug = x.Blog.Slug,

    // Here is the trap, LINQ provider will throw an exception, since he doesn't know how to translate function into expression
    BlogUrl = Url.Action("RenderPost", "BlogController", new { Id = x.Blog.Id, slug = x.Blog.Slug }) 
}

So thats not an option.
Luckily, we can do this

.Select(x => new
{
    Id = x.Id,
    BlogId = x.Blog.Id,
    BlogSlug = x.Blog.Slug
}
.ToList()
.Select(x => new
{
    // This works
    BlogUrl = Url.Action("RenderPost", "BlogController", new { Id = x.BlogId, slug = x.BlogSlug })
}

Copy paste this stuff into each and every action method that renders different “intresting blog” parts (they have different visual representation as well cant use same view model) ? Not a good way, so i came up with a solution.
I created “source model”, so the code will be

.Select(x => new BlogPostSourceViewModel
{
    Id = x.Id,
    BlogId = x.Blog.Id,
    BlogSlug = x.Blog.Slug
}
.ToList()
.Select(x => x.ToBlogPostViewModel())  // Extension method { return Mapper.Map<>() }
.ToList();

This surely looks better, but i have many different models like BlogPostSourceViewModel, BlogAuthorSourceViewModel, BlogCommentSourceViewModel. They all need this link building logic.
Ok, i extract the needed source data (BlogId, BlogSlug) into an interface

BlogPostSourceViewModel : IBlogPostUrl
BlogAuthorSourceViewModel: IBlogPostUrl
BlogCommentSourceViewModel : IBlogPostUrl

Then i define the mappings

Mapper.CreateMap<BlogPostSourceViewModel, BlogPostViewModel>
    .ForMember(dest => dest.BlogUrl, opt => opt.ResolveUsing<BlogPostUrlResolver>())
Mapper.CreateMap<BlogAuthorSourceViewModel, BlogAuthorViewModel>
    .ForMember(dest => dest.BlogUrl, opt => opt.ResolveUsing<BlogPostUrlResolver>())
Mapper.CreateMap<BlogCommentSourceViewModel, BlogCommentViewModel>
    .ForMember(dest => dest.BlogUrl, opt => opt.ResolveUsing<BlogPostUrlResolver>())

Resolver:

BlogPostUrlResolver : ValueResolver<IBlogPostUrl, String>
// Here goes the url building logic

As you see the more models i have that need blog url the more identical mappings i have to add. This is ok for now, but as project grows it will be painful.
Ideally i would want to have it like this:

Mapper.CreateMap<IBlogPostUrl, SomeOtherInterfaceWithBlogUrlAsString>
    .ForMember(dest => dest.BlogUrl, opt => opt.ResolveUsing<BlogPostUrlResolver>())

but Automapper doesn’t understand it. And i dont know how if there is other way to do it.

Any ideas ?

Answer 1

If I understand the question correctly…

In order to use AutoMapper mapping capabilities across all of your classes you can provide base class that will use Generics:

public abstract class Base<Entity, ViewModel>   
    where Entity : EntityObject         
    where ViewModel : BaseViewModel     
    {
        // you will call this method from your operations class using base
        public SomeViewModel GetData()
        {
            public Entity entityObject = db.Entity.SingleOrDefault();
            public ViewModel yourViewModelName = base.Map(entityObject);

            return yourViewModelName;
        }
        ....
        // this will be defined only once for each mapping direction
        // ie. there will be multiple of these.
        public static Entity Map(ViewModel typeViewModel)
        {
            try
            {
                Mapper.CreateMap<ViewModel, Entity>();
                Entity t = Mapper.Map<ViewModel, Entity>(typeViewModel);

                return t;
            }
            catch (Exception exc)
            {
                throw exc;
            }
        }
    }

// this will be your class for database operations on specific Entity
// that inherits generic base, with its AutoMapping setup.
public class DataBaseOperationsClass : Base<SomeEntity, SomeViewModel>
{
    public SomeViewModel Get()
    { 
        return base.GetData();
    }
}

Hope this helps !