How to Download Razor View Engine

Question

I want to download and install razor view engine for ASP.Net MVC 2. From where i can download and install?

Answer 1

Possibly a bit outdated but you should maybe take a look at this post.

http://stefan.rusek.org/Posts/Using-Razor-with-ASP-NET-MVC-in-Four-Easy-Steps/26/

Razor is capable of running standalone so it is entirely possible to provide the wiring yourself. Whether or not you need to be using .NET4 or not I am not 100% sure of. On another note MVC3 is at RC status and has a Go-Live license which emans you could technically start using now and when the RTM hits (soon) just upgrade.

Answer 2

Utilizing Matthew Abbott's and My Razor View Engine from Codeplex. You could do the following. It doesn't support models or layout pages but it will get you in the right direction if you choose to go this route. Frankly though, I would just update to MVC 3 when the time is ready. This code was based on my blog post at http://buildstarted.com/2010/11/22/making-your-own-viewengine-with-markdown/

You'll have to add the following line to your global.asax:

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

unless you want both engines in which case just remove Clear()

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using System.Web.Hosting;
using System.IO;
using System.Text.RegularExpressions;
using System.Xml.Linq;

namespace RazorViewEngine {
    /// <summary>
    /// ViewEngine for the RazorView. Provides basic file handling to load views. 
    /// </summary>
    public class RazorViewEngine : IViewEngine {

        string[] SearchLocations { get; set; }
        Tuple<string, string, RazorView> Cache { get; set; }
        VirtualPathProvider VirtualPathProvider { get; set; }

        public RazorViewEngine() {
            //{1} == Controller name
            //{0} == View name
            SearchLocations = new string[] {
                "~/Views/{1}/{0}.cshtml",
                "~/Views/Shared/{0}.cshtml",
            };

            VirtualPathProvider = HostingEnvironment.VirtualPathProvider;
        }

        #region IViewEngine Members

        public ViewEngineResult FindPartialView(ControllerContext controllerContext, string partialViewName, bool useCache) {
            return CreateView(controllerContext, partialViewName, null, null, useCache);
        }

        public ViewEngineResult FindView(ControllerContext controllerContext, string viewName, string masterName, bool useCache) {
            return CreateView(controllerContext, viewName, masterName, GetLayoutPath(controllerContext), useCache);
        }

        /// <summary>
        /// Meat of the FindView methods.
        /// </summary>
        /// <param name="controllerContext">The current controller context for this request.</param>
        /// <param name="viewName">The requested view name. </param>
        /// <param name="masterName">The master page view name (currently unused)</param>
        /// <param name="layoutPath">The layout path location (Replaces the masterpage in other view engines)</param>
        /// <param name="useCache">Cache the viewpage?</param>
        /// <remarks>The layout path is currently hardcoded to "Layout" and will look in the SearchLocations for that path</remarks>
        /// <returns>Returns a ViewEngineResult with the requested view</returns>
        public ViewEngineResult CreateView(ControllerContext controllerContext, string viewName, string masterName, string layoutPath, bool useCache) {
            //grab the current controller from the route data
            string controllerName = controllerContext.RouteData.GetRequiredString("controller");

            //for proper error handling we need to return a list of locations we attempted to search for the view
            string[] SearchedLocations;

            //get the actual path of the view - returns null if none is found
            string viewPath = GetViewPath(viewName, controllerName, out SearchedLocations);

            if (viewPath != null) {
                RazorView view = new RazorView(this, controllerContext, viewPath, layoutPath);
                return new ViewEngineResult(view, this);
            }

            //we couldn't find the view - return an array of all locations we've looked in
            return new ViewEngineResult(SearchedLocations);
        }

        /// <summary>
        /// Look for the view in the current file system
        /// </summary>
        /// <param name="viewName">The name of the View you're looking for</param>
        /// <param name="controllerName">Current controller name</param>
        /// <param name="SearchedLocations">out a list of locations searched</param>
        /// <returns>A string value of the relative path</returns>
        public string GetViewPath(string viewName, string controllerName, out string[] SearchedLocations) {
            return FindPath(viewName, controllerName, out SearchedLocations);
        }

        /// <summary>
        /// Look for the view in the current file system
        /// </summary>
        /// <param name="viewName">The name of the View you're looking for</param>
        /// <param name="controllerName">Current controller name</param>
        /// <param name="SearchedLocations">out a list of locations searched</param>
        /// <returns>A string value of the relative path</returns>
        public string FindPath(string viewName, string controllerName, out string[] SearchedLocations) {
            SearchedLocations = new string[SearchLocations.Length];

            for (int i = 0; i < SearchLocations.Length; i++) {
                string virtualPath = string.Format(SearchLocations[i], viewName, controllerName);

                SearchedLocations[i] = virtualPath;

                //check the active VirtualPathProvider if the file exists
                if (VirtualPathProvider.FileExists(virtualPath)) {
                    //add it to cache - not currently implemented
                    return VirtualPathProvider.GetFile(virtualPath).VirtualPath;
                }
            }

            return null;
        }

        /// <summary>
        /// Get the layout virtual path
        /// </summary>
        /// <param name="controllerContext">The current Controller context for this request</param>
        /// <returns>A string virtual path</returns>
        public string GetLayoutPath(ControllerContext controllerContext) {
            //This should probably be added to a list of locations - I'm not sure exactly
            //what I need to do with this yet.
            string[] locations;

            return FindPath("Layout", controllerContext.RouteData.GetRequiredString("controller"), out locations);
        }

        /// <summary>
        /// Current irrelevant
        /// </summary>
        /// <param name="controllerContext">The active controller context</param>
        /// <param name="view">View to release</param>
        public void ReleaseView(ControllerContext controllerContext, IView view) {
            IDisposable disposable = view as IDisposable;
            if (disposable != null) {
                disposable.Dispose();
            }
        }

        #endregion
    }

    /// <summary>
    /// Implements IView and renders a Razor
    /// </summary>
    public class RazorView : IView {

        ControllerContext ControllerContext;
        string ViewPath;
        string LayoutPath;
        RazorViewEngine Engine;

        public RazorView(RazorViewEngine engine, ControllerContext controllerContext, string viewPath, string layoutPath) {
            //load the file
            this.ControllerContext = controllerContext;
            this.ViewPath = viewPath;
            this.LayoutPath = layoutPath;
            this.Engine = engine;
        }

        #region IView Members

        /// <summary>
        /// Converts Razor to html and writes it to the passed in writer
        /// </summary>
        /// <param name="viewContext"></param>
        /// <param name="writer"></param>
        public void Render(ViewContext viewContext, System.IO.TextWriter writer) {
            //View contents
            string contents = new StreamReader(VirtualPathProvider.OpenFile(ViewPath)).ReadToEnd();
            string layoutContents = LayoutPath == null
                ? null
                : new StreamReader(VirtualPathProvider.OpenFile(LayoutPath)).ReadToEnd();

            contents = Parse(contents);

            string output;
            output = contents;

            writer.Write(output);
        }

        /// <summary>
        /// Converts Razor to html
        /// </summary>
        /// <param name="Razor">Razor text</param>
        /// <returns>Html formatted Razor text</returns>
        string Parse(string Razor) {

            //Where do I get the model From

            return RazorEngine.Razor.Parse(Razor);
        }

        #endregion
    }

}