Frequently Asked Questions for Total .NET Analyzer

Here are some common questions about Total .NET Analyzer:

• What is Total .NET Analyzer?
• How does Total .NET Analyzer work?
• What issues does Total .NET Analyzer find?
• I’m new to .NET programming. How can Total .NET Analyzer help me?
• How does Total .NET Analyzer help me solve issues?
• Are the rules configurable?
• How does Total .NET Analyzer compare to FXCop from Microsoft?
• Why is unused code an issue? Doesn’t the compiler get rid of unused code?
• How long will it take to analyze my project?
• What are the system requirements?
• How much does it cost?

What is Total .NET Analyzer?

Total .NET Analyzer is an add-in for Visual Studio .NET that performs detailed analysis of C# and Visual Basic .NET Code. It detects over 150 issues related to errors, unused code, references to legacy libraries, performance issues, naming conventions, standards, and much more.

How does Total .NET Analyzer work?

After you install Total .NET Analyzer, a new toolwindow is available within Visual Studio .NET. Simply open your C# or Visual Basic .NET solution and press then Analyze button. Total .NET Analyzer parses and analyzes all source code in the project, and builds a list of issues. The list appears directly in the toolwindow. As you click on each found issue, Total .NET Analyzer takes you to the code location where the issue exists.

What issues does Total .NET Analyzer find?

Total .NET Analyzer detects over 150 issues. Issues fall into one of six categories:

• Errors: Rules that relate to specific errors in code. For example, Total .NET Analyzer detects unreachable code, which may contain logic crucial to your application. Another example of an error is the use of Stop and End statements in code.
• Performance: Rules that identify potential performance issues in code. For example, Total .NET Analyzer detects use of string concatenation instead of using the StringBuilder class, or use of multi-dimensioned arrays, which are not optimized in the .NET Framework.
• Standards: Rules that identify standards and best practices problems. Standards including configurable naming conventions, and rules that detect things like use of literal strings, characters, and integers.
• Suggestions: Rules that offer suggestions to improve code readability, maintainability, and usability. Examples include event handlers that return values, empty Try statements, underived exceptions, and lack of a default clause in Select Case statements.
• Unused: Rules that detect unused or unreachable objects. Total .NET Analyzer detects unused labels, variables, assignments, events, members, classes, statements, fields, parameters, and enumeration members. (See Why is unused code an issue?)
• VBLegacy: Rules that identify calls in code to legacy Visual Basic libraries. For example, Total .NET Analyzer detects references to Visual Basic legacy date and math functions, control characters, message boxes, and more.

For a complete list or rules, along with documentation on each, visit our Total .NET Analyzer Rules Site.

I’m new to .NET programming. How can Total .NET Analyzer help me?

Everyone is new to .NET. And any new development environment requires that developers re-learn how to program. .NET brings many changes to the table, including new languages, a new framework, and a new IDE. Total .NET Analyzer is ideal for learning .NET because it detects the common errors in .NET code that all new developers make. Not only will Total .NET Analyzer help you identify mistakes in coding, but it will also help you learn the best practices as you develop .NET solutions.

How does Total .NET Analyzer help me solve issues?

Total .NET Analyzer goes beyond simply detecting issues. Each rule includes detailed information about the rule, and provides information on how to correct the problem. This information is crucial to allow you to quickly solve problems.

Are the rules configurable?

Absolutely. Every rule can be turned on or off. Additionally, many of the rules have configurable parameters. For example, the rule that detects literal strings in code can be disabled for the InitializeComponent call in Windows Forms. Also, you can attach your own notes to rules to explain your own standards or practices.

How does Total .NET Analyzer compare with FXCop from Microsoft?

Microsoft designed FXCop to be an internal tool to test compliance with CLS/CLR standards for published components. If you are developing a .NET component, control, or other assembly that is going to be consumed by others, FXCop does a good job of detecting problems with naming conventions and language interoperability.

However, FXCop does not have any of the advanced analysis that Total .NET Analyzer offers. For example, FXCop does not detect calls to legacy libraries, or unused code, nor does it detect possible bugs or programming defects. Finally, FXCop only runs on assemblies, not source code. By directly analyzing C# and Visual Basic .NET source code, Total .NET Analyzer can find issues that no assembly inspection can reveal.

Why is unused code an issue? Doesn’t the compiler get rid of unused code?

Why should you worry about unused code? After all, if it never gets called, what’s the problem? In many cases, unused code actually points to a programming error. The issue is not that the code doesn’t get called. The issue is that the code may contain important logic for your application, and the fact that it isn’t called represents an error. For example, look at the following code:

        Dim Continue As Boolean = False
        If Continue Then
            ' Be sure to close database connections
            DatabaseConn.Close()
        End If

In this example, the code in the If block is considered unused code. In this case, a potentially large bug is hidden by unused code.

How long will it take to analyze my project?

Total .NET Analyzer uses our state of the art .NET code parser. Written from the ground up specifically for C# and Visual Basic .NET, the parser can handle over 10,000 lines of code per second. This means that an average size .NET project will parse very quickly. As an example, a solution that comprises roughly 10 C# files and 10 Visual Basic .NET files will parse in under 2 seconds on a typical development computer. Learn more about our .NET Parser.

What are the System Requirements?

Total .NET Analyzer has the following system requirements:

• Microsoft Visual Studio .NET running on a supported Windows operating system (Total .NET Analyzer is not supported under Windows 95, 98, or ME)
• Approximately 3 MB Free Disk Space.
• PC with a Pentium II-class processor, 450 MHz minimum. Pentium III-class processor or higher recommended.
• 256 MB of RAM (more is always better)

How much does Total .NET Analyzer cost?

Total .NET Analyzer is licensed on a per-user basis. Each user who runs the program must own a license. Pricing is as follows:

• 1 License: $499
• 5 Licenses: $1499
• 25 Licenses: $4,999.

Larger quantity discounts are available by contacting FMS.

Total .NET Analyzer can be purchased directly from FMS, corporate resellers, and international distributors. All FMS products offer a 30-day money back guarantee.