public async Task <string> RenderRazorViewToString(string viewName, object model)
{
using (var sw = new StringWriter())
{
var actionContext = GetActionContext();
IViewEngine viewEngine = compositeViewEngine;
var viewResult = viewEngine.FindView(actionContext, viewName, false);
var viewContext = new ViewContext(
actionContext,
viewResult.View,
new ViewDataDictionary(
metadataProvider: new EmptyModelMetadataProvider(),
modelState: new ModelStateDictionary())
{
Model = model
},
new TempDataDictionary(
actionContext.HttpContext,
tempDataProvider),
sw,
new HtmlHelperOptions());
await viewResult.View.RenderAsync(viewContext);
return(sw.GetStringBuilder().ToString());
}
}
private async Task <OutputCacheModel> GenerateViewAsString(FilterContext context, ViewResult viewResult)
{
string viewName = viewResult.ViewName != null ? viewResult.ViewName : context.RouteData.Values["action"].ToString();
IViewEngine viewEngine = context.HttpContext.RequestServices.GetService(typeof(ICompositeViewEngine)) as ICompositeViewEngine;
ViewEngineResult viewEngineResult = viewEngine.FindView(context, viewName, true);
using (var writer = new StringWriter())
{
if (viewEngineResult.Success)
{
ViewContext viewContext = new ViewContext(context, viewEngineResult.View, viewResult.ViewData, viewResult.TempData, writer, new HtmlHelperOptions());
await viewEngineResult.View.RenderAsync(viewContext);
string content = writer.GetStringBuilder().ToString();
var outputCache = new OutputCacheModel()
{
Content = content,
ContentType = context.HttpContext.Response.ContentType,
StatusCode = context.HttpContext.Response.StatusCode
};
return(outputCache);
}
else
{
throw new FileNotFoundException($"A view with the name {viewName} could not be found");
}
}
}
public static string RenderRazorViewToString(Controller controller, string viewName, object model = null, GradutionProject.Data.ApplicationDbContext _context = null)
{
controller.ViewData.Model = model;
if (viewName == "ViewAllRegion")
{
controller.ViewBag.page = _context.Regions.Include(r => r.City).Include(a => a.Image).ToPagedList(1, 2);
}
else if (viewName == "ViewAllCategory")
{
controller.ViewBag.page = _context.Categories.ToPagedList(1, 2);
}
else if (viewName == "ViewAllCities")
{
controller.ViewBag.page = _context.Cities.ToPagedList(1, 2);
}
using (var sw = new StringWriter())
{
IViewEngine viewEngine = controller.HttpContext.RequestServices.GetService(typeof(ICompositeViewEngine)) as ICompositeViewEngine;
ViewEngineResult viewResult = viewEngine.FindView(controller.ControllerContext, viewName, false);
ViewContext viewContext = new ViewContext(
controller.ControllerContext,
viewResult.View,
controller.ViewData,
controller.TempData,
sw,
new HtmlHelperOptions()
);
viewResult.View.RenderAsync(viewContext);
return(sw.GetStringBuilder().ToString());
}
}
private static string RenderPartialViewToString(TextWriter writer, string viewName, object model, ViewContext viewContext, IViewEngine viewEngine)
{
if (string.IsNullOrEmpty(viewName))
{
throw new ArgumentException("viewName");
}
var context = new ControllerContext(viewContext);
ViewEngineResult viewResult = viewEngine.FindView(context, viewName, false);
if (viewResult.View == null)
{
throw new InvalidDataException(
string.Format("Specified view name for Grid.Mvc not found. ViewName: {0}", viewName));
}
var viewDictionary = new ViewDataDictionary(new EmptyModelMetadataProvider(), new ModelStateDictionary())
{
Model = model
};
var newViewContext = new ViewContext(
context,
viewResult.View,
viewDictionary,
viewContext.TempData,
writer,
new HtmlHelperOptions());
var task = viewResult.View.RenderAsync(newViewContext);
task.Wait();
return(writer.ToString());
}
public ViewEngineResult FindView(ControllerContext controllerContext, string viewName, string masterName, bool useCache)
{
using (ProfilerResolver.Current.Profiler.Step(string.Format("{0}.FindView, {1}, {2}, {3}", _name, viewName, masterName, useCache)))
{
return(WrapResult(_inner.FindView(controllerContext, viewName, masterName, useCache)));
}
}
public static async Task <string> RenderViewAsync <TModel>(this Controller controller, string viewname, TModel model, bool partial = false)
{
if (string.IsNullOrEmpty(viewname))
{
viewname = controller.ControllerContext.ActionDescriptor.ActionName;
}
controller.ViewData.Model = model;
using (var writer = new StringWriter())
{
IViewEngine viewengin = controller.HttpContext.RequestServices.GetService(typeof(ICompositeViewEngine)) as ICompositeViewEngine;
ViewEngineResult viewEngineResult = viewengin.FindView(controller.ControllerContext, viewname, !partial);
if (viewEngineResult.Success == false)
{
return($"Vista no encontrada {viewname}");
}
ViewContext viewContext = new ViewContext(controller.ControllerContext, viewEngineResult.View, controller.ViewData, controller.TempData, writer,
new Microsoft.AspNetCore.Mvc.ViewFeatures.HtmlHelperOptions());
await viewEngineResult.View.RenderAsync(viewContext);
return(writer.GetStringBuilder().ToString());
}
}
public static async Task <byte []> ViewToString(Controller controller, List <OrderItem> model)
{
controller.ViewData.Model = model;
using (var writer = new StringWriter())
{
IViewEngine viewEngine = controller.HttpContext.RequestServices.GetService(typeof(ICompositeViewEngine)) as ICompositeViewEngine;
ViewEngineResult viewResult = viewEngine.FindView(controller.ControllerContext, "Confirmation", false);
if (viewResult.Success == false)
{
throw new Exception("Could not find the page to convert into a PDF.");
}
ViewContext viewContext = new ViewContext(
controller.ControllerContext,
viewResult.View,
controller.ViewData,
controller.TempData,
writer,
new HtmlHelperOptions()
);
await viewResult.View.RenderAsync(viewContext);
var result = writer.GetStringBuilder().ToString();
HtmlToPdf renderer = new HtmlToPdf();
return(renderer.RenderHtmlAsPdf(result).BinaryData);
}
}
public static async Task <string> RenderViewAsync <TModel>(this Controller controller, string viewName, TModel model, bool partial = false)
{
if (string.IsNullOrEmpty(viewName))
{
viewName = controller.ControllerContext.ActionDescriptor.ActionName;
}
controller.ViewData.Model = model;
await using var writer = new StringWriter();
IViewEngine viewEngine = controller.HttpContext.RequestServices.GetService(typeof(ICompositeViewEngine)) as ICompositeViewEngine;
ViewEngineResult viewResult = viewEngine.FindView(controller.ControllerContext, viewName, !partial);
if (viewResult.Success == false)
{
return($"Una vista con el nombre de: {viewName} no se encuentra en el proyecto");
}
ViewContext viewContext = new ViewContext(
controller.ControllerContext,
viewResult.View,
controller.ViewData,
controller.TempData,
writer,
new HtmlHelperOptions()
);
await viewResult.View.RenderAsync(viewContext);
return(writer.GetStringBuilder().ToString());
}
public ViewEngineResult FindView(ControllerContext controllerContext, string viewName, string masterName,
bool useCache)
{
var result = _innerViewEngine.FindView(controllerContext, viewName, masterName, useCache);
return(CreateTracingViewEngineResult(result, viewName));
}
public ViewEngineResult FindView(ControllerContext controllerContext, string viewName, string masterName, bool useCache)
{
var result = inner.FindView(controllerContext, viewName, masterName, useCache);
AppendRazorViewPath(controllerContext, result);
return(result);
}
/// <summary>
/// Allows to parse selected view to string. Useful if partial view has to be send as parameter which contains
/// plain HTML code.
/// </summary>
/// <typeparam name="TModel"></typeparam>
/// <param name="controller"></param>
/// <param name="viewModel"></param>
/// <param name="viewName"></param>
/// <param name="isPartialView"></param>
/// <returns></returns>
public static async Task <string> ParseViewToStringAsync <TModel>(this Controller controller, TModel viewModel, string viewName, bool isPartialView)
{
using (var writer = new StringWriter())
{
IViewEngine viewEngine = controller.HttpContext.RequestServices.GetService(typeof(ICompositeViewEngine)) as ICompositeViewEngine;
ViewEngineResult viewResult = viewEngine.FindView(controller.ControllerContext, viewName, !isPartialView);
if (viewResult == null)
{
return(null);
}
var viewDictionary = new ViewDataDictionary(new EmptyModelMetadataProvider(), new ModelStateDictionary())
{
Model = viewModel
};
ViewContext viewContext = new ViewContext(
controller.ControllerContext,
viewResult.View,
viewDictionary,
controller.TempData,
writer,
new HtmlHelperOptions()
);
await viewResult.View.RenderAsync(viewContext);
return(writer.GetStringBuilder().ToString());
}
}
protected async Task <string> RenderViewAsync <TModel>(string viewName, TModel model, bool partial = false)
{
if (string.IsNullOrEmpty(viewName))
{
viewName = ControllerContext.ActionDescriptor.ActionName;
}
ViewData.Model = model;
using (var writer = new StringWriter())
{
IViewEngine viewEngine = HttpContext.RequestServices.GetService(typeof(ICompositeViewEngine)) as ICompositeViewEngine;
ViewEngineResult viewResult = viewEngine.FindView(ControllerContext, viewName, !partial);
if (!viewResult.Success)
{
return($"A view with the name {viewName} could not be found");
}
var viewContext = new ViewContext(
ControllerContext,
viewResult.View,
ViewData,
TempData,
writer,
new HtmlHelperOptions()
);
await viewResult.View.RenderAsync(viewContext);
return(writer.GetStringBuilder().ToString());
}
}
public static string RenderView(
this Controller controller,
string viewName,
object model,
bool partial = false)
{
controller.ViewBag.RenderPartial = partial;
if (string.IsNullOrEmpty(viewName))
{
viewName = controller.ControllerContext.ActionDescriptor.ActionName;
}
controller.ViewData.Model = model;
using (StringWriter stringWriter = new StringWriter())
{
IViewEngine service =
controller.HttpContext.RequestServices.GetService(typeof(ICompositeViewEngine)) as
ICompositeViewEngine;
if (service != null)
{
ViewEngineResult view = service.FindView(controller.ControllerContext, viewName, !partial);
if (!view.Success)
{
return("A view with the name " + viewName + " could not be found");
}
ViewContext viewContext = new ViewContext(controller.ControllerContext, view.View,
controller.ViewData, controller.TempData, stringWriter, new HtmlHelperOptions());
controller.ViewBag.RenderPartial = partial;
view.View.RenderAsync(viewContext).Wait();
}
return(stringWriter.GetStringBuilder().ToString());
}
}
public static async Task <string> RenderViewAsync <TModel>(this Controller controller, string viewName, TModel model, bool partial = false)
{
if (string.IsNullOrEmpty(viewName))
{
viewName = controller.ControllerContext.ActionDescriptor.ActionName;
}
IViewEngine viewEngine = controller.HttpContext.RequestServices.GetService(typeof(ICompositeViewEngine)) as ICompositeViewEngine;
ViewEngineResult viewResult = viewEngine.FindView(controller.ControllerContext, viewName, !partial);
if (viewResult.Success == false)
{
throw new ArgumentException($"A view with the name {viewName} could not be found");
}
controller.ViewData.Model = model;
using (var writer = new StringWriter())
{
ViewContext viewContext = new ViewContext(
controller.ControllerContext,
viewResult.View,
controller.ViewData,
controller.TempData,
writer,
new HtmlHelperOptions());
await viewResult.View.RenderAsync(viewContext);
return(writer.GetStringBuilder().ToString());
}
}
public static string RenderRazorViewToString(Controller controller, string viewName, object model = null)
{
controller.ViewData.Model = model;
using (var sw = new StringWriter())
{
IViewEngine viewEngine = controller.HttpContext.RequestServices.GetService(typeof(ICompositeViewEngine)) as ICompositeViewEngine;
if (viewEngine == null)
{
return(sw.GetStringBuilder().ToString());
}
var viewResult = viewEngine.FindView(controller.ControllerContext, viewName, false);
var viewContext = new ViewContext(
controller.ControllerContext,
viewResult.View,
controller.ViewData,
controller.TempData,
sw,
new HtmlHelperOptions()
);
viewResult.View.RenderAsync(viewContext);
return(sw.GetStringBuilder().ToString());
}
}
public ViewEngineResult FindView(ControllerContext controllerContext, string viewName, string masterName, bool useCache)
{
var engineResult = _engine.FindView(controllerContext, viewName, masterName, useCache);
InterceptEngineResult(engineResult);
return(engineResult);
}
public ViewEngineResult FindView(ActionContext context, string viewName, bool isMainPage)
{
using (_profiler.Step(string.Format("{0}.FindView, {1}, {2}", _name, viewName, isMainPage)))
{
return(WrapResult(Inner.FindView(context, viewName, isMainPage)));
}
}
public ViewEngineResult FindView(ControllerContext controllerContext, string viewName, string masterName, bool useCache)
{
if (IsAllowed(controllerContext))
{
return(inner.FindView(controllerContext, viewName, masterName, useCache));
}
return(new ViewEngineResult(Enumerable.Empty <string>()));
}
public ViewEngineResult FindView(ControllerContext controllerContext, string viewName, string masterName, bool useCache)
{
if (_predicate(controllerContext))
{
masterName = _masterNameProvider(masterName);
}
return(_innerViewEngine.FindView(controllerContext, viewName, masterName, useCache));
}
public ViewEngineResult FindView(ControllerContext controllerContext, string viewName, string masterName, bool useCache)
{
IViewEngine viewEngine = GetViewEngine(controllerContext);
if (viewEngine != null)
{
return(viewEngine.FindView(controllerContext, viewName, masterName, useCache));
}
return(new ViewEngineResult(new string[0]));
}
public ViewEngineResult FindView(ControllerContext controllerContext, string viewName, string masterName, bool useCache)
{
var found = wrapped.FindView(controllerContext, viewName, masterName, useCache);
if (found != null && found.View != null)
{
found = new ViewEngineResult(new WrappedView(found.View, viewName, isPartial: false), this);
}
return(found);
}
private static ViewEngineResult GetViewEngineResult(ControllerBase controller, string viewName, bool isPartial, IViewEngine viewEngine)
{
if (!viewName.StartsWith("~/"))
{
return(viewEngine.FindView(controller.ControllerContext, viewName, !isPartial));
}
var hostingEnv = controller.HttpContext.RequestServices.GetService(typeof(IWebHostEnvironment)) as
IWebHostEnvironment;
return(viewEngine.GetView(hostingEnv?.WebRootPath ?? Environment.WebRootPath, viewName, !isPartial));
}
public override string Render(AbstractNode node, object model)
{
var modelValueProviderFactory = Host.DependencyResolver.Resolve <IModelValueProviderFactory>();
if (node == null)
{
throw new ArgumentNullException("node");
}
var blockNode = node as Statement;
if (blockNode == null)
{
throw new InvalidCastException("node");
}
object localModel = model;
if (blockNode.Parameters != null && blockNode.Parameters.Any())
{
localModel = modelValueProviderFactory.Get(model.GetType()).GetValue(model, blockNode.Parameters.First().ValueType,
blockNode.Parameters.First().Value);
}
//get the parameter
string layout = "";
if (blockNode.Parameters != null && blockNode.Parameters.Any())
{
//assume only the first is the path
//second is the argument (model)
layout = blockNode.Parameters[0].Value;
}
//ok...we need to load the layoutpage
//then pass the node's children into the layout page
//then return the result
var result = _engine.FindView(null, layout, null, false);
if (result != null)
{
var parrotView = (result.View as ParrotView);
using (var stream = parrotView.LoadStream())
{
string contents = new StreamReader(stream).ReadToEnd();
var document = parrotView.LoadDocument(contents);
return(Host.DependencyResolver.Resolve <DocumentRenderer>().Render(document, localModel));
}
}
throw new InvalidOperationException();
}
public ViewEngineResult FindView(ControllerContext controllerContext, string viewName, string masterName, bool useCache)
{
if (_predicate(controllerContext))
{
var result = _innerViewEngine.FindView(controllerContext, _viewNameProvider(viewName), masterName, useCache);
if (result != null && result.View != null)
{
return(result);
}
}
return(new ViewEngineResult(new string[] { }));
}
public ViewEngineResult FindView(ControllerContext controllerContext, string viewName, string masterName, bool useCache)
{
var result =
baseViewEngine.FindView(controllerContext, viewName, masterName, useCache);
if (result.View != null)
{
return(new ViewEngineResult(new RazorXView(result.View), this));
}
return(result);
}
/// <summary>
/// Render a partial view to string.
/// </summary>
/// <typeparam name="TModel"></typeparam>
/// <param name="controller"></param>
/// <param name="viewNamePath"></param>
/// <param name="model"></param>
/// <returns></returns>
public static async Task <string> RenderViewToStringAsync <TModel>(this Controller controller,
string viewNamePath, TModel model)
{
if (string.IsNullOrEmpty(viewNamePath))
{
viewNamePath = controller.ControllerContext.ActionDescriptor.ActionName;
}
controller.ViewData.Model = model;
using (StringWriter writer = new StringWriter())
{
try
{
IViewEngine viewEngine =
controller.HttpContext.RequestServices.GetService(typeof(ICompositeViewEngine)) as
ICompositeViewEngine;
ViewEngineResult viewResult = null;
if (viewNamePath.EndsWith(".cshtml"))
{
viewResult = viewEngine.GetView(viewNamePath, viewNamePath, false);
}
else
{
viewResult = viewEngine.FindView(controller.ControllerContext, viewNamePath, false);
}
if (!viewResult.Success)
{
return($"A view with the name '{viewNamePath}' could not be found");
}
ViewContext viewContext = new ViewContext(
controller.ControllerContext,
viewResult.View,
controller.ViewData,
controller.TempData,
writer,
new HtmlHelperOptions()
);
await viewResult.View.RenderAsync(viewContext);
return(writer.GetStringBuilder().ToString());
}
catch (Exception exc)
{
return($"Failed - {exc.Message}");
}
}
}
/// <summary>
/// Finds the view with the given <paramref name="viewName"/> using view locations and information from the
/// <paramref name="context"/>.
/// </summary>
/// <param name="context">The <see cref="ActionContext"/>.</param>
/// <param name="viewName">The name of the view.</param>
/// <param name="isMainPage">Determines if the page being found is the main page for an action.</param>
/// <returns>The <see cref="ViewEngineResult"/> of locating the view.</returns>
public ViewEngineResult FindView(ActionContext context, string viewName, bool isMainPage)
{
using (MiniProfiler.Current.Step("Find: " + viewName))
{
var found = _wrapped.FindView(context, viewName, isMainPage);
if (found.View != null)
{
return(ViewEngineResult.Found(viewName, new WrappedView(found.View)));
}
return(found);
}
}
private ViewEngineResult GetViewEngineResult(string viewName, bool isPartial, IViewEngine viewEngine)
{
if (viewName.StartsWith("~/"))
{
var hostingEnv = HttpContext.RequestServices.GetService(typeof(IHostingEnvironment)) as IHostingEnvironment;
return(viewEngine.GetView(hostingEnv.WebRootPath, viewName, !isPartial));
}
else
{
return(viewEngine.FindView(ControllerContext, viewName, !isPartial));
}
}
private static ViewEngineResult GetViewEngineResult(Controller controller, string viewName, bool isPartial, IViewEngine viewEngine)
{
if (viewName.StartsWith("~/"))
{
var env = controller.HttpContext.RequestServices.GetService <IWebHostEnvironment>();
return(viewEngine.GetView(env.WebRootPath, viewName, !isPartial));
}
else
{
return(viewEngine.FindView(controller.ControllerContext, viewName, !isPartial));
}
}
public void Can_Create_View()
{
var routeData = new RouteData();
routeData.Values.Add("controller", "home");
var result = _viewEngine.FindView(new ControllerContext()
{
RouteData = routeData
}, "view", null, false);
Assert.IsNotNull(result.View);
}
private static IView FindView(IViewEngine viewEngine, ActionContext context, string viewName)
{
var result = viewEngine.FindView(context, viewName);
if (!result.Success)
{
var locations = string.Empty;
if (result.SearchedLocations != null)
{
locations = Environment.NewLine +
string.Join(Environment.NewLine, result.SearchedLocations);
}
throw new InvalidOperationException(Resources.FormatViewEngine_ViewNotFound(viewName, locations));
}
return result.View;
}
internal static IView FindPartialView(ViewContext viewContext, string partialViewName, IViewEngine viewEngine)
{
ViewEngineResult result = viewEngine.FindView(viewContext, partialViewName).Result;
if (result.View != null)
{
return result.View;
}
StringBuilder locationsText = new StringBuilder();
foreach (string location in result.SearchedLocations)
{
locationsText.AppendLine();
locationsText.Append(location);
}
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
"MvcResources.Common_PartialViewNotFound", partialViewName, locationsText));
}
