example - c# razorengine

Problemas con RazorEngine con @Html

Question

Estoy usando RazorEngine para renderizar algunos contenidos básicos (un sistema de gestión de contenidos muy tosco).

Funciona de maravilla hasta que incluya cualquier sintaxis de @Html en el marcado.

Si el marcado contiene un @html, aparece el siguiente error:

No se puede compilar la plantilla. El nombre ''Html'' no existe en el contexto actual

Esta es la vista que representa el marcado:

@Model Models.ContentPage

@{
    ViewBag.Title = Model.MetaTitle;
    Layout = "~/Views/Shared/Templates/_" + Model.Layout + "Layout.cshtml";

}
@Html.Raw(RazorEngine.Razor.Parse(Model.Markup, Model))

He visto en el sitio de Codeplex para RazorEngine el uso de @Html (sé que la versión no está actualizada y obtuve mi versión a través de nuget).

Cualquier ayuda con esto sería genial.

Answer 1

Es una pregunta bastante antigua, pero encontré una buena respuesta en coderwall . La solución es usar:

@(new RawString("<strong>Bold!</strong>"))

o solo:

@(new RawString(Model.YourHTMLStrinInModel))

Espero que sea útil.

Answer 2

Esto tiene más de un año, pero como no he encontrado una copia de trabajo en Internet y la página github está inactiva, pensé que compartiría mi implementación para agregar la sintaxis de @Html helper a RazorEngine. Aquí está la implementación con la que terminé, usando la implementación de Abu Haider como punto de partida.

Cortesía del comentario de miketrash: si intentas usar @ Html.Action (), necesitarás agregar RequestContext (puedes usar HttpContext.Current.Request.RequestContext ). No incluí el contexto de solicitud porque no siempre está disponible para mi aplicación.

[RequireNamespaces("System.Web.Mvc.Html")]
public class HtmlTemplateBase<T>:TemplateBase<T>, IViewDataContainer
{
    private HtmlHelper<T> helper = null;
    private ViewDataDictionary viewdata = null;       

    public HtmlHelper<T> Html
    {
        get
        {
            if (helper == null) 
            {                  
                var writer = this.CurrentWriter; //TemplateBase.CurrentWriter
                var vcontext = new ViewContext() { Writer = writer, ViewData = this.ViewData};

                helper = new HtmlHelper<T>(vcontext, this);
            }
            return helper;
        }
    }

    public ViewDataDictionary ViewData
    {
        get
        {
            if (viewdata == null)
            {
                viewdata = new ViewDataDictionary();
                viewdata.TemplateInfo = new TemplateInfo() { HtmlFieldPrefix = string.Empty };

                if (this.Model != null)
                {
                    viewdata.Model = Model;
                }
            }
            return viewdata;
        }
        set
        {
            viewdata = value;
        }
    }

    public override void WriteTo(TextWriter writer, object value)
    {
        if (writer == null)
            throw new ArgumentNullException("writer");

        if (value == null) return;

        //try to cast to RazorEngine IEncodedString
        var encodedString = value as IEncodedString;
        if (encodedString != null)
        {
            writer.Write(encodedString);
        }
        else
        {
            //try to cast to IHtmlString (Could be returned by Mvc Html helper methods)
            var htmlString = value as IHtmlString;
            if (htmlString != null) writer.Write(htmlString.ToHtmlString());
            else
            {
                //default implementation is to convert to RazorEngine encoded string
                encodedString = TemplateService.EncodedStringFactory.CreateEncodedString(value);
                writer.Write(encodedString);
            }

        }
    }
}

También tuve que anular el método WriteTo de TemplateBase , porque de lo contrario RazorEngine codificará html el resultado del método helper lo que significa que escapará de ''<'', ''>'' y comillas (vea esta pregunta ). La anulación agrega una comprobación para que el valor sea un IHtmlString antes de recurrir a la realización de una codificación.

Answer 3

Las propiedades helper Html y Url son características reales de la implementación de Razor de MVC en su motor de visualización. Fuera de la caja, Html y Url no son compatibles actualmente sin especializar una plantilla base personalizada.

La próxima versión de v3 estará acompañada por una versión asociada de RazorEngine.Web, que con suerte incluirá una plantilla base compatible con MVC3 con compatibilidad para Html y Url .

El ejemplo que escribí en la página de inicio del proyecto es puramente un ejemplo del uso de una plantilla base personalizada.

Puede encontrar más información sobre v3 en https://github.com/Antaris/RazorEngine

Answer 4

Mis disculpas, no tengo la reputación requerida de 50 para agregar un comentario, así que tengo que poner una respuesta.

Si alguien se está preguntando (como JamesStuddart), falta el método SetTemplateBase (), pero puede crear una instancia de configuración para inicializar un servicio con su plantilla base.

Desde http://razorengine.codeplex.com/discussions/285937 he adaptado mi código para que se vea así:

var config = new RazorEngine.Configuration.TemplateServiceConfiguration
        {
            BaseTemplateType = typeof(MyHtmlTemplateBase<>)
        };

        using (var service = new RazorEngine.Templating.TemplateService(config))
        {
            // Use template service.
            Razor.SetTemplateService(service);
            result = Razor.Parse(templateString, model);
        }

Answer 5

Modificación de la respuesta mao47 para la última sintaxis de la afeitadora, esto también admitirá vistas parciales.

using System;
using System.Collections.Concurrent;
using System.IO;
using System.Linq;
using System.Web.Hosting;
using System.Xml.Linq;
using RazorEngine.Configuration;
using RazorEngine.Templating;
public static class DynamicRazorTemplateParser
    {
        private static readonly IRazorEngineService service = RazorEngineService.Create(TemplateServiceConfiguration);
        public static string RunCompile<T>(string template, string placeholder, T model, DynamicViewBag viewBag) where T : class
        {
            var templateSource = new LoadedTemplateSource(template);
            return RunCompile(templateSource, placeholder, model, viewBag);
        }
        public static string RunCompile<T>(ITemplateSource template, string placeholder, T model, DynamicViewBag viewBag) where T : class 
        {            
                return service.RunCompile(template, placeholder, model.GetType(), model, viewBag);
        }
        public static string RunCompile(ITemplateSource template, string placeholder)
        {


                return service.RunCompile(template, placeholder);

        }

        private static TemplateServiceConfiguration TemplateServiceConfiguration
        {
            get
            {
                var config = new TemplateServiceConfiguration
                {
                    BaseTemplateType = typeof(HtmlTemplateBase<>),
                    TemplateManager = new TemplateManager()
                };
                //TODO: Is this the best way?
                var xDocument = XDocument.Load(AppDomain.CurrentDomain.SetupInformation.ApplicationBase + "/Views/Web.config");
                if (xDocument.Root != null)
                {
                    var sysWeb = xDocument.Root.Element("system.web.webPages.razor");
                    if (sysWeb == null) return config;
                    var pages = sysWeb.Element("pages");
                    if (pages != null)
                    {
                        var namespaces = pages.Element("namespaces");
                        if (namespaces != null)
                        {
                            var namespacesAdd = namespaces.Elements("add")
                                .Where(x => x.Attribute("namespace") != null)
                                .Select(x =>

                                    x.Attribute("namespace").Value
                                );
                            foreach (var ns in namespacesAdd)
                            {
                                config.Namespaces.Add(ns);
                            }
                        }
                    }
                }
                return config;
            }
        }
        private class TemplateManager : ITemplateManager
        {
            private readonly ConcurrentDictionary<ITemplateKey, ITemplateSource> _dynamicTemplates = new ConcurrentDictionary<ITemplateKey, ITemplateSource>();
            private readonly string baseTemplatePath;
            public TemplateManager()
            {
                baseTemplatePath = HostingEnvironment.MapPath("~/Views/");
            }

            public ITemplateSource Resolve(ITemplateKey key)
            {
                ITemplateSource templateSource;
                if (this._dynamicTemplates.TryGetValue(key, out templateSource))
                    return templateSource;

                string template = key.Name;
                var ubuilder = new UriBuilder();
                ubuilder.Path = template;
                var newURL = ubuilder.Uri.LocalPath.TrimStart(''/'');
                string path = Path.Combine(baseTemplatePath, string.Format("{0}", newURL));


                string content = File.ReadAllText(path);
                return new LoadedTemplateSource(content, path);
            }

            public ITemplateKey GetKey(string name, ResolveType resolveType, ITemplateKey context)
            {
                return new NameOnlyTemplateKey(name, resolveType, context);
            }

            public void AddDynamic(ITemplateKey key, ITemplateSource source)
            {
                this._dynamicTemplates.AddOrUpdate(key, source, (k, oldSource) =>
                {
                    if (oldSource.Template != source.Template)
                        throw new InvalidOperationException("The same key was already used for another template!");
                    return source;
                });
            }
        }
    }


using System;
using System.IO;
using System.Web;
using System.Web.Mvc;
using System.Web.Routing;
using RazorEngine.Templating;
using RazorEngine.Text;
// ReSharper disable ClassWithVirtualMembersNeverInherited.Global
// ReSharper disable MemberCanBePrivate.Global

namespace Common.Core.Razor
{
    [RequireNamespaces("System.Web.Mvc.Html")]
    public class HtmlTemplateBase<T> : RazorEngine.Templating.HtmlTemplateBase<T>, IViewDataContainer
    {
        private HtmlHelper<T> helper;
        private ViewDataDictionary viewdata;
        private TempDataDictionary tempdata;
        private AjaxHelper<T> ajaxHelper;
        private ViewContext viewContext;
        private UrlHelper urlHelper;
        private readonly RequestContext _requestContext = HttpContext.Current.Request.RequestContext;


        public UrlHelper Url => urlHelper ?? (urlHelper = new UrlHelper(_requestContext));

        public ViewContext ViewContext
        {
            get
            {
                if (viewContext != null) return viewContext;
                viewContext = GetViewContext();
                return viewContext;
            }
        }

        public AjaxHelper<T> Ajax
        {
            get
            {
                if (ajaxHelper != null) return ajaxHelper;
                ajaxHelper = new AjaxHelper<T>(ViewContext, this);
                return ajaxHelper;
            }
        }

        public HtmlHelper<T> Html
        {
            get
            {
                if (helper != null) return helper;
                helper = new HtmlHelper<T>(ViewContext, this);
                return helper;
            }
        }

        public ViewDataDictionary ViewData
        {
            get
            {
                if (viewdata == null)
                {
                    viewdata = new ViewDataDictionary
                    {
                        TemplateInfo = new TemplateInfo() { HtmlFieldPrefix = string.Empty }
                    };

                    if (Model != null)
                    {
                        viewdata.Model = Model;
                    }
                }
                return viewdata;
            }
            set
            {
                viewdata = value;
            }
        }
        public TempDataDictionary TempData
        {
            get { return tempdata ?? (tempdata = new TempDataDictionary()); }
            set
            {
                tempdata = value;
            }
        }
        public virtual string RenderView()
        {
            using (var writer = new StringWriter())
            {
                ViewContext.View.Render(ViewContext, CurrentWriter);
                return writer.GetStringBuilder().ToString();
            }
        }


        private ViewContext GetViewContext()
        {
            if (HttpContext.Current == null) throw new NotImplementedException();
            var requestContext = _requestContext;
            var controllerContext = ControllerContext(requestContext);

            var view = GetView(requestContext, controllerContext);
            //Can''t check if string writer is closed, need to catch exception
            try
            {
                var vContext = new ViewContext(controllerContext, view, ViewData, TempData, CurrentWriter);
                return vContext;

            }
            catch
            {
                using (var sw = new StringWriter())
                {
                    var vContext = new ViewContext(controllerContext, view, ViewData, TempData, sw);
                    return vContext;
                }
            }
        }

        private IView GetView(RequestContext requestContext, ControllerContext controllerContext)
        {
            if ((string)requestContext.RouteData.DataTokens["Action"] != null)
            {
                requestContext.RouteData.Values["action"] = (string)requestContext.RouteData.DataTokens["Action"];
            }

            var action = requestContext.RouteData.GetRequiredString("action");
            var viewEngineResult = ViewEngines.Engines.FindPartialView(controllerContext, action);
            if (viewEngineResult != null && viewEngineResult.View != null)
            {
                return viewEngineResult.View;
            }

            viewEngineResult = ViewEngines.Engines.FindView(controllerContext, action, null);
            if (viewEngineResult == null)
            {
                throw new Exception("No PartialView assigned in route");
            }
            return viewEngineResult.View;


        }

        public void SetView(string view)
        {
            _requestContext.RouteData.DataTokens["Action"] = view;
        }


        private ControllerContext ControllerContext(RequestContext requestContext)
        {
            ControllerBase controllerBase;
            var routeDataValue = "EmptyController";
            if (requestContext.RouteData.Values["controller"] != null && (string)requestContext.RouteData.Values["controller"] != routeDataValue)
            {
                var controllerName = (string)requestContext.RouteData.Values["controller"];
                IController controller = ControllerBuilder.Current.GetControllerFactory().CreateController(requestContext, controllerName);
                controllerBase = controller as ControllerBase;
            }
            else
            {

                var controller = new EmptyController();
                controllerBase = controller; //ControllerBase implements IController which this returns
                requestContext.RouteData.Values["controller"] = routeDataValue;
            }
            var controllerContext =
                new ControllerContext(requestContext.HttpContext, requestContext.RouteData, controllerBase);
            return controllerContext;
        }
        private class EmptyController : Controller { }
        public override void WriteTo(TextWriter writer, object value)
        {
            if (writer == null)
                throw new ArgumentNullException("writer");

            if (value == null) return;

            //try to cast to RazorEngine IEncodedString
            var encodedString = value as IEncodedString;
            if (encodedString != null)
            {
                writer.Write(encodedString);
            }
            else
            {
                //try to cast to IHtmlString (Could be returned by Mvc Html helper methods)
                var htmlString = value as IHtmlString;
                if (htmlString != null) writer.Write(htmlString.ToHtmlString());
                else
                {
                    //default implementation is to convert to RazorEngine encoded string
                    base.WriteTo(writer, value);

                }

            }
        }
    }
}

Answer 6

Solución Html.Raw Simplest !! 3 pasos necesarios

Paso 1: heredad de TemplateBase:

public class HtmlSupportTemplateBase<T> : TemplateBase<T>
{
    public HtmlSupportTemplateBase()
    {
        Html = new MyHtmlHelper();
    }

    public MyHtmlHelper Html { get; set; }

}

Paso 2: crea un objeto que ponga a disposición todos los métodos Html consumidos por tu plantilla. En este ejemplo, Html.Raw y Html.Encode están disponibles en cshtml. modelo

public class MyHtmlHelper
{
    /// <summary>
    /// Instructs razor to render a string without applying html encoding.
    /// </summary>
    /// <param name="htmlString"></param>
    /// <returns></returns>
    public IEncodedString Raw(string htmlString)
    {
        return new RawString(htmlString);
    }

    public string Encode(string value)
    {
        return System.Net.WebUtility.HtmlEncode(value);
    }

    public string Encode(object value)
    {
        return "do whatever";
    }
}

Paso 3:

var config = new TemplateServiceConfiguration
{
    TemplateManager = templateManager,
    BaseTemplateType = typeof(HtmlSupportTemplateBase<>)
};

Answer 7

Verifique https://github.com/Antaris/RazorEngine/wiki/6.-Encoding-Values page. Lo copio / lo paso aquí:

Por defecto, RazorEngine está configurado para codificar como HTML. Esto a veces presenta problemas donde ciertos caracteres están codificados como HTML cuando se quería que el resultado fuera tal como está.

Para mostrar algo en formato sin formato, use el método incorporado @Raw () como se muestra en el siguiente ejemplo:

string template = "@Raw(Model.Data)";
var model = new { Data = "My raw double quotes appears here /"hello!/"" };

string result = Razor.Parse(template, model);

Que debería resultar en:

My raw double quotes appears here "hello!"