When I originally announced JustCode in an earlier post, I described its solution wide analysis feature as "it’s like having a compiler running all the time with the only difference being that it runs much faster." This is, of course, only true to an extent but as this is the major feature of JustCode I’ve decided to write a separate blog post describing, in detail, just how this feature can help you. I’ve also decided to split this blog post into several parts covering each of the different platforms support by JustCode as the solution wide analysis works differently depending on the platform.
Let's start with the "usual suspects": C# / VB.NET:
JustCode is incredibly invaluable when working with these two languages as it decreases the amount of times you need to compile to check for errors in the solution. Consider this, when the compiler fails to compile a given project, which it often does, it will stop prematurely, thus not being able to provide a complete and valid list of the actual errors. JustCode however, will continue analyzing your code after it has encountered an error and, in this way, it will provide a better list of all errors and warnings.
When modifying code, depending on the size of the solution and the code you change (whether it's something used only in a few files, or throughout the entire solution), the code analysis will show you all errors and warnings almost instantly.
ASP.NET / HTML:
If you're doing ASP.NET development, you probably know that compiling web sites, especially large web sites, can take a very long time. Not compiling them can cause you an even bigger headache later at runtime. While the VS "Show live semantic errors" feature, introduced in VS 2008 SP1, can help a lot, it still only shows errors for currently opened files. This means that if you add or remove a reference, change some code used in the ascx/aspx files, or if you change something else that can result in errors in these files, you’ll have to either open all solution files in order to see all the errors or you'll need to recompile. JustCode, on the other hand, will show you errors and warnings, on-the-fly, that exist throughout the entire solution. This includes ASP.NET errors, HTML errors, and so on.
The way JustCode provides code analysis for XAML is very similar to the way it supports ASP.NET. The only difference is, for XAML we annotate properties too. In ASP.NET it's perfectly legal to type <prefix:MyControl MyProperty="Test" runat="server" /> where property "MyProperty" doesn't exist. The same is not valid in XAML however, and JustCode will provide warnings for such cases. This might come in handy when you refactor some code which is referred to from the XAML (e.g. when you rename properties, remove properties, change the type of a property and so on) as JustCode will immediately show errors and warnings in all affected files.
I hope this quick overview gives you some ideas about how the global code analysis feature of JustCode can save you a lot of development time. I tried to keep focus specifically on JustCode’s code analysis feature, but I must say that this feature gets even more helpful and time saving when combined with all of the other JustCode features like refactorings, code navigation, and so on. For example, if you want to change the name of a property that is referred to in XAML files, you shouldn’t use Visual Studio's rename refactoring as it won't rename the occurrences of this property in XAML. It's true that JustCode's code analysis will show warnings for all the occurrences that have not been renamed in the XAML, and you can quickly navigate through them and fix them one by one, but it would be much easier to use JustCode's rename refactoring to rename all occurrences in both the C# and in XAML.
Hope this helps.