ReSharper and Roslyn: Q&A

As you probably know based on news from BUILD Windows conference last week, Roslyn, the new .NET Compiler Platform with code analysis APIs for C# and VB.NET, has been pushed to Preview phase and open sourced. In case the event slipped your attention, here’s a nice tour of Roslyn on the C# FAQ blog at MSDN.

Immediately we at JetBrains were faced with multiple questions on the perspectives of ReSharper using Roslyn for its code analysis and how the two tools might compete. The flow of questions wouldn’t end, to the point of introducing a template to answer them:

ReSharper and Roslyn? I dare you!!

Seriously though, it was clear that we needed to elaborate on the ReSharper vs Roslyn issue. Hence this post.

We sat down with Sergey Shkredov (@serjic), ReSharper Project Lead and .NET Tools Department Lead at JetBrains, and Alex Shvedov (@controlflow), a Senior Developer on the ReSharper team who’s responsible for ReSharper’s Generate functionality, code annotations and support for XML-based languages. The following Q&A is a summary of the conversation that we had with them.

What’s JetBrains stance towards Roslyn? Do we consider the technology and its Open Source status important and valuable?

Roslyn is definitely important and a good step forward for Microsoft in that it should help Visual Studio users take advantage of more C# and VB.NET code editing and analysis features in Visual Studio out of the box.

It should also help Visual Studio extension developers write code-centric extensions against a consistent API while having the opportunity to know how it works inside, thanks to the Open Source status of the project. This is not to mention hackers who are willing to spend their time forking the compiler and tuning it to make, say, C# the ideal language they’ve always envisioned.

We also believe that Roslyn is no less important for Microsoft itself. Faced with the burden of maintaining a plethora of Visual Studio integrated tools including code editing tools, IntelliTrace and code designers, the folks at Microsoft are interested in making these tools as flexible and easy to update as possible. Roslyn should enable updating .NET languages and experimenting with them faster than before. Apart from that, the old compiler wouldn’t let launch compilation steps in parallel, and Roslyn is expected to enable that, bringing more scalability to the table.

What’s the point of making Roslyn Open Source?

As to the act of letting Roslyn go Open Source, we don’t believe that Microsoft is expecting anyone from outside of the company to develop the compiler for them. Programming languages are entities too monolithic and complex to justify accepting external changes of any significance. Therefore, we expect Microsoft to keep the function of designing .NET languages totally to itself without depending on the community.

The true value of Roslyn going Open Source lies in enabling extension developers to look into Roslyn code that is relevant to their purposes: how it’s written and whether it’s efficient. They might debug or profile it to see if it’s the culprit of unexpected behavior in their extensions or if it introduces performance issues. This is possibly the workflow whereby meaningful pull requests might start coming in to the Roslyn repository.

As to possible endeavors to fork and modify the compiler to address application- or domain-specific tasks, this scenario appears to be a shot in the foot. Even if the default compiler in Visual Studio can be replaced with a fork, instrumental support for the fork ends as soon as you go beyond Visual Studio. In theory we can imagine a custom INotifyPropertyChanged implementation based on a Roslyn fork that can even gain certain popularity. However, we can barely imagine supporting it in ReSharper as our intention is to focus on supporting the official version of Roslyn.

Will ReSharper take advantage of Roslyn?

The short answer to this tremendously popular question is, no, ReSharper will not use Roslyn. There are at least two major reasons behind this.

The first reason is the effort it would take, in terms of rewriting, testing and stabilizing. We’ve been developing and evolving ReSharper for 10 years, and we have a very successful platform for implementing our inspections and refactorings. In many ways, Roslyn is very similar to the model we already have for ReSharper: we build abstract syntax trees of the code and create a semantic model for type resolution which we use to implement the many inspections and refactorings. Replacing that much code would take an enormous amount of time, and risk destabilizing currently working code. We’d rather concentrate on the functionality we want to add or optimize, rather than spend the next release cycle reimplementing what we’ve already got working.

The second reason is architectural. Many things that ReSharper does cannot be supported with Roslyn, as they’re too dependent on concepts in our own code model. Examples of these features include Solution-Wide Error Analysis, code inspections requiring fast lookup of inheritors, and code inspections that require having the “big picture” such as finding unused public classes. In cases where Roslyn does provide suitable core APIs, they don’t provide the benefit of having years of optimization behind them: say, finding all derived types of a given type in Roslyn implies enumerating through all classes and checking whether each of them is derived. On the ReSharper side, this functionality belongs to the core and is highly optimized.

The code model underlying ReSharper features is conceptually different from Roslyn’s code model. This is highlighted by drastically different approaches to processing and updating syntax trees. In contrast to ReSharper, Roslyn syntax trees are immutable, meaning that a new tree is built for every change.

Another core difference is that Roslyn covers exactly two languages, C# and VB.NET, whereas ReSharper architecture is multilingual, supporting cross-language references and non-trivial language mixtures such as Razor. Moreover, ReSharper provides an internal feature framework that streamlines consistent feature coverage for each new supported language. This is something that Roslyn doesn’t have by definition.

Will it be practical to use both ReSharper and Roslyn-based functionality in Visual Studio?

This is a tricky problem as it’s still uncertain whether we would be able to disable Roslyn-based features (such as refactorings or error highlighting) when integrating into new releases of Visual Studio. If we’re unable to do that, performance would take a hit. Apart from ReSharper’s own immanent memory and performance impact, Roslyn’s immutable code model would increase memory traffic, which would in turn lead to more frequent garbage collection, negatively impacting performance.

We’re hopeful that this problem would be solved in favor of letting us disable Roslyn features that ReSharper overrides, because otherwise ReSharper would have to work in a highly resource-restricted environment. Irrelevant of whether this happens though, we’ll keep doing what we can do, minimizing ReSharper’s own performance impact.

As Roslyn is now Open Source, which parts of its code are going to be of particular interest to ReSharper developers?

We’ll be sure to peek into Roslyn code and tests from time to time, to see how C# and VB.NET language features are implemented. We don’t rule out that actual code supporting them is going to emerge before formal specifications are finalized. In fact, we’ve already started.


That’s more or less the picture of living in the Roslyn world as we see it today. As time goes by, we’ll see if things turn out the way we expected them to.

Meanwhile, if you have questions that were not addressed in this post, please ask in comments and we’ll try to come up with meaningful answers.

Posted in How-To's | Tagged , , | 59 Comments

Introducing dotPeek 1.2 Early Access Program

It has been a while since dotPeek, our free .NET decompiler, received its latest update, but that doesn’t mean we put it aside. Today we’re ready to launch the dotPeek 1.2 Early Access Program that introduces a substantial set of new features.

Starting from version 1.2 dotPeek learns to perform as a symbol server and supply Visual Studio debugger with the information required to debug assembly code. This can be most useful when debugging a project that references an assembly from an external class library.

dotPeek listens for requests from Visual Studio debugger, generates PDB files and source files for the requested assemblies on demand, and returns them back to the debugger. dotPeek provides several options to choose exactly which assemblies you want it to generate symbol files for.

Symbol server options in dotPeek 1.2 EAP

To learn more on how to set up dotPeek as a symbol server and use it for debugging in Visual Studio, please refer to this guide.

In case that the Visual Studio cache already contains PDB files for certain assemblies but you would like to replace them with PDB files generated by dotPeek, use the option to generate PDB files manually. In order to do that, simply select an assembly in dotPeek’s Assembly Explorer, right-click it and choose Generate PDB.

Generate pdb in dotPeek 1.2

dotPeek can export to project and generate PDB files in the background, meaning that you can explore assemblies during PDB generation or assembly export. To address cases when it’s not clear whether PDB files were generated properly, dotPeek has a dedicated tool window that shows current status and results of PDB generation.

PDB generation status in dotPeek 1.2 EAP

In addition to the set of features that streamline debugging decompiled code, dotPeek 1.2 adds quick search and node filtering in various trees, most notably Assembly Explorer. Searching and filtering using lowerCamelHumps is supported for these scenarios.

Search in Assembly Explorer in dotPeek 1.2 EAP

If you’re interested to learn about other fixes and improvements made for dotPeek 1.2 EAP, this link should help you out.

Does the above sound enticing? Download dotPeek 1.2 EAP and give it a try!

Posted in dotPeek Tips&Tricks, News and Events | Tagged , , | 7 Comments

Live Webinar: Deconstructing Clippy – Common Issues for an Uncommon Extension, April 16th

Join us Wednesday, April 16th, 15:00 – 16:00 GMT (11:00 AM – 12:00 PM EDT) for our free live webinar, Deconstructing Clippy, with Matt Ellis.

Clippy for ReSharper is a good April Fools’ day joke made better by the fact that it’s a real, fully functioning extension – replacing the Alt+Enter menus as well as integrating with navigation and refactoring. It’s also a great demonstration of the varied and often surprising ways you can extend ReSharper.

This webinar will take a deep dive into Clippy’s implementation. We won’t look at the standard extension points (it doesn’t use any!), but will look at common platform issues faced by all plugins, such as versioning, components, lifetime management and threading. And we’ll look at some of the more interesting issues thrown up by trying to add a cartoon character to a productivity tool.

Space is limited, please register now.

The source code for Clippy for ReSharper can be found on GitHub: https://github.com/citizenmatt/resharper-clippy. It’s not required for the webinar.

About the Presenter:

Matt EllisMatt Ellis is a Technical Evangelist at JetBrains. He has been a professional developer for nearly 20 years, shipping software for BBC Worldwide, BNP Paribas and Egg, the UK’s first Internet bank. He is an open source creator and contributor, owning projects such as the xUnit.net test runner for ReSharper. He believes in clean code, simplicity and the open/closed principle.
Posted in How-To's, ReSharper Tips&Tricks | Tagged , , , , | 1 Comment

Clippy for ReSharper

When we heard that Office 2003 was being retired, we spotted a synergy almost immediately.

ReSharper has always wanted to make you more productive with your code. We already provide great tools for navigation and code completion, refactoring, inspections and running unit tests.

But how can we improve on what we’ve got?

How can we really help you, our customer, develop great solutions for your customers?

With Office 2003 hitting end of support, the answer was obvious – a much loved icon was also being retired.

We’ve offered him a job.

Clippy helps with in place refactoring

That’s right, Clippy is coming to ReSharper. And this isn’t just an announcement – you can download and install him right now, from the Extension Gallery (in Visual Studio, select ReSharper –> Extension Manager –> Online, search for “clippy”). Clippy supports ReSharper 8.1 and the recently released 8.2 (which is a free upgrade – grab it now!)

extension_manager

In the same way that he has provided help to millions of customers of the phenomenally successful Office suite, he can now live out his retirement helping developers produce the best code they possibly can, as quickly as they can.

He’ll help you navigate, he’ll help you refactor, he’ll help you generate code: clippy_in_action

He’ll even help you run your tests!

Clippy runs your unit tests

Once you’ve installed the extension, there’s nothing more you need to do. Just open a solution, start working and Clippy will appear, ready and willing to help.

Download today, give him a go and let us know how you get on!

Posted in ReSharper Tips&Tricks | Tagged , , , , | 31 Comments

dotMemory 4 Beta: Memory Profiling Better Than Ever Before

As you may have noticed, a totally renewed dotMemory 4 is on its way. Meanwhile, we are proud to introduce dotMemory 4 Beta!

dotMemory 4 Beta

dotMemory 4 offers a lot of new functionality that helps you optimize memory usage in your applications, find memory leaks, and address other types of memory issues like never before.

Let’s have a closer look on features you can already try on:

Powerful automatic inspections
To ease your task, dotMemory automatically scans your snapshot for most common types of memory issues. These inspections can be a great starting point in analyzing a snapshot if you’re not sure where to begin.
Automatic Inspections

Easy and comprehensive UI
While memory profiling has the reputation of being for pros only, dotMemory’s unique user interface lowers that entry barrier dramatically. You can start memory issues investigating straightforward.

Timeline view with real-time data collection
In order to monitor memory consumed by your application, get snapshots and drop them to compare in one click.

dotMemory Timeline View

Multiple views on data
Examine objects in the heap from multiple views. Want to know how objects relate to each other? What objects do they reference and through what fields? Which calls created these objects? No problem! dotMemory has a view for everything.
Multiple Views

Comparing memory snapshots
Comparing two snapshots is the main way to find objects that are causing a memory leak. Use the comparison view to find out how many objects were created between snapshots and how many objects were collected.

Analyzing memory traffic
Excessive allocations and garbage collections may imply significant memory management overhead. Use the traffic view to understand what objects are created/collected most intensively in your app and what functions are causing this memory traffic.

Remote profiling
Profile apps not only on your local computer but on any computer in your network or on the Internet. Remote profiling is especially helpful when you need to profile a web app on a production server.

Profiling API
Picking the right moment to get a snapshot is very important for memory analysis. Use the dotMemory API calls to take snapshots at exact places of your code.

Support for various .NET applications
Profile apps based on .NET Framework 2.0 to 4.5.1, Silverlight 4, Silverlight 5, Windows Store and IIS applications.

Visual Studio integration
dotMemory integrates with Visual Studio so you can start a memory profiling session right from the IDE, whenever you need.

For a more detailed overview of dotMemory 4 Beta functionality, please check the brand new dotMemory 4 website. That’s right, dotMemory now has a dedicated website, albeit still in Beta.

By the way, the resources available for you to know dotMemory 4 even better:

Please download dotMemory 4 Beta and feel free to share you feedback with us via comments here! You can also contact our technical support if you have any questions and report issues to dotMemory bug tracker if you experience any. We’ll be happy to help. Thank you for choosing dotMemory.

Give it a try and enjoy!

Stay tuned for further announcements,
JetBrains dotMemory Team

Posted in dotMemory Tips&Tricks, News and Events | Tagged , | 3 Comments

ReSharper 8.2 is Released Along with dotTrace, dotCover Updates

We are still eager to deliver cross compatible joint releases, that’s why today we prepared a triple update for our .NET tools.

The following builds are already waiting for you to download and try: ReSharper 8.2, dotCover 2.7 and dotTrace Performance 5.5.4.

ReSharper 8.2, dotTrace 5.5.4 and dotCover 2.7

Here’s why these updates can be attractive to you:

ReSharper 8.2

As you might have already heard, lately we’ve been working on improving your TypeScript coding experience with ReSharper. Here’s a quick overview of what we’ve done in this regard:

  • ReSharper 8.2 significantly expands TypeScript support with smart completion, Create From Usage quick fixes and Import Module context action, navigation combos, naming settings, support for generics and compiler defined errors highlighting. For details on these features, please see an earlier post, More TypeScript support in ReSharper 8.2.
  • Jasmine 2.0 support for ReSharper’s unit test runner that works with JavaScript and TypeScript files now.
  • Other enhancements including Quick Documentation fixes (including a fix to an epic bug that could be easily qualified as the best way to hang and crash Visual Studio), a long-awaited fix for the red code problem with Xamarin installed and another 140+ fixes.

Please note that not all ReSharper plugins are ready for 8.2 and if you’re using plugins, you’ll see update notifications from the Extension Manager as new updates become available.

dotCover 2.7 & dotTrace Performance 5.5.4

With this minor update dotCover receives a standalone test runner which can be most useful for running manual tests outside Visual Studio, as well as for analyzing coverage snapshots.

Both dotCover 2.7 and dotTrace Performance 5.5.4 provide integration with the updated ReSharper 8.2.

Please download ReSharper 8.2, dotCover 2.7 and dotTrace Performance 5.5.4.

In terms of license eligibility, here’s a way to check if your licenses will work with these updates:

  • ReSharper 8.2 is a free upgrade for all personal and academic licensees who are eligible for ReSharper 8.0. It’s also a free upgrade with all commercial per-major-version licenses to 8.x, and with commercial subscription-based licenses purchased or renewed on March 21, 2013 or later.
  • dotCover 2.7 is a free upgrade for all licensees who have purchased or renewed their licenses on March 21, 2013 or later.
  • dotTrace Performance 5.5.4 is a free upgrade for all dotTrace Performance 5 licensees.
Posted in News and Events | Tagged , , , , , , | 40 Comments

More TypeScript Support in ReSharper 8.2

When we announced TypeScript Support in ReSharper 8.1, we promised you a lot more to come. It’s time to deliver on that promise. Here are some of the things we’ve added in ReSharper 8.2:

  • Support for generics as well as many improvements to ReSharper’s type resolution mechanisms.
  • Create from usage lets you start using code constructs first and create them later.
    ReSharper 8.2 TypeScript Create from usage
    This mechanism supports creation of many different constructs such as creation of modules or enum members from usage. ReSharper now also honors Member Generation settings for usage-generated TypeScript code.
  • Compiler-defined errors (only syntax errors, for now) are highlighted. These errors are accompanied with over 50 quick-fixes:
    ReSharper 8.2 TypeScript Make all overloads public or private
  • Naming support has been added: ReSharper will now check your code against the TypeScript naming settings:
    ReSharper 8.2 TypeScript Inconsistent naming inspection
    and will offer to fix things for you:
    ReSharper 8.2 TypeScript Naming quick-fix
  • Navigation up and down the inheritance hierarchy (Alt+Home and Alt+End respectively) now works for both type declarations as well as type members.
  • Support for modules in navigation (Go to Symbol Shift+Alt+T/Go to Everything Ctrl+T):
  • The Import Module context action lets you automatically add the right import statements when an external module is used:
    ReSharper 8.2 TypeScript Import Module
  • Smart completion support (Ctrl+Alt+Space): ReSharper can filter out a completion list leaving only structurally compatible subtypes, as shown below:
    ReSharper TypeScript Smart Completion
  • Jasmine support, including support for version 2.0:
    ReSharper 8.2 TypeScript Jasmine Support

    To add support for Jasmine via TypeScript, simply include both original Jasmine (jasmine.js) as well as the DefinitelyTyped package (jasmine.d.ts) and then reference the .d.ts file via the <reference> construct, and you’re good to go. Your project will likely look something similar to this:

    ReSharper TypeScript Jasmine Project Structure

As always, we aim to deliver additional new features (and improvements to existing ones) in the near future. Meanwhile, we hope you enjoy this update that is available starting ReSharper 8.2 EAP. Until next time!

Posted in ReSharper Tips&Tricks | Tagged , , , | 14 Comments

Performance Optimizations in ReSharper 8.x

One of the most popular questions we’re facing as soon as we push a new release is whether it works faster than before.

ReSharper performance has a ton of dependencies related to hardware, Visual Studio configuration (including other installed extensions as well as native VS components like XAML Designer) and ReSharper’s own configuration. Nevertheless, the team always finds ways to improve the product’s performance. This is an ongoing process across all our releases, and 8.x is no exception.

Let’s take a look at where exactly ReSharper 8.x became faster: overall UI responsiveness, coding assistance, code analysis, and unit testing. No mile-length lists*, just highlights.

*For those who are interested in statistics, it’s 170+ improvements (and growing).

Coding Assistance

When the auto-completion pop-up takes seconds to appear, I get the urge to smash the monitor or throw my keyboard across the room. Can you blame me? Well, since the coding assistance improvements in ReSharper 8.x I’ve gotten way more peaceful, and hopefully you will too.

  • Lower Impact on Typing
    All phases of code completion have become interruptible. What does this mean for you? Typing should be much smoother now as it doesn’t interfere with coding assistance.
  • Faster Displaying of Lookup Items in Pop-Ups
    Now we cache all lookup items in Intellisense, meaning it works faster on the second run and all subsequent ones. For example, here are two call stacks taken with dotTrace for ReSharper 7 and ReSharper 8 correspondingly. Both reflect the second run of an auto-completion pop-up showing a list of graphic files available for selection within the project.
    VS 2012 with ReSharper 7
    R#7 displaying lookup items
    VS 2012 with ReSharper 8
    R#8 displaying lookup items
    Thanks to caching introduced in ReSharper 8, the method that gets the results completes 16 times faster.

We’ve also fixed many other small assistance issues, like hangups during smart completion in VB, lags when erasing long symbol sequences, and more. Though most are minor, when taken together they result in a tangible performance improvement.

Code Analysis

Code analysis is also an area we consider to be crucial from the performance perspective. Even though solution-wide analysis is carried out in the background, poor performance here can lead to noticeable lags in Visual Studio. That’s why we’ve made some tweaks in this area.

  • Optimized Solution-Wide Analysis
    Solution-wide error analysis (SWEA) now utilizes the CPU much more efficiently. As a result, SWEA is finished a little bit faster, especially on complex solutions. What is more important, solution-wide analysis has a lower impact on the UI, thus improving its responsiveness.
    On the screencasts below, you can see how typing performs in ReSharper 7 and 8 at the same stage of solution-wide analysis.
    VS 2012 with ReSharper 7
    R#7 Solution-wide analysis
    VS 2012 with ReSharper 8
    R#8 Solution-wide analysis

Overall UI Responsiveness

Many of you complained about lags in the user interface when performing some ordinary actions in the UI: lags during code editing, slow loading of context menus, slow auto-completion on JavaScript, and others.

It’s no secret that most of these problems are related to numerous tasks that ReSharper is doing in the background. These background tasks became our main target for optimization in 8.x releases.

  • Faster Solution Building / Loading
    We’re constantly working to reduce ReSharper’s impact on the performance of Visual Studio’s native features. As our tests show, Visual Studio with ReSharper 8.x builds a solution up to two times faster than Visual Studio with ReSharper 7. Moreover, VS with ReSharper 8.x loads a solution nearly 20% faster.
  • Faster Caching
    ReSharper loads its caches much faster now. Among many improvements here, we optimized the way ReSharper works with its database that stores caches. The database (and your hard drive) is now accessed far less frequently.
    As a result, there are no lags when typing while the caches are being loaded. Exact numbers are difficult to evaluate as they are highly dependent on solution complexity.
  • Optimized Memory Usage
    We did our best to minimize memory traffic in main ReSharper usage scenarios. This should significantly lower the number of cases when Visual Studio UI hangs for a moment and then continues working. For example, consider such a common operation as Find Usages.
    The diagrams below show memory traffic (for ReSharper 7 and 8 correspondingly) when searching for all string usages in a large project.
    VS 2012 with ReSharper 7
    R#7 Memory traffic
    VS 2012 with ReSharper 8
    R#8 Memory traffic
    As you can see, the traffic in ReSharper 8 has dropped 15%. As we said before, large memory traffic causes excessive Garbage Collections which, in turn, lead to UI freezes (true for GCs longer than 200 ms). If you want to know how we fight such bottlenecks, it’s a combination of the Timeline view* in dotTrace and a new dotMemory tool (yep, we’re strong dogfooding followers). Timeline in dotTrace allows detecting all UI freezes (yellow stripes on the timeline diagram show Blocking GC) while dotMemory lets us determine exact objects that cause the traffic.* (This view will be available in the upcoming dotTrace 6.0.)Timeline view in dotTrace
    The snapshot was taken when typing during solution-wide analysis.

Unit testing

The unit testing subsystem was also redesigned for ReSharper 8 to eliminate the key annoying lag that users complained about in ReSharper 7.

  • Faster Start of Unit Tests
    We’ve entirely reworked the way ReSharper runs tests. ReSharper 7 took a lot of time (whole seconds) before the tests were actually run. In ReSharper 8.x, it’s no longer a problem: tests are run almost instantly.
    VS 2012 with ReSharper 7
    R#7 Running unit tests
    VS 2012 with ReSharper 8
    R#8 Running unit tests

Your Help is Invaluable in Improving ReSharper’s Performance

Of course, we would never be able to find all these issues without the ReSharper community. Yes, we mean you, our valued customers and fans!

The main problem when fighting performance issues is that they are very hard to test and reproduce. The thing is, they are very sensitive to the environment: the complexity of your solution, installed Visual Studio plugins or NuGet packages, system components, and other factors. For obvious reasons, we are unable to test ReSharper on all possible environment combinations. And that’s where you can help us tremendously.

Profile Visual Studio menu

If you suspect ReSharper may be slowing down your work in Visual Studio, follow these steps to make sure that ReSharper is indeed the culprit. If it is, run the built-in dotTrace profiler (go to ReSharper | Help | Profile Visual Studio), profile Visual Studio and send a performance snapshot our way. We will look at your performance snapshot, locate the bottleneck and do our best to fix it.

As outlined above, we made a lot of performance optimizations to bring you the improved ReSharper 8.x. But of course we’re not stopping there. For ReSharper 9, we plan to do a lot more work in terms of improving performance. Stay tuned!

Posted in Other | Tagged , | 6 Comments

dotCover 2.7 EAP is Open

Spring is here and so is dotCover 2.7 Early Access Program. Now you can download and play with EAP builds. Please welcome integration with ReSharper 8.2 EAP and Standalone runner.

27 eap

We would be happy to get your feedback via dotCover issue tracker. Stay tuned for further updates.

Posted in dotCover Tips&Tricks, News and Events | Tagged | 5 Comments

Webinar Recording: dotMemory 4.0 – What’s Inside

The recording of our February 25th webinar with Maarten Balliauw, dotMemory 4: What’s Inside, is now available on JetBrains YouTube Channel and slides on slideshare.

In this webinar we explore the new dotMemory 4 memory profiler. We share our view on why one may want to use a memory profiler and show how easy it is to use dotMemory to find and solve memory issues.

Even if your program is just a few lines of code, .NET’s runtime will create a number of objects in memory. Are all objects being destroyed by the garbage collector? Or is there a potential memory leak? And why is the application seemingly slow when having lots of objects in memory? Find out in this webinar.

Below are select questions and answers from our webinar:

Has dotMemory 4 been released already?
No, not yet. We currently have an EAP version available for everyone to try. Do give us feedback if you’re using it! The final release will be there around the end of April.

Can dotMemory profile .NET 4.0 applications?
Yes it can! dotMemory allows memory profiling of applications written in .NET (all versions up to 4.5.1) and Silverlight, as well as Windows Store applications.

For more information on dotMemory, please see our blog post dotMemory 4.0 EAP: .NET Memory Profiler Resuscitation.

Maarten BalliauwMaarten Balliauw is a Technical Evangelist at JetBrains. His interests are all web: ASP.NET MVC, PHP and Windows Azure. He’s a Microsoft Most Valuable Professional (MVP) for Windows Azure and an ASPInsider. He has published many articles in both PHP and .NET literature such as MSDN magazine and PHP architect. Maarten is a frequent speaker at various national and international events such as MIX (Las Vegas), TechDays, DPC and others.
Posted in dotMemory Tips&Tricks | Tagged , , | Leave a comment