Come scaricare Razor View Engine

Question

Desidero scaricare e installare il motore di visualizzazione del rasoio per ASP.Net MVC 2. Da dove posso scaricare e installare?

Answer 1

forse un po 'datato, ma si dovrebbe forse dare un'occhiata a questo post.

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

Razor è in grado di funzionare in modo autonomo è del tutto possibile per fornire il cablaggio da soli. Se non hai bisogno di usare .NET4 o no non ne sono sicuro al 100%. In un'altra nota MVC3 è in stato RC e dispone di una licenza Go-Live che può essere tecnicamente avviata utilizzando ora e quando l'RTM raggiunge (presto) solo l'aggiornamento.

Answer 2

Razor is for MVC 3

Answer 3

Utilizzo di Matthew Abbott e My Razor View Engine di Codeplex. Potresti fare quanto segue Non supporta modelli o pagine di layout ma ti porterà nella direzione giusta se sceglierai di percorrere questa rotta. Francamente, vorrei solo aggiornare a MVC 3 quando il tempo è pronto. Questo codice è stato basato sul mio post sul blog a http://buildstarted.com/2010/11/22/making-your-own-viewengine-with-markdown/

Dovrete aggiungere la seguente riga al global.asax:

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

a meno che non si desidera entrambi i motori, nel qual caso è sufficiente rimuovere 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 
    } 

} 

Answer 4

Il modo migliore per ottenere un motore MVC Razor e imparare a usarlo è quello di Scot Gu! Il Guru dell'intero progetto Razor. Il suo post sul blog http://weblogs.asp.net/scottgu/archive/2010/10/22/asp-net-mvc-3-layouts.aspx è molto facile da seguire e ti insegna come gestire il processo di impalcatura dal gestore di pacchetti Consel in VS.