Où mettre de la vue spécifique des fichiers javascript en un ASP.NET application MVC?

Question

Quel est le meilleur endroit (dossier, etc) pour mettre de la vue spécifique des fichiers javascript en un ASP.NET application MVC?

Pour garder mon projet organisé, j'aimerais vraiment être en mesure de les mettre côte-à-côte avec la vue .fichiers aspx, mais je n'ai pas trouvé un bon moyen de faire référence à eux quand le faire sans s'exposer à l' ~/Views/Action/ structure de dossier. Est-ce vraiment une mauvaise chose de laisser les détails de la structure de dossier de fuite?

L'alternative est de le mettre dans ~/Scripts ou ~/dossiers de Contenu, mais une irritation mineure parce que maintenant j'ai à vous soucier de nom de fichier affrontements. C'est une irritation que je peux obtenir plus, mais, si c'est "la bonne chose".

Answer 1

Vieille question, mais je voulais mettre ma réponse au cas où quelqu'un d'autre vient les chercher.

Moi aussi je voulais mon point de vue spécifique js/css fichiers dans le dossier vues, et voici comment je l'ai fait:

Dans le web.dossier config à la racine de /points de Vue vous avez besoin de modifier deux sections pour permettre au serveur de servir les fichiers:

    <system.web>
        <httpHandlers>
            <add path="*.js" verb="GET,HEAD" type="System.Web.StaticFileHandler" />
            <add path="*.css" verb="GET,HEAD" type="System.Web.StaticFileHandler" />
            <add path="*" verb="*" type="System.Web.HttpNotFoundHandler"/>
        </httpHandlers>
        <!-- other content here -->
    </system.web>

    <system.webServer>
        <handlers>
            <remove name="BlockViewHandler"/>
            <add name="JavaScript" path="*.js" verb="GET,HEAD" type="System.Web.StaticFileHandler" />
            <add name="CSS" path="*.css" verb="GET,HEAD" type="System.Web.StaticFileHandler" />
            <add name="BlockViewHandler" path="*" verb="*" preCondition="integratedMode" type="System.Web.HttpNotFoundHandler" />
        </handlers>
        <!-- other content here -->
    </system.webServer>

Puis, à partir de votre fichier de vue, vous pouvez référencer l'url comme vous vous attendez à:

@Url.Content("~/Views/<ControllerName>/somefile.css")

Cela permettra de service de .js et .les fichiers css, et va interdire de servir à rien d'autre.

Answer 2

Une façon d'y parvenir est de fournir votre propre ActionInvoker. À l'aide du code fourni ci-dessous, vous pouvez ajouter à votre constructeur du contrôleur:

ActionInvoker = new JavaScriptActionInvoker();

Maintenant, chaque fois que vous placez un .js fichier suivant dans votre point de vue:

Vous pouvez y accéder directement:

http://yourdomain.com/YourController/Index.js

Ci-dessous est la source:

namespace JavaScriptViews {
    public class JavaScriptActionDescriptor : ActionDescriptor
    {
        private string actionName;
        private ControllerDescriptor controllerDescriptor;

        public JavaScriptActionDescriptor(string actionName, ControllerDescriptor controllerDescriptor)
        {
            this.actionName = actionName;
            this.controllerDescriptor = controllerDescriptor;
        }

        public override object Execute(ControllerContext controllerContext, IDictionary<string, object> parameters)
        {
            return new ViewResult();
        }

        public override ParameterDescriptor[] GetParameters()
        {
            return new ParameterDescriptor[0];
        }

        public override string ActionName
        {
            get { return actionName; }
        }

        public override ControllerDescriptor ControllerDescriptor
        {
            get { return controllerDescriptor; }
        }
    }

    public class JavaScriptActionInvoker : ControllerActionInvoker
    {
        protected override ActionDescriptor FindAction(ControllerContext controllerContext, ControllerDescriptor controllerDescriptor, string actionName)
        {
            var action = base.FindAction(controllerContext, controllerDescriptor, actionName);
            if (action != null)
            {
                return action;
            } 

            if (actionName.EndsWith(".js"))
            {
                return new JavaScriptActionDescriptor(actionName, controllerDescriptor);
            }

            else 
                return null;
        }
    }

    public class JavaScriptView : IView
    {
        private string fileName;

        public JavaScriptView(string fileName)
        {
            this.fileName = fileName;
        }

        public void Render(ViewContext viewContext, TextWriter writer)
        {
            var file = File.ReadAllText(viewContext.HttpContext.Server.MapPath(fileName));
            writer.Write(file);
        }
    }


    public class JavaScriptViewEngine : VirtualPathProviderViewEngine
    {
        public JavaScriptViewEngine()
            : this(null)
        {
        }

        public JavaScriptViewEngine(IViewPageActivator viewPageActivator)
            : base()
        {
            AreaViewLocationFormats = new[]
            {
                "~/Areas/{2}/Views/{1}/{0}.js",
                "~/Areas/{2}/Views/Shared/{0}.js"
            };
            AreaMasterLocationFormats = new[]
            {
                "~/Areas/{2}/Views/{1}/{0}.js",
                "~/Areas/{2}/Views/Shared/{0}.js"
            };
            AreaPartialViewLocationFormats = new []
            {
                "~/Areas/{2}/Views/{1}/{0}.js",
                "~/Areas/{2}/Views/Shared/{0}.js"
            };
            ViewLocationFormats = new[]
            {
                "~/Views/{1}/{0}.js",
                "~/Views/Shared/{0}.js"
            };
            MasterLocationFormats = new[]
            {
                "~/Views/{1}/{0}.js",
                "~/Views/Shared/{0}.js"
            };
            PartialViewLocationFormats = new[]
            {
                "~/Views/{1}/{0}.js",
                "~/Views/Shared/{0}.js"
            };
            FileExtensions = new[]
            {
                "js"
            };
        }

        public override ViewEngineResult FindView(ControllerContext controllerContext, string viewName, string masterName, bool useCache)
        {
            if (viewName.EndsWith(".js"))
                viewName = viewName.ChopEnd(".js");
            return base.FindView(controllerContext, viewName, masterName, useCache);
        }


        protected override IView CreatePartialView(ControllerContext controllerContext, string partialPath)
        {
            return new JavaScriptView(partialPath);
        }

        protected override IView CreateView(ControllerContext controllerContext, string viewPath, string masterPath)
        {
            return new JavaScriptView(viewPath);
        }
    }
}

Answer 3

Vous pouvez inverser davesw de la suggestion et de bloquer uniquement .cshtml

<httpHandlers>
    <add path="*.cshtml" verb="*" type="System.Web.HttpNotFoundHandler"/>
</httpHandlers>