Using custom model casts to keep MVC/WebAPI Controllers free of “plumbing” code.

What do I mean by plumbing in MVC?

When you’re getting back your objects from the data access layers in your MVC controllers, there can be a lot of code that just ends up “plumbing” the data in your models into your viewmodels. More code = less readability, generally, so what are the techniques that we can use to take care of it?

[HttpGet]
public JsonResult GetTestJson()
{
    DataObject data = repo.GetFoo();
    MyJsonObject obj = new MyJsonObject()
    {
        first = data.dataFirst,
        second = data.Foo,
        third = data.Bar
    }

    return Json(obj, JsonRequestBehavior.AllowGet);
}

While this example is not a bad lot of code to see, it can add up when you’re doing this in every action.

The solution?

Firstly, there are some libraries that can make this sort of thing easier - Automapper for example.

While my experiences with automapper are actually very good, there might be some times when another nuget package might just seem like additional bloat. In these situations we can declare our own type conversion operator to allow casting between your object types:

class MyJsonObject
    {
        public int first { get; set; }
        public int second { get; set; }
        public int third { get; set; }

        public static explicit operator MyJsonObject(DataObject data)
        {
            return new MyJsonObject
            {
                first = data.dataFirst,
                second = data.Foo,
                third = data.Bar
            };
        }
    }

C# will now let us cast from DataObject to MyJsonObject class, giving us some nice clean code:

public JsonResult GetTestJson()
    {
        return Json((MyJsonObject)repo.GetFoo()); 
    }

This can be even better if you want to convert a list of objects to a single object, keeping the for loops out of your controllers:

class RandomViewModel
    {
        public List<MyJsonObject> list;
        public int Name { get; set; }

        public RandomViewModel() { list = new List<MyJsonObject>(); }

        public static explicit operator RandomViewModel(List<DataObject> data)
        {
            var rvm = new RandomViewModel();
            foreach (var i in data)
            {
                rvm.list.Add(new MyJsonObject() {
                    first = i.dataFirst,
                    second = i.Foo,
                    third = i.Bar
                });
            }
            rvm.Name = data[0].SetName;
            return rvm;
        }
    }

While you’re really just “moving code around” this sort of thing is the cornerstone of refactoring – method extraction, although in this case we’re simply moving it to a method so that C# can invoke our conversion with its own syntax.

The post Using custom model casts to keep MVC/WebAPI Controllers free of “plumbing” code. appeared first on Weebtutorials.