Asp.net mvc 使用绑定框架在javascript包中包含MVC视图或字符串_Asp.net Mvc_Bundling And Minification_Virtualpathprovider

Asp.net mvc 使用绑定框架在javascript包中包含MVC视图或字符串

asp.net-mvc

Asp.net mvc 使用绑定框架在javascript包中包含MVC视图或字符串,asp.net-mvc,bundling-and-minification,virtualpathprovider,Asp.net Mvc,Bundling And Minification,Virtualpathprovider,我试图将几个javascript文件捆绑在一起，但我还需要在js中包含app.config中的一个变量我的想法是使用一个控制器返回一个字符串来设置变量，所以 ~/Javascript/Index将返回var foo=“bar”；这个很好用但是当我试图构建一个包时，静态文件被包括在内，但是字符串（或视图）没有显示出来。环顾四周，我发现优化框架仅限于静态文件，直到1.1版本实现了对VirtualPathProviders的支持我升级到了最新的软件包，但是我找不到任何关于如何将静态文件和控制器/

我试图将几个javascript文件捆绑在一起，但我还需要在js中包含app.config中的一个变量

我的想法是使用一个控制器返回一个字符串来设置变量，所以 ~/Javascript/Index将返回var foo=“bar”；这个很好用

但是当我试图构建一个包时，静态文件被包括在内，但是字符串（或视图）没有显示出来。环顾四周，我发现优化框架仅限于静态文件，直到1.1版本实现了对VirtualPathProviders的支持

我升级到了最新的软件包，但是我找不到任何关于如何将静态文件和控制器/视图生成的文件混合起来打包的信息。我想我只是想使用MVC路径提供程序

我的另一个想法是尝试使用捆绑引擎来构建捆绑静态文件的字符串，然后只附加我的字符串并将其全部返回到浏览器。但是，我找不到允许我使用捆绑引擎返回捆绑过程结果的方法。

将动态内容集成到捆绑过程需要以下步骤：

编写请求/构建所需内容的逻辑。直接从控制器生成内容需要一些工作：

public static class ControllerActionHelper
{
    public static string RenderControllerActionToString(string virtualPath)
    {
        HttpContext httpContext = CreateHttpContext(virtualPath);
        HttpContextWrapper httpContextWrapper = new HttpContextWrapper(httpContext);

        RequestContext httpResponse = new RequestContext()
        {
            HttpContext = httpContextWrapper,
            RouteData = RouteTable.Routes.GetRouteData(httpContextWrapper)
        };

        // Set HttpContext.Current if RenderActionToString is called outside of a request
        if (HttpContext.Current == null)
        {
            HttpContext.Current = httpContext;
        }

        IControllerFactory controllerFactory = ControllerBuilder.Current.GetControllerFactory();
        IController controller = controllerFactory.CreateController(httpResponse,
            httpResponse.RouteData.GetRequiredString("controller"));
        controller.Execute(httpResponse);

        return httpResponse.HttpContext.Response.Output.ToString();
    }

    private static HttpContext CreateHttpContext(string virtualPath)
    {
        HttpRequest httpRequest = new HttpRequest(string.Empty, ToDummyAbsoluteUrl(virtualPath), string.Empty);
        HttpResponse httpResponse = new HttpResponse(new StringWriter());

        return new HttpContext(httpRequest, httpResponse);
    }

    private static string ToDummyAbsoluteUrl(string virtualPath)
    {
        return string.Format("http://dummy.net{0}", VirtualPathUtility.ToAbsolute(virtualPath));
    }
}

实现一个虚拟路径提供程序，该提供程序包装现有的虚拟路径，并截获所有应传递动态内容的虚拟路径

public class ControllerActionVirtualPathProvider : VirtualPathProvider
{
    public ControllerActionVirtualPathProvider(VirtualPathProvider virtualPathProvider)
    {
        // Wrap an existing virtual path provider
        VirtualPathProvider = virtualPathProvider;
    }

    protected VirtualPathProvider VirtualPathProvider { get; set; }

    public override string CombineVirtualPaths(string basePath, string relativePath)
    {
        return VirtualPathProvider.CombineVirtualPaths(basePath, relativePath);
    }

    public override bool DirectoryExists(string virtualDir)
    {
        return VirtualPathProvider.DirectoryExists(virtualDir);
    }

    public override bool FileExists(string virtualPath)
    {
        if (ControllerActionHelper.IsControllerActionRoute(virtualPath))
        {
            return true;
        }

        return VirtualPathProvider.FileExists(virtualPath);
    }

    public override CacheDependency GetCacheDependency(string virtualPath, IEnumerable virtualPathDependencies,
        DateTime utcStart)
    {
        AggregateCacheDependency aggregateCacheDependency = new AggregateCacheDependency();

        List<string> virtualPathDependenciesCopy = virtualPathDependencies.Cast<string>().ToList();

        // Create CacheDependencies for our virtual Controller Action paths
        foreach (string virtualPathDependency in virtualPathDependenciesCopy.ToList())
        {
            if (ControllerActionHelper.IsControllerActionRoute(virtualPathDependency))
            {
                aggregateCacheDependency.Add(new ControllerActionCacheDependency(virtualPathDependency));
                virtualPathDependenciesCopy.Remove(virtualPathDependency);
            }
        }

        // Aggregate them with the base cache dependency for virtual file paths
        aggregateCacheDependency.Add(VirtualPathProvider.GetCacheDependency(virtualPath, virtualPathDependenciesCopy,
            utcStart));

        return aggregateCacheDependency;
    }

    public override string GetCacheKey(string virtualPath)
    {
        return VirtualPathProvider.GetCacheKey(virtualPath);
    }

    public override VirtualDirectory GetDirectory(string virtualDir)
    {
        return VirtualPathProvider.GetDirectory(virtualDir);
    }

    public override VirtualFile GetFile(string virtualPath)
    {
        if (ControllerActionHelper.IsControllerActionRoute(virtualPath))
        {
            return new ControllerActionVirtualFile(virtualPath,
                new MemoryStream(Encoding.Default.GetBytes(ControllerActionHelper.RenderControllerActionToString(virtualPath))));
        }

        return VirtualPathProvider.GetFile(virtualPath);
    }

    public override string GetFileHash(string virtualPath, IEnumerable virtualPathDependencies)
    {
        return VirtualPathProvider.GetFileHash(virtualPath, virtualPathDependencies);
    }

    public override object InitializeLifetimeService()
    {
        return VirtualPathProvider.InitializeLifetimeService();
    }
}

public class ControllerActionVirtualFile : VirtualFile
{
    public CustomVirtualFile (string virtualPath, Stream stream)
        : base(virtualPath)
    {
        Stream = stream;
    }

    public Stream Stream { get; private set; }

    public override Stream Open()
    {
         return Stream;
    }
}

注册虚拟路径提供程序：

public static void RegisterBundles(BundleCollection bundles)
{
    // Set the virtual path provider
    BundleTable.VirtualPathProvider = new ControllerActionVirtualPathProvider(BundleTable.VirtualPathProvider);

    bundles.Add(new Bundle("~/bundle")
        .Include("~/Content/static.js")
        .Include("~/JavaScript/Route1")
        .Include("~/JavaScript/Route2"));
}

可选：向视图添加Intellisense支持。在视图中使用

标记，并通过自定义ViewResult将其删除：

public class DynamicContentViewResult : ViewResult
{
    public DynamicContentViewResult()
    {
        StripTags = false;
    }

    public string ContentType { get; set; }

    public bool StripTags { get; set; }

    public string TagName { get; set; }

    public override void ExecuteResult(ControllerContext context)
    {
        if (context == null)
        {
            throw new ArgumentNullException("context");
        }

        if (string.IsNullOrEmpty(ViewName))
        {
            ViewName = context.RouteData.GetRequiredString("action");
        }

        ViewEngineResult result = null;

        if (View == null)
        {
            result = FindView(context);
            View = result.View;
        }

        string viewResult;

        using (StringWriter viewContentWriter = new StringWriter())
        {
            ViewContext viewContext = new ViewContext(context, View, ViewData, TempData, viewContentWriter);

            View.Render(viewContext, viewContentWriter);

            if (result != null)
            {
                result.ViewEngine.ReleaseView(context, View);
            }

            viewResult = viewContentWriter.ToString();

            // Strip Tags
            if (StripTags)
            {
                string regex = string.Format("<{0}[^>]*>(.*?)</{0}>", TagName);
                Match res = Regex.Match(viewResult, regex,
                    RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace | RegexOptions.Multiline | RegexOptions.Singleline);

                if (res.Success && res.Groups.Count > 1)
                {
                    viewResult = res.Groups[1].Value;
                }
                else
                {
                    throw new InvalidProgramException(
                        string.Format("Dynamic content produced by View '{0}' expected to be wrapped in '{1}' tag.", ViewName, TagName));
                }
            }
        }

        context.HttpContext.Response.ContentType = ContentType;
        context.HttpContext.Response.Output.Write(viewResult);
    }
}

这些步骤与其他类型的动态内容类似。例如，见

如果您想试用，我将概念验证存储库添加到了中。

将动态内容集成到捆绑过程中需要以下步骤：