agrupación/minificación ASP.NET: incluyendo Javascript generado dinámicamente

Question

Tengo un sitio que genera Javascript de forma dinámica. El código generado describe metadatos de tipo y algunas constantes del lado del servidor para que los clientes puedan consumir fácilmente los servicios del servidor, por lo que es muy caché.

El Javascript generado es servido por un controlador ASP.NET MVC; entonces tiene un Uri; decir ~/MyGeneratedJs.

Me gustaría incluir este Javascript en un paquete de Javascript con otros archivos Javascript estáticos (por ejemplo, jQuery, etc.): así como los archivos estáticos quiero que se mencionen por separado en modo de depuración y en formato reducido junto con el otro archivos en modo sin depuración.

¿Cómo puedo incluir Javascript generado dinámicamente en un paquete?

Answer 1

Darin tiene razón, actualmente el agrupamiento solo funciona en archivos estáticos. Pero si puede agregar un archivo de marcador de posición con contenido actualizado, la agrupación configura notificaciones de cambio de archivo que se detectarán automáticamente cuando cambie el archivo de marcador de posición.

También vamos a pasar a utilizar VirtualPathProviders pronto, que podría ser una forma de servir contenido generado dinámicamente.

Actualización: La versión 1.1-alfa 1 es ahora el que tiene soporte para VPP

Answer 2

Esto no es posible. Los paquetes solo funcionan con archivos estáticos.

Answer 3

Con VirtualPathProviders esto es ahora posible. La integración de contenido dinámico en el proceso de agrupación requiere los siguientes pasos:

1. Escribiendo la lógica que solicita/crea el contenido requerido. La generación de contenido de controlador directamente requiere un poco de trabajo:

   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)); 
       } 
   } 
   

2. Implementar un proveedor de ruta de acceso virtual que envuelve la existente e interceptar todos los caminos virtuales que debe entregar el contenido dinámico.

   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; 
       } 
   } 
   

   también hay que poner en práctica CacheDependency si lo necesita:

   public class ControllerActionCacheDependency : CacheDependency 
   { 
       public ControllerActionCacheDependency(string virtualPath, int actualizationTime = 10000) 
       { 
        VirtualPath = virtualPath; 
        LastContent = GetContentFromControllerAction(); 
   
        Timer = new Timer(CheckDependencyCallback, this, actualizationTime, actualizationTime); 
       } 
   
       private string LastContent { get; set; } 
   
       private Timer Timer { get; set; } 
   
       private string VirtualPath { get; set; } 
   
       protected override void DependencyDispose() 
       { 
        if (Timer != null) 
        { 
         Timer.Dispose(); 
        } 
   
        base.DependencyDispose(); 
       } 
   
       private void CheckDependencyCallback(object sender) 
       { 
        if (Monitor.TryEnter(Timer)) 
        { 
         try 
         { 
          string contentFromAction = GetContentFromControllerAction(); 
   
          if (contentFromAction != LastContent) 
          { 
           LastContent = contentFromAction; 
           NotifyDependencyChanged(sender, EventArgs.Empty); 
          } 
         } 
         finally 
         { 
          Monitor.Exit(Timer); 
         } 
        } 
       } 
   
       private string GetContentFromControllerAction() 
       { 
        return ControllerActionHelper.RenderControllerActionToString(VirtualPath); 
       } 
   } 
   

3. Registra tu proveedor de ruta de acceso virtual:

   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")); 
   } 
   

4. Opcional: Añadir soporte Intellisense a sus puntos de vista. Utilice <script> etiquetas dentro de su vista y dejar que ser retirados por un ViewResult personalizado:

   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); 
       } 
   } 
   

   utilizar un método de extensión o agregar una función auxiliar para su controlador:

   public static DynamicContentViewResult JavaScriptView(this Controller controller, string viewName, string masterName, object model) 
   { 
       if (model != null) 
       { 
        controller.ViewData.Model = model; 
       } 
   
       return new DynamicContentViewResult 
       { 
        ViewName = viewName, 
        MasterName = masterName, 
        ViewData = controller.ViewData, 
        TempData = controller.TempData, 
        ViewEngineCollection = controller.ViewEngineCollection, 
        ContentType = "text/javascript", 
        TagName = "script", 
        StripTags = true 
       }; 
   } 
   

Los pasos son similiar para otro tipo de contenido dinámico. Ver Bundling and Minification and Embedded Resources por ejemplo.

He añadido un repositorio de prueba de concepto al GitHub si quieres probarlo.