Technical questions?
Visit Frontline
[Log-in required]

Try It
Request a risk-free, 14-day evaluation.

Shop Now
Visit our online store.

Learning .NET

Many developers are new to Visual Studio NET but they have experience in Windows application development. With DevPartner Studio Professional Edition, you can quickly apply your existing skills to .NET development and shorten your learning curve.

DevPartner Studio represents the best way for software developers to quickly learn and apply Visual Studio .NET to complex programming problems, and for building applications supporting business processes

(click image to enlarge)

(click image to enlarge)

DevPartner source code analysis does much more than simply point out your errors.

More important, it tells you why they are errors, and provides pointers to further information on the web or in books.

(click image to enlarge)

(click image to enlarge)

Using DevPartner Studio source code analysis makes it possible for you to learn while you're coding, making you more productive while delivering new .NET applications.

(click image to enlarge)

Development organizations can use the integrated rules editor to create custom rules that reflect standards and technologies unique to that organization.

(click image to enlarge)

Developers typically use DevPartner source code analysis as an automated "code review," applying the expertise of the best developers across the entire group.

(click image to enlarge)

And there's more to learning .NET than looking at your source code. You also have to understand what kind of code produces efficient executables, and what kind produces slow code and bottlenecks.

By tying together the source of bottlenecks with the line or lines of code responsible, you can easily learn what code constructs will cause you problems. These are the types of lessons that can be applied across .NET applications to provide an immediate payback of your learning investment.

(click image to enlarge)

Migrating to .NET

Using DevPartner Studio Professional Edition, you can migrate your existing Visual Studio 6 applications to .NET. DevPartner Studio includes source code analysis that reviews your existing Visual Basic 6 code. It identifies constructs, logic, and operating system calls that must be modified prior to migration.

It provides a description of the incompatibility, suggestions on how to address it and references for additional research.

(click image to enlarge)

(click image to enlarge)

In this example, DevPartner Studio runs an analysis on a Visual Basic 6 module, identifying a number of statements and instructions that require modification. These errors are summarized in tabular form, describing type of error and severity.

(click image to enlarge)

Selecting one of the errors identified by DevPartner Studio opens a window with a description of the problem and some detail on its impact. There is also a link to a Microsoft reference for more information.

(click image to enlarge)

In this example, correcting one of the errors requires only changing a keyword in a statement.

(click image to enlarge)

DevPartner source code analysis enables you to suppress a notification if it isn't of immediate interest.

(click image to enlarge)

You can also mark an item as fixed.

(click image to enlarge)

Or, you can choose a different set of rules or run all rules against your code.

(click image to enlarge)

Once you have made the required modifications to your VB6 code and ported it over to Visual Basic .NET, DevPartner Studio source code analysis helps you find common .NET programming problems automatically. You can locate problems in:

• program logic
• performance
• use of the CLR
• structured exception handling
• usability
• COM
• internationalization
• design time properties and standards.

(click image to enlarge)

This level of automated error detection works with VB .NET, C#, and ASP.NET code.

(click image to enlarge)

You can use DevPartner .NET source code analysis at this point to identify any additional problems in the code you ported, or new code that you've written. Specifically, DevPartner identifies errors in using the hundreds of new .NET programming interface calls, which will assist you in learning how to use new features and capabilities of the .NET environment.

(click image to enlarge)

Seamless integration

DevPartner Studio integrates seamlessly with Microsoft Visual Studio and Visual Studio .NET. Its features are accessible in the same way you already use Visual Studio.  This means you don’t have to spend much time learning how to use DevPartner Studio features.  For example, you can access DevPartner Studio features from the Visual Studio Tools menu, just as you would any built-in feature.

(click image to enlarge)

DevPartner features are also available through buttons on the Visual Studio button bar.

(click image to enlarge)

When integrated with Visual Studio, DevPartner Studio works in the same way you’d expect Visual Studio to work.  When you want to set DevPartner feature options, such as filtering files or specifying the type of analysis you want, you do so using the Visual Studio Options menu selection.

(click image to enlarge)

The analyses generated by DevPartner Studio appear in panes within the Visual Studio environment, rather than in separate windows.  They have the appearance similar to a code window or form layout window.

(click image to enlarge)

They show up in the Solution Explorer, alongside your code, forms, and other files, so you manage your results just like you do your application files.

(click image to enlarge)

DevPartner Help is also integrated into the Visual Studio Help window.  This means you look in the same place for assistance.

In short, you won’t be able to tell whether you are using Visual Studio features, DevPartner Studio features, or some combination of both.  Both are accessed and used in the same way.  This means that if you are a Visual Studio developer there’s no need to learn anything new in order to use DevPartner Studio immediately to help you write more reliable and better performing applications.

(click image to enlarge)

Memory analysis

Developers lack experience in understanding, identifying, and fixing memory errors in managed code.  Part of the problem is you need accurate, real-time information on how memory is allocated and collected while your application is running.  DevPartner Studio provides memory analysis for .NET that enables you to view memory behavior dynamically, and take snapshots at critical times to be able to relate memory use back to your code.

(click image to enlarge)

DevPartner Studio provides three fundamental views of .NET memory—RAM footprint, temporary objects and memory leaks. You can take snapshots of all these views, in order to examine the state of memory at an instant of your choosing.

(click image to enlarge)

For example, taking a RAM footprint snapshot shows you who allocated the memory, what objects it comprises and which components are holding references to it, and are preventing it from being freed.  This information might prompt you to revisit your design and implementation decisions.

(click image to enlarge)

You can use analysis of temporary objects—the second fundamental view of .NET memory—to look for unusual or inefficient behavior creating large numbers of temporary objects or large-sized temporary objects.

(click image to enlarge)

DevPartner Studio lets you see the objects allocating the most memory, along with the methods using the most memory.

(click image to enlarge)

Further, you can drill down to examine the methods, how many times they are called, whom they are calling and who is calling them.

(click image to enlarge)

The call graph provides a visual display of this information enabling you to see at a glance how these calls occur.  This provides you with a clear picture on when and why these methods are called.

(click image to enlarge)

Another view of .NET memory involves memory leaks.  Objects can leak memory because references aren’t released promptly—or not at all—resulting in poor performance and even application failures. DevPartner Studio tracks memory
allocations among objects to identify those not releasing their instances over time.  You can use this information to determine which objects are leaking memory from your application and when.

(click image to enlarge)

Profiling .NET applications

DevPartner Studio Professional Edition includes a multi-language performance profiler that helps locate bottlenecks.

(click image to enlarge)

This profiler works with both managed and unmanaged code, providing you with the unique ability to profile an entire application seamlessly, even if it mixes .NET and native components.

(click image to enlarge)

It enables you to quickly profile and identify slow code and bottlenecks, taking you to the line of code where the problem resides.

(click image to enlarge)

While your application is running, you can take performance data snapshots using the recording controls or collect data continuously from start to finish.

(click image to enlarge)

When you take a snapshot or quit the application, DevPartner Studio displays the session data in an intuitive interface.

You can navigate through the data, analyzing:

• comprehensive timing
• statistics and data for applications
• components
• source files
• libraries
• procedures
• individual lines of code.

(click image to enlarge)

You can also get detailed views of the performance of children or parent routines, enabling you to dissect performance in an almost unlimited number of ways.

(click image to enlarge)

You can even collect data from remote systems to pinpoint performance bottlenecks at any point in distributed applications.

(click image to enlarge)

Detecting errors automatically in .NET

(click image to enlarge)

(click image to enlarge)

The automatic error detection capabilities in DevPartner Studio Professional Edition provide the only way of identifying, analyzing and addressing errors that occur when your .NET application calls native code. DevPartner Studio ensures that you pass valid information into your native code, and that any exceptions generated from Win32 are caught before they can cause irreversible damage to the rest of the application.

(click image to enlarge)

(click image to enlarge)

In this example, an unhandled exception passed from a native component to the .NET Common Language Runtime—causes the application to crash. However, using DevPartner error detection, this unhandled exception will be caught prior to corrupting the .NET runtime.

(click image to enlarge)

(click image to enlarge)

(click image to enlarge)

(click image to enlarge)

DevPartner error detection also enables developers to identify calls across the managed-unmanaged boundary. Such calls are expensive and can significantly slow down the execution of an application. DevPartner provides you with the opportunity to identify excessive calls, and to marshal and group them together so that fewer calls are made.

DevPartner Studio incorporates a deadlock analysis capability in its automated error detection feature that provides an automated method to search for deadlocks, potential deadlocks and other synchronization errors in unmanaged Windows applications.

DevPartner Studio will report a potential deadlock when we notice that you are not accessing resources in a safe manner. An example would be an application with three threads, all of which make use of a series of resources controlled by critical sections of code. The problem arises when all three threads try to perform operations on several critical sections at the same time.

Potential deadlocks, where a deadlock can occur but has not yet done so, are often the hardest to track down because they only happen in heavily loaded production systems. Attempts to duplicate these problems on development systems are often time consuming and don’t find the real root of the problem.

DevPartner Studio monitors all synchronization objects in an application and will notify you if a potential deadlock is detected, long before it occurs. DevPartner Studio will also provide detailed information describing how the actual deadlock will occur making it easier to modify your code to prevent the problem.

A classic example illustrating this problem is taught in Computer Science and is called the "Dining Philosophers" problem. Because of a limited number of utensils, the philosophers will eventually deadlock because they lack the appropriate number of utensils and no one will return one to the table so that another can use it.

At deadlock time, DevPartner Studio identifies the threads that deadlocked, and what they were doing when the deadlock occurred. If there is a potential for a deadlock to occur, DevPartner Studio will detect that a cyclical execution path between threads exists and determine that a deadlock is possible, even though it has not yet occurred. In both cases, DevPartner Studio will display the line of code where it detected the error, so that you can study the problem and fix the code.

If you are developing distributed applications, this is a must-have tool within your developer tool set. Request a trial version or purchase DevPartner Studio Professional Edition now.