Code Analysis
JustCode provides real-time solution-wide code analysis and error checking, warnings, code highlighting, error navigation and more. With JustCode, you can instantly see how changes in a file affect other files in your solution, even across .NET language barriers because JustCode provides code analysis features for C#, VB.NET, ASP.NET, XAML, JavaScript and HTML and supports multi-language solutions.
Watch a video on JustCode Code Analysis features
C# / VB.NET
JustCode is invaluable when working with these languages because you no longer have to compile the solution to find errors. Also, the compiler will stop analysis as soon as it fails to compile a project, thus not being able to provide a complete and valid list of errors. JustCode, however, will continue analyzing your code after it has encountered an error and, will provide a complete list of all errors and warnings. When modifying code, the code analysis engine will show you all errors and warnings almost instantly.
 enlarge screenshot
ASP.NET / HTML
JustCode will also help out when working on web applications. The code analysis engine provides on-the-fly error checking, and warnings, for ASP.NET and HTML. To find these errors with Visual Studio alone, you would need to run your web application, which could take a long time especially for large web sites. However, even if you went this route, you would not get a list of errors, and would have to figure out the HTML errors at runtime. With JustCode, you do not need to run web sites to find issues in html, or ASP.NET because it provides you with these errors and warnings on-the-fly as you type, or as the solution updates (e.g. after getting the latest changes from the source control).
 enlarge screenshot
JavaScript
With JustCode, you can easily discover JavaScript errors and warnings on-the-fly as you type. You can quickly navigate through these errors and warnings through the JustCode’s Errors List window.
 enlarge screenshot
XAML
JustCode checks the entire solution on-the-fly for XAML errors and warnings, and will save you a lot of time tracking down invalid XAML. For example, when you forget to declare a XAML namespace, or when a dependency property is renamed or removed, JustCode will immediately notify you.
 enlarge screenshot
Errors & Warnings Navigation
JustCode provides many navigation commands enabling you to quickly jump through all the errors, and warnings it finds in your code. In addition, you can easily tell JustCode to ignore an error or warning.
Control Over Errors & Warnings Reporting
JustCode provides a way to disable the solution-wide analysis for a given language and you can even exclude specific files, or entire projects which you don’t want to be checked for errors and warnings.
Inspection Details
JustCode provides inspection details for errors and warnings in a couple of different ways as follows:
- Via Tooltip over a highlighted expression
Hover over a highlighted expression with your mouse to get inspection details.
Info pop-up appears at the bottom when navigating through errors and warnings or when executing the Fix (Alt+Enter) quick fix.
- Via Tooltip in the Marker Bar
Hover over a marker in the JustCode Marker Bar to get inspection details.
Inspection Details are also provided in the Error List Window.
Refactorings
JustCode provides a number of refactoring commands to help you improve your code by changing its structure while at the same time saving its behavior. Refactorings help simplify your code, by improving its readability and maintainability. Here is a list of the most common refactorings in JustCode.
Rename
Allows you to quickly change the name of namespaces, types, methods, fields and practically every type of code you write (see details below). The operation replaces all references in code, as well as in comments and string literals (optional).
 enlarge screenshot
Organize and Add Missing Usings
Helps you to easily sort, remove unused and add missing using directives.
Move Type to Another File
You can quickly move a type to a new file having the same name as the type. That refactoring works with classes, enums, interfaces and structures. This refactoring can be accessed through the pop-up menu.
Introduce Field
Allows you to quickly create a new field from a selected constant expression and initialize it with the expression. Additionally, you will get a dropdown suggesting several names based on the code you have selected.
Introduce Variable
Introduce a new variable from an existing one; use an existing constant to introduce a new variable; use an existing expression to introduce a new variable. Additionally, you will get a dropdown suggesting several names based on the code you have selected.
Extract Method
Allows you to reorganize your code for better reuse and readability by creating a new method based on a selected code fragment. By analyzing the selected code JustCode creates a new method that contains the extracted code and replaces it in the existing member with a call to the new method. Available for C#, VB.NET and JavaScript.
Introduce Parameter
It allows you to add a new parameter to a function from a local variable or a constant inside its body. All calls to the function are automatically updated with the appropriate value passed as the new parameter.
Move/Delete Parameter
You can quickly change a parameter's position or remove it from method's signature. All calls to the method being refactored will be updated once you apply the changes.
 enlarge screenshot
Inline variable
This refactoring replaces all occurrences of the selected variable with its initializer.
Pull Member to Base Class
When you execute this refactoring for a member of a given type, JustCode will move it to the base type along with the other private members it is using (if they are not used by other members).
Add Stubs in Inheritors
This command can be executed for a member of a type or for the whole type. This becomes very useful, when you have added a new member to an interface or to a base class and want this member implemented in all the inheritors of this type instead of going into each inheritor and running "Add Stubs For Required Members" from there.
Extract Interface
This refactoring allows users to quickly create a new interface based on an existing interface or class. JustCode analyses the type and detects the members and methods that can be converted. After extraction, the original type inherits from the new interface.
Inline Method
It lets you move a method's body into the body of its callers and remove the method declaration. It does exactly the opposite of what 'Extract Method' does.
Generate Documentation
Automatically generates XML documentation for every code element. It is smart enough to identify what parameters and types you are using and suggest smart documentation comments.
Convert Method To Property
Allows you to convert methods to properties. This refactoring is quite useful for converting legacy code with setter- and getter-type methods to C#.
Safe Delete
This refactoring allows the safe removal of type members.
$(document).ready(function(){ $("a[rel^='prettyPhoto']").prettyPhoto(); }); $(document).ready(function () { var docUrl = document.location.pathname; $(".poJustcodeIcons").children('li').each(function (i) { var _containerURL = $(this).children('a').attr('href').split('.'); var _sectionURL = String(docUrl).substring(0, String(_containerURL[0]).length); if (_containerURL[0] == _sectionURL) { $(this).addClass("selected"); $(this).children('a').addClass("selected"); }; }); });
Code Navigation and Search
JustCode comes with a powerful navigation and search engine that provides a number of features enabling you to quickly navigate to different parts of your code and easily find and highlight symbol usages, definitions, types, members, errors, etc. As you search, JustCode keeps track of returned results and lets you navigate through them quickly via a convenient Find Results Window. To speed-up the search process, JustCode provides the so-called Camel Case Search, which lets you search by capital letters of compound names.
Go-to Commands
Go to Definition - quickly navigate to the definition of a class, struct, method, property or various other types of declaration solution-wide.
Go to File - lets you search and navigate to a file within your solution.
Go to Type - lets you search and navigate to a specific type.
Go to Symbol - allows you to navigate to any symbol solution-wide.
Go to Member - lets you search and navigate to a member in the current file.
Go to Previous/Next Error - By using the Go To Previous Error/ Go To Next Error commands you can quickly navigate between the errors found by JustCode.
Usages
JustCode helps you find, highlight and navigate through usages of namespaces, types, method, fields and local variables in your code. The commands related to usages are:
Find Usages ? quickly locates the places where a certain namespace, type, method, property, field, or local variable is used in the solution. The Find Usages dialog also allows you to easily distinguish and filter the read and write usages of a given member or variable.
Additionally, you can distinguish these usages in the vertical stripe bar when doing Highlight Usages.
 enlarge screenshot
These usages are also highlighted and distinguished in JavaScript:
Find Extended Usages ? helps you locate the places where certain type and its members are used in the solution. It also finds a certain namespace, method, property, field, or local variable usage. The only difference with the Find Usages command is that when you search for a type it also includes usages of its members in the results.
Highlight Usages - highlights the usages of the selected identifier in all files within the solution. JustCode also marks the highlights in the Marker Bar to indicate the relative position of the usage in the file.
Highlight Usages in File
Go to Previous/Next Usage - once a usage is highlighted, JustCode allows you to easily navigate through all found usages.
Find Commands
The find commands allow you to find and navigate through the code syntax.
Find Inheritors - find and navigate to derived types from a given type.
Find Members Returning Type - find and navigate to members that return a certain type.
Find Members Taking Type - find and navigate to members that take a certain type as a parameter.
Find Overridden Members - find and navigate to overridden abstract, virtual, override or interface members.
Find Overriding Members - helps you find and navigate to overriding abstract, virtual, override or interface members.
Locate in Solution Explorer
The Locate In Solution Explorer command lets you quickly find the currently opened file in Solution Explorer. JustCode automatically scrolls to the file and highlights it. This feature is especially handy in cases where you have a solution with hundreds of files and/or multiple projects.
Solution Explorer Commands
Just Collapse All - Collapse all the child items of the currently selected solution, project or folder.
Just Find All Dependent Code - The command can be executed for the currently selected project, folder, file or reference and the Find Results window will appear showing all the code that depends on the selected item(s).
 enlarge screenshot
Just Format All - This command can be run for the entire solution, for a project or for a project folder and JustCode will format all the files under the currently selected item using the JustCode formatting options you have set (JustCode Options / Code Style).
Decompiling
From Q1 2011 JustCode offers a powerful decompiling capability, which enables you to recover lost source code and explore and analyze compiled .NET assemblies without ever leaving Visual Studio. Simply navigate to the definition of any class and reveal the source as if it were in your project.
Quick Fixes
Quick Fixes provide a fast and easy way to fix errors and warnings in your code. All Quick fixes are available once JustCode detects an unknown identifier or a type mismatch in your code. Here is a list of some of the most common Quick Fixes:
Create Method
When JustCode cannot find the method you are calling within a class, it will offer to create the missing method with a signature derived from the method invocation.
 enlarge screenshot
Delete
The Delete quick fix is available for mistyped or needless syntax characters such as duplicate ;(semi-colon), }(curly bracket), etc.
Replace With
Works with declaring a method without returning type - suggest to rename the method name to the class name (create a constructor).
Add Reference and Fix Using
If JustCode detects a type name that cannot be resolved and is not available in the currently referenced assemblies, it underlines the type name and offers to add the reference for you.
Add Required Cast
JustCode underlines the type mismatch expression and offers to insert a cast (or a safe cast whenever appropriate) to the type of the expression standing on the left side of the assignment.
Rename File to Match Type Name
When a type and the file it is in do not have the same name, JustCode will offer to rename the file to match the selected type name. This feature works with classes, enums, interfaces and structures.
Error and Warning Control
Sometimes you may not be in control of certain areas of the code you are working on, and as such, may not want to see errors, or warnings for this code. JustCode allows you to quickly ignore any error and warnings you do not want to see.
Generate New Class
This quick fix is available once JustCode has detected use of an unknown type in your code. JustCode suggests you generate a class, structure, interface or enumeration. JustCode automatically generates a new class in the current file with the same name as the unknown type
Fix Using
Underlines any unresolvable types, and offers to automatically add a using directive, or to fix all usings in the file.
Create Property / Create Auto-Implemented Property
When JustCode finds an unknown identifier in your class, JustCode will offer to create a normal property, or an auto property in the current class with the same name as the unknown identifier.
Create Field
When JustCode finds an unknown idenitifier anywhere in your class, it will offer to create a field in the current class with the same name as the unknown identifier.
Create Variable
When there is an unknown idenitifier in your method body, JustCode will offer to create a local variable in the current method/constructor with the same name as the unknown identifier.
Create Parameter
When there is an unknown identifier in your method body, JustCode will offer to introduce a new method parameter based on it. Once you execute this quick fix, all method calls will be updated with default values. You can configure whether or not method calls will be updated in JustCode’s options.
Add Parameter to Method
If you have a method call and you add some additional argument to that call, JustCode will offer to update the method’s signature and all calls to it. You can configure whether or not the method calls will be updated in JustCode’s options.
Delete Unused Parameter
As a part of the analysis, JustCode will show warnings for parameters that are not used in a method’s body and offer to remove the unused parameter and, optionally, to keep any side effects.
Create and Initialize Field
If you have an unused parameter in a constructor, JustCode will offer to create and initialize a field with the same name for you.
Create and Initialize Property
If you have an unused parameter in a constructor, JustCode will offer to create and initialize a property with the same name for you.
Code Generation
Duplicate Text
Duplicate Text assists you by duplicating the currently selected code. This command is especially useful when used in combination with the Expand Selection command. For example, you can easily select a constructor/method signature, duplicate the selection and create a new constructor/method overload.
Create Set/Get Property
You can quickly select one or more fields and automatically to create read/write properties.
Create Constructor
Easily create a non-default constructor on-the-fly by selecting the fields that you would like the constructor to take as parameters.
Add Stubs for Required Members
This command lets you implement an interface or abstract members on-the-fly. When a class does not implement required member(s) from an interface or a base abstract class JustCode displays an error.
Expand Selection
Expand Selection will select logical pieces of your code. You can quickly select code blocks executing the command several times until you get the selection you need.
Before
 enlarge screenshot
After
 enlarge screenshot
Generate Equality Members
This feauture enables you to effortlessly generate Equals() and GetHashCode() method for the current type. You can easily call out this command from the context menu.
Code Templates
Code Templates are reusable code snippets that allow you to quickly insert commonly used code fragments or surround selected code fragments with a meaningful code block (example: try-catch statement). JustCode templates are easy to create and customize, and even easier to use.
Insert Templates
Insert a C#/VB.NET/JavaScript code template like foreach, for, if, or console.write.
Surround Templates
Surround a C#/VB.NET/JavaScript code fragment with a valid language statement.
Using Acronyms
With this feature you just type the abbreviation for the template, press "Shift+Space" and the template expands. See some of them in the screenshots below:
Smart Template Completion
When JustCode expands a template, it will search for all variables in scope that can help complete the code template. In addition, it will suggest appropriate variable names where necessary
Code Formatting
JustCode allows you to format your code against a set of rules defined in the JustCode options, or you can reuse some Visual Studio default formatting options. Your formatting rules include indentation, aligning, spaces, braces layout, anything related to your code format.
Automatically Learn Formatting
Using the Learn Code Style From File command you can set your own custom set of code styles. This command is language dependent meaning that depending on what type of file (C#, VB.NET, ASP.NET, XAML, JavaScript, HTML) you execute it in, JustCode will set code styles for that language. By default, JustCode comes with a set of predefined code styles for each supported language.
Code Reordering
This feature allows you to reorder all of the various members in your class using a single command. Once executed, JustCode will sort the members using specific rules, thus keeping it clean and readable. Code ordering rules are easily customizable through the JustCode Options dialog.
Lines Wrapping
This feature allows you to set the maximum characters per line. When necessary, JustCode will wrap the line, and hyphenate it.
Coding Assistance
Color Identifiers
Color identifiers make it easier for developers to quickly read and understand the code on the screen. One of the many features provided by Telerik JustCode is the ability to colorize additional items that Visual Studio does not allow you to colorize by default. The colorization of items such as methods, properties, events, variables, and method parameters can be easily changed to your specific needs.
Telerik JustCode allows you to enable, disable or adjust the fonts and colors of the identifiers. The various available markers let you define how the specific elements of the code being refactored will look like. For example, you can define the border of the object you are refactoring or the foreground/background colors. There are many other markers to let you fully control the appearance of the code you are refactoring.
Typing Assistance
Telerik JustCode will save you keystrokes by automatically closing braces, brackets, and single or double quotes. In addition, it also prevents doubling of brackets, and auto-formats code on semi-colon, or close bracket press.
Bracket Completion
When you add an open bracket at the beginning of a line, JustCode will add the closing bracket for you at the end of the line, even if there is code. When you hit enter, the auto formatter will run.
Prevents Bracket Doubling
JustCode prevents you from doubling parenthesis, braces, and brackets. Instead of doubling these items up, it will move your cursor outside the closing item.
Auto Format on Semi-Colon and Close Bracket
JustCode automatically runs the auto formatter when you press semi-colon or add a closing bracket at the end of a line.
 
Auto Completion of Single & Double Quotes
The typing assistant also adds a closing single or double quote for you!
JavaScript Support
JustCode provides various JavaScript features like code navigations, refactorings, quick fixes and more which increase the speed at which you read, navigate, and refactor JavaScript code.
Color Identifiers
When you have the “Color identifiers” feature turned on, JustCode will colorize local variables and functions in different colors which significantly improves code readability as you can easily see what’s declared in the current file. Additionally when you know that something is declared in the current file, you also know whether you can find its usages, rename it or perform some other code navigation or refactoring.
JavaScript Code Navigations
For locally declared variables and functions JustCode provides code navigation features which make navigating through your JavaScript code easier and faster. Using JustCode you can navigate to the definition of a given identifier, find its usages or just highlight all occurrences of this variable / function in the current file.
You can also use the Go To Member dialog to quickly find the declaration of a variable or function in the currently opened file and navigate to it.
Or you can even use the Go To Symbol dialog and navigate globally to the declaration of a variable or function declared in any JavaScript file inside your solution.
Quickly navigate to any declaration in your whole solution using the Go to Definition navigation.
Use the Find Usages navigation to quickly locate the places where a specific method, field, or local variable is used in the solution. The Find Usages dialog will also help you easily distinguish, and filter, the read and write usages of a given member or variable.
JavaScript Refactorings
JustCode provides a set of refactorings that greatly decrease the time spent refactoring JavaScript code. You can rename variables and functions, introduce variables and fields.
And you can even extract methods from a selection.
JavaScript Code Analysis
JustCode makes it easy to discover JavaScript errors and warnings on-the-fly, as you type. You can quickly navigate through these errors and warnings through the JustCode’s Errors List window.
JavaScript Quick Fixes
When you position the cursor over a JavaScript error or warning, JustCode will suggest how to fix this error, in this case by adding the missing character.
Code Formatting
JustCode provides additional code formatting options, which are not available in the default Visual Studio formatting options, giving you even more control over the coding style you want to adhere to.
JavaScript Typing Assistance
When you add an open bracket at the beginning of a line, JustCode will add the closing bracket for you at the end of the line, even if there is code. When you hit enter, the auto formatter will run. The typing assistant also adds a closing single, or double quote for you. Additionally JustCode automatically runs the auto formatter when you press semi-colon, or add a closing bracket at the end of a line. |
