More
and more I’m finding myself getting lost in the
files in some of my larger Web projects. There’s so much freaking content to deal with – HTML Views, several derived CSS pages, page level CSS, script libraries, application wide scripts
and page specific script
files etc. etc. Thankfully I use Resharper
and the Ctrl-T Go to Anything which autocompletes you to any file, type, member rapidly. Awesome except when I forget – or when I’m not quite sure of the name of what I’m looking for. Project navigation is still important. Sometimes while working on a project I seem to have 30 or more
files open
and trying to locate another new file to open in the solution often ends up being a mental exercise – “where did I put that thing?” It’s those little hesitations that tend to get in the way of workflow frequently. To make things worse most NuGet packages for client side frameworks
and scripts, dump stuff into folders that I generally don’t use. I’ve never been a fan of the ‘Content’
folder in MVC which is just an empty layer that doesn’t serve much of a purpose. It’s usually the first thing I nuke in every MVC project. To me the project root is where the actual content for a site goes – is there really a need to add another
folder to force another path into every resource you use? It’s ugly
and also inefficient as it adds additional bytes to every resource link you embed into a page. Alternatives I’ve been playing around with different
folder layouts recently
and found that moving my cheese around has actually made project navigation much easier. In this post I show a couple of things I’ve found useful
and maybe you find some of these useful as well or at least get some ideas what can be changed to provide better project flow. The first thing I’ve been doing is add a root Code
folder and putting all server code into that. I’m a big fan of treating the Web project root
folder as my Web root
folder so all content comes from the root without unneeded nesting like the Content
folder. By moving all server code out of the root tree (except for Code) the root tree becomes a lot cleaner immediately as you remove Controllers, App_Start, Models etc.
and move them underneath Code. Yes this adds another
folder level for server code, but it leaves only code related things in one place that’s easier to jump back
and forth in. Additionally I find myself doing a lot less with server side code these days, more with client side code so I want the server code separated from that. The root
folder itself then serves as the root content
folder. Specifically I have the Views
folder below it, as well as the Css
and Scripts folders which serve to hold only common libraries
and global CSS
and Scripts code. These days of building SPA style application, I also tend to have an App
folder there where I keep my application specific JavaScript
files, as well as HTML View templates for client SPA apps like Angular. Here’s an example of what this looks like in a relatively small project: The goal is to keep things that are related together, so I don’t end up jumping around so much in the solution to get to specific project items. The Code
folder may irk some of you
and hark back to the days of the App_Code
folder in non Web-Application projects, but these days I find myself messing with a lot less server side code
and much more with client side
files – HTML, CSS
and JavaScript. Generally I work on a single controller at a time – once that’s open it’s open that’s typically the only server code I work with regularily. Business logic lives in another project altogether, so other than the controller
and maybe ViewModels there’s not a lot of code being accessed in the Code
folder. So throwing that off the root
and isolating seems like an easy win. Nesting Page specific content In a lot of my existing applications that are pure server side MVC application perhaps with some JavaScript associated with them , I tend to have page level javascript
and css
files. For these types of pages I actually prefer the local
files stored in the same
folder as the parent view. So typically I have a .css
and .js
files with the same name as the view in the same
folder. This looks something like this: In order for this to work you have to also make a configuration change inside of the /Views/web.config file, as the Views
folder is blocked with the BlockViewHandler that prohibits access to content from that
folder. It’s easy to fix by changing the path from * to *.cshtml or *.vbhtml so that view retrieval is blocked:<system.webServer>
<handlers>
<remove name="BlockViewHandler"/>
<add name="BlockViewHandler" path="*.cshtml" verb="*" preCondition="integratedMode" type="System.Web.HttpNotFoundHandler" />
</handlers>
</system.webServer>
With this in place, from inside of your Views you can then reference those same resources like this:<link href="~/Views/Admin/QuizPrognosisItems.css" rel="stylesheet" />
and<script src="~/Views/Admin/QuizPrognosisItems.js"></script>
which works fine. JavaScript
and CSS
files in the Views
folder deploy just like the .cshtml
files do
and can be referenced from this
folder as well.
Making this happen is not really as straightforward as it should be with just Visual Studio unfortunately, as there’s no easy way to get the file nesting from the VS IDE directly (you have to modify the .csproj file).
However, Mads Kristensen has a nice Visual Studio Add-in that provides file nesting via a short cut menu option. Using this you can select each of the ‘child’
files and then nest them under a parent file. In the case above I select the .js
and .css
files and nest them underneath the .cshtml view.
I was even toying with the idea of throwing the controller.cs
files into the Views
folder, but that’s maybe going a little too far :-) It would work however as Visual Studio doesn’t publish .cs
files and the compiler doesn’t care where the
files live. There are lots of options
and if you think that would make life easier it’s another option to help group related things together.
Are there any downside to this? Possibly – if you’re using automated minification/packaging tools like ASP.NET Bundling or Grunt/Gulp with Uglify, it becomes a little harder to group script
and css
files for minification as you may end up looking in multiple folders instead of a single
folder. But – again that’s a one time configuration step that’s easily handled
and much less intrusive then constantly having to search for
files in your project.
Client Side Folders
The particular project shown above in the screen shots above is a traditional server side ASP.NET MVC application with most content rendered into server side Razor pages. There’s a fair amount of client side stuff happening on these pages as well – specifically several of these pages are self contained single page Angular applications that deal with 1 or maybe 2 separate views
and the layout I’ve shown above really focuses on the server side aspect where there are Razor views with related script
and css resources.
For applications that are more client centric
and have a lot more script
and HTML template based content I tend to use the same layout for the server components, but the client side code can often be broken out differently.
In SPA type applications I tend to follow the App
folder approach where all the application pieces that make the SPA applications end up below the App
folder.
Here’s what that looks like for me – here this is an AngularJs project:
In this case the App
folder holds both the application specific js
files,
and the partial HTML views that get loaded into this single SPA page application.
In this particular Angular SPA application that has controllers linked to particular partial views, I prefer to keep the script
files that are associated with the views – Angular Js Controllers in this case – with the actual partials. Again I like the proximity of the view with the main code associated with the view, because 90% of the UI application code that gets written is handled between these two
files.
This approach works well, but only if controllers are fairly closely aligned with the partials. If you have many smaller sub-controllers or lots of directives where the alignment between views
and code is more segmented this approach starts falling apart
and you’ll probably be better off with separate folders in js
folder. Following Angular conventions you’d have controllers/directives/services etc. folders.
Please note that I’m not saying any of these ways are right or wrong – this is just what has worked for me
and why!
Skipping Project Navigation altogether with Resharper
I’ve talked a bit about project navigation in the project tree, which is a common way to navigate
and which we all use at least some of the time, but if you use a tool like Resharper – which has Ctrl-T to jump to anything, you can quickly navigate with a shortcut key
and autocomplete search.
Here’s what Resharper’s jump to anything looks like:
Resharper’s Goto Anything box lets you type
and quick search over
files, classes
and members of the entire solution which is a very fast
and powerful way to find what you’re looking for in your project, by passing the solution explorer altogether. As long as you remember to use (which I sometimes don’t)
and you know what you’re looking for it’s by far the quickest way to find things in a project. It’s a shame that this sort of a simple search interface isn’t part of the native Visual Studio IDE.
Work how you like to work
Ultimately it all comes down to workflow
and how you like to work,
and what makes *you* more productive. Following pre-defined patterns is great for consistency, as long as they don’t get in the way you work. A lot of the default
folder structures in Visual Studio for ASP.NET MVC were defined when things were done differently. These days we’re dealing with a lot more diverse project content than when ASP.NET MVC was originally introduced
and project organization definitely is something that can get in the way if it doesn’t fit your workflow. So take a look
and see what works well
and what might benefit from organizing
files differently.
As so many things with ASP.NET, as things evolve
and tend to get more complex I’ve found that I end up fighting some of the conventions. The good news is that you don’t have to follow the conventions
and you have the freedom to do just about anything that works for you.
Even though what I’ve shown here diverges from conventions, I don’t think anybody would stumble over these relatively minor changes
and not immediately figure out where things live, even in larger projects. But nevertheless think long
and hard before breaking those conventions – if there isn’t a good reason to break them or the changes don’t provide improved workflow then it’s not worth it. Break the rules, but only if there’s a quantifiable benefit.
You may not agree with how I’ve chosen to divert from the standard project structures in this article, but maybe it gives you some ideas of how you can mix things up to make your existing project flow a little nicer
and make it easier to navigate for your environment. © Rick Strahl, West Wind Technologies, 2005-2014Posted in ASP.NET MVC
Tweet
!function(d,s,id){var js,fjs=d.getElementsByTagName(s)[0];if(!d.getElementById(id)){js=d.createElement(s);js.id=id;js.src="//platform.twitter.com/widgets.js";fjs.parentNode.insertBefore(js,fjs);}}(document,"script","twitter-wjs");
(function() {
var po = document.createElement('script'); po.type = 'text/javascript'; po.async = true;
po.src = 'https://apis.google.com/js/plusone.js';
var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(po, s);
})();
