Controllers often have some repetitive code, implementing your own Controller class can help eliminate a lot of this
Here is a small snippet and how I use some simple tricks to help clean up my Controllers in Asp.Net MVC (using MVC 4 at the moment):
public class MyController : Controller
{
public MyEntities Db { get; set; }
protected override void OnActionExecuting(
ActionExecutingContext filterContext)
{
if (filterContext.IsChildAction)
return;
this.Db = new MyEntities();
base.OnActionExecuting(filterContext);
}
[HttpPost]
public ActionResult Index(FormCollection form)
{
string srch = form["Search"] ?? string.Empty;
return RedirectToAction("Index",
new { search = srch });
}
protected void AttachToDb(EntityObject obj,
bool save = false, string entityKeyField = "Id")
{
obj.EntityKey = new EntityKey(
obj.ToPluralizedString(), entityKeyField,
obj.GetType().GetProperty("Id")
.GetValue(obj, null));
Db.Attach(obj);
Db.ObjectStateManager.ChangeObjectState(
obj, System.Data.EntityState.Modified);
if (save) Db.SaveChanges();
}
}
The first thing in the code is simple declaration of an EntityContext - this is implemented directly, but could (and usually should) be implemented differently for dependency injection, but you get the idea. Here is where I also like to include stuff that is often used and could be vital (and centralized) for an application like an output type for web services (JSON, XML, etc.).
Next the
OnActionExecuting is over-ridden and the Context is initialized. Here is where you can initialize the properties you set above.
The next method, the
HttpPost Index method is just an example of how often times you can consolidate a commonly used method. For this example, it was from an application that had searches on all index pages. Instead of repeating this code in every controller, you can just put it here.
The final method has become very useful. A use I often find, is when taking in a large model after an Asp.Net MVC POST event, I can attach the model to the Db generically without any extra work
This method is a bit confusing, but it is simply attaching the new model to the Db without a Db lookup. In my tables, I generally have a field 'Id' that houses the Primary Key of every table, whether it is an Int or Guid. This way, I can simply pass in whatever object I am currently working with, and by using the
pluralize method, and reflection, the method can figure out which table to attach the model to - eliminating the need for me to do extra coding. Alternatively, if I want to change the Key from 'Id', I can pass that in as well.
Now when I get a model being POSTed, it is easy to deal with:
[HttpPost]
public ActionResult Edit(Widget model)
{
if(ModelState.IsValid)
{
AttachToDb(model, true);
//do stuff
}
else { /*do other stuff*/ }
}
This avoids the need to take another trip to the DB, change the properties on the object, then submit - streamlining the process very much and cutting down a lot of code.
This would be an example of how this would be done manually with the normal Controller class:
[HttpPost]
public ActionResult Edit(Widget model)
{
if(ModelState.IsValid)
{
MyEntities db = new MyEntities();
Widget w = db.Widgets.Single(x => x.Id == model.Id);
w.Name = model.Name;
w.Serial = model.Serial;
db.SaveChanges();
//do stuff
}
else { /*do other stuff*/ }
}
Not a huge difference when you are just getting 2 values, but you could see how a model with 20 or 30 fields can be cut down from 30+ lines to just 1 or 2.