First Look at ASP.NET MVC

	
	public class BlogController: Controller
	{
		public ActionResult Index() {
			var posts = repo.GetAllPosts();
			return View(posts);
		}
		
		public ActionResult Edit(int postId) {
			var post = repo.GetPost(postId);
			return View(post);
		}
		
		[HttpPost]
		public ActionResult Edit(Post post) {
			repo.SavePost(post);
			RedirectToAction("Index"); 
		}
	}
		

	
	public class HomeController: Controller
	{
		// returning a plain text from action
		public ContentResult SayHello() {
			return Content("Hello, World!");
		}
		
		// returning a view from action
		public ViewResult About() {
			return View("AboutMe");
		}
		
		// returning json from action
		public JsonResult About() {
			return Json(new { id = 1, success = true });
		}
	}
		

	
	// strongly typed razor view that dispays a html form
	@model CustomValidation.MVC.Models.Party
	@{
	  ViewBag.Title = "Party Planner";
	}
	<h2>
	  @ViewBag.Title</h2>

	@using (Html.BeginForm())
	{
	  @Html.ValidationSummary()
	  <p>
		Start date (MM/dd/yyyy HH:mm:ss AM/PM) *: 
		@Html.TextBoxFor(x => x.StartDate, new { size = 25 })</p>
	  <p>
		No. of joinees *: @Html.TextBoxFor(x => x.NoOfJoinees, new { size = 5 })</p>
	  <p>
		Drinks? @Html.CheckBoxFor(x => x.Drinks)</p>
	  <p>
		<input type="submit" value="Host the party!" />
	  </p>
	}
		

	
	// passing data to a strongly typed view from action.
	public ActionResult Index() {
		var posts = repo.GetAllPosts();
		return View(posts);
	}
	
	// passing data to view using ViewData.
	public ActionResult Index() {
		ViewData["posts"] = repo.GetAllPosts();
		return View();
	}
	
	// passing data to view using ViewBag dynamic object.
	public ActionResult Index() {
		ViewBag.Posts = repo.GetAllPosts();
		return View();
	}
		

		
	ViewEngines.Engines.Add(new RazorViewEngine());
	
	ViewEngines.Engines.Add(new MyViewEngine());
		

		
	routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
	
	routes.MapRoute(
		"Post",	
		"Blog/Archive/{year}/{month}/{fileName}", 
		new { controller = "Blog", action = "Post" }
	); 
		

		
	[HandleError]
	public class HomeController : Controller {
		public ActionResult About()	{
			return View();
		}
	}
		

		
	// the person instance is automatically created and populated from the values
	// available in the HTTP request.
	public ActionResult Details(Person person) {
		return View(person);
	}
		

		
	public class Movie {
		public int Id { get; set; }

		[Required(ErrorMessage="Movie title is required.")]
		[StringLength(8, ErrorMessage="Movie title cannot be longer than 8 characters")]
		public string Title { get; set; }

		[Required(ErrorMessage="Movie director is required")]
		public string Director { get; set; }
	}
		

	
	// creating a custom route constraint that matches the request to the route
	// only if it has come from a particular browser.
	public class UserAgentConstraint: IRouteConstraint {
		private string requiredUserAgent;
		
		public UserAgentConstraint(string agentParam) {
			requiredUserAgent = agentParam;
		}
		
		public bool Match(HttpContextBase httpContext, Route route, string parameterName,
			RouteValueDictionary values, RouteDirection routeDirection)	{
			return httpContext.Request.UserAgent.Contains(requiredUserAgent);
		}
	}
	
	// this route will receive only the requests that are sent by the Internet Explorer.
	routes.MapRoute("MyRoute", 
		"{controller}/{action}",
		new { controller = "Home", action = "Index" },  
		new { customConstraint = new UserAgentConstraint("IE")},
	);
		

	// creating a custom route handler
	public class CustomRouteHandler: IRouteHandler {
		public IHttpHandler GetHttpHandler(RequestContext requestContext) {
			return new CustomHttpHandler();
		}
	}
	
	public class CustomHttpHandler: IHttpHandler {
		public bool IsReusable {
			get{ return false; }
		}
		
		public void ProcessRequest(HttpContext context) {
			context.Response.Write("Hello");
		}
	}
	
	// setting the custom handler for a route
	routes.Add(new Route("SayHello", new CustomRouteHandler()));
		

	// creating a custom controller factory that instantiates HomeController
	// without using the default constructor
	public class CustomControllerFactory: IControllerFactory {
		public IController CreateController(RequestContext requestContext,
									string controllerName) {
			return new HomeController(new PostRepository());
		}
		
		public SessionStateBehavior GetControllerSessionBehavior
			(RequestContext requestContext, strong ControllerName) {
			return SessionStateBehavior.Default;
		}
		
		public void ReleaseController(IController controller) {
			if(controller is IDisposable)
				((IDisposable)controller).Dispose();
		}
	}
	
	// setting the custom controller factory in the Application_Start event			
	ControllerBuilder.Current.SetControllerFactory(new CustomControllerFactory());
		

	// creating a custom action invoker
	public class CustomActionInvoker: IActionInvoker {
		public bool InvokeAction(ControllerContext context, string actionName) {
			if(actionName == "Index") {
				context.HttpContext.Response.Write("This is Index action");
				return true;
			}
			
			return false;
		}
	}
	
	// setting the custom action invoker to the controller
	public class CustomController: Controller {
		public CustomController() {			
			this.ActionInvoker = new CustomActionInvoker();
		}
	}
		

	// a custom view engine that uses XSLTs for generating HTML from the model
	public class XsltViewEngine: VirtualPathProviderViewEngine	{
		public XsltViewEngine()	{
			base.ViewLocationFormats = new[] { "~/Views/{1}/{0}.xsl", "~/Views/Shared/{0}.xsl" };
			base.PartialViewLocationFormats = base.ViewLocationFormats;
		}

		protected override IView CreatePartialView(ControllerContext controllerContext, string partialPath)	{
			return new XsltView(partialPath);
		}

		protected override IView CreateView(ControllerContext controllerContext, string viewPath, string masterPath) {
			return new XsltView(viewPath);
		}
	}
		

	// the custom view used by the XSLT view engine.
	public class XsltView : IView {
		private readonly string _path;

		public XsltView(string path) {
			_path = path;
		}

		public void Render(ViewContext viewContext, TextWriter writer) {
			var xsltFile = viewContext.HttpContext.Server.MapPath(_path);
			var xmlData = viewContext.ViewData["data"] != null 
					? ((XElement)viewContext.ViewData["data"]).ToString() : "";

			var xmlTree = XDocument.Parse(xmlData);
			var xslt = new XslCompiledTransform();

			xslt.Load(xsltFile);
			xslt.Transform(xmlTree.CreateReader(), null, writer);
		}
	}		
		

    protected void Application_Start() {
		ViewEngines.Engines.Add(new XsltViewEngine());
	}
		

	// a custom action filter
	public class AuditFilter : FilterAttribute, IActionFilter {
		// this method is called after the action is executed
		public void OnActionExecuted(ActionExecutedContext filterContext) {
			Debug.WriteLine("OnActionExecuted is called");
		}

		// this method is called before the action is executed
		public void OnActionExecuting(ActionExecutingContext filterContext)	{
			Debug.WriteLine("OnActionExecuting is called");
		}
	}
	
	[AuditFilter]
	public ActionResult EditProfile() { 
		//..
	}