True to form for the .NET Reflector team, Ryan brings a suite of talents to the table. UX specialist, top-notch facilitator, front-end web designer, triathlete, and gourmand. All essential skills. Ryan takes no prisoners, makes no compromises, and pulls no punches. In another life, we’re pretty sure he was a gritty, hard-boiled, film noir detective. On a sweet bike.

What’s your background? (What technologies have you worked with, etc.?)

My story starts in a one room shack on the side of a mountain in North Carolina.  The screen door flapping in the light breeze, the dog barking, rocking easily on the porch while fighting the oppressive summer heat with ice tea in hand.  When my granddad did move the family off the mountain, he finally ended up building aircraft carriers at the Norfolk Shipyard.

By the time I was old enough to switch on a computer I began doing things like playing Bushido and Parsec and writing TI Basic, which was very basic.  With a strong interest in science, art and music I went to University to study art.

With a degree in studio 2-D art in hand, I began traveling and building websites in 2003.  My strengths and experience are firmly rooted in UX, visual design, front-end web technologies and time working in PHP development along side of my experience in marketing, strategic branding, and all the other skills you pick up working in boutique web shops.

What are you working on at the moment?

Currently I’ve just helped in some small way to get v7.5 out the door.  Mainly working on improving the experience around the Visual Studio installation and helping out with the decompilation and PDB creation within VS.

That’s just the beginning though, and I’m working hard to lay the groundwork for v8.  We’ll be doing some user research and more usability testing to create an even more seamless experience inside of VS.  If you’re interested in helping with research and feedback please get in touch with us and let us know, as there will be some exciting opportunities to help look to the future of Reflector.

If you could make one change to the .NET Framework, what would it be?

I’d give it a sexier name, something like LoveFrame.

What’s the most interesting / satisfying project you’ve worked on, and why?

The most satisfying project I’ve ever worked on was helping an orthodontist in the States bring the energy and fun she brought to her office, which was covered in murals by a mate of mine, to her website.

I find doing work for small businesses extremely satisfying.  You’re (hopefully) helping people realize their dreams, and what can be a small job for you can make a big impact on them.  In this particular case, it was just fun to work with someone who cared about her patients and wanted to make something as scary as orthodontics as fun and welcoming as she could.

Sadly the work I did for her isn’t still around, but it was definitely one of the most satisfying projects I’ve worked on.

What do you do to relax?

One of the ways I relax is cycling when I can get the time. The farmland around Cambridge on a sunny day is a glorious time to enjoy the English countryside. Currently I relish relaxing on my custom build Omega titanium frame with SRAM Force, Fulcrum 3 wheels, 3T handlebars and seatpost. It’s no Pegoretti, but I’m really enjoying it.

What’s your favorite book (technical or non-technical), and why?

Non-technical

“Duchamp” by Calvin Tomkins, because it is about one of the world’s great artist and consummate gamesman, and is a textbook on how to keep a playful mind throughout your life.

“Farewell to Arms” by Ernest Hemingway, because it shows how men can be manly, yet know war is wrong and still write incredibly sad, beautiful stories.  That’s a true man.

Technical

“Facilitator’s Guide to Participatory Decision-Making” by Sam Kaner, because interfacing people is as technical as you get.

Do you have any advice / suggestions / questions for other UX Specialists

I’m sure lots of people could share their wisdom on being a great User Experience Specialist better than myself, but I would say being a good User Experience Specialist is a lot like being a well-rounded person.  It helps to be good at lots of different things and be able to pull those things together in new ways.  I’m learning these days to embrace my inner generalist and realising that it’s a strength, not a weakness.

Beyond that, I think what makes you really good is to always remember that implementation is a crucial part of design.  The real design happens when you try to actually create something, not when you conceive it.  Often during implementation is where some of the best solutions come from.  If you want to be an artist, you don’t want to work with developers, but if you want to be a great designer build a relationship with the best.  Nothing pushes you more than working with amazing developers and testers.  Luckily the Reflector team has those in spades.

Today we are proud to announce the release of .NET Reflector v7.5. This release brings several enhancements to our Visual Studio integration, as well as improvements to the stability, performance, and design of Reflector itself. The new features allow developers to decompile, debug, and understand any .NET code within Visual Studio, using Visual Studio’s native debugging workflows.

Our roadmap for 7.5 was to bring you:

• A fully-featured Reflector Object Browser (ROB) inside Visual Studio
• Dynamic type-by-type decompilation in the Visual Studio editor
• An improved Visual Studio debugging experience, step straight into code without source

Our eventual goal for Reflector is to make working with any code as easy as working with your own, and 7.5 is a big step towards that. As you can see from our extensive changelog, we’ve worked hard to make our integration with Visual Studio closer to seamless, and to bring powerful dynamic decompilation right into your normal workflow.

You can read more about the work that went into .NET Reflector 7.5, but for us the highlights above and beyond the basic roadmap would have to be:

• The ability to Go To Definition (F12) on any .NET code, whether you have the source code or not
• PDB files are now automatically generated when you set a breakpoint
• PDBs can be generated in parallel, and in ways that will fit smoothly into your workflow
• Design and UX enhancements to improve the Reflector experience is Visual Studio
• Reflector is now a Visual Studio Package, rather than an add-in. We’ll be able to do much more to support developers with this deeper integration with VS.

We’d also like to say a huge thank you to all of our EAP users for all of their feedback and their time. Download a free trial of .NET Reflector 7.5 and take the new features for a spin, and leave us comments to let us know what you think!

What the .NET Reflector team have to say:

Just before Christmas, I had an opportunity to talk to the inestimable Peli de Halleux, Microsoft researcher &, with support from Lutz, a prolific author of .NET Reflector addins. If you’ve not had the opportunity to read his blog, you should – he doesn’t post often, but when he does, it’s worth a look.

I’m very pleased to announce that many of Peli’s classic add-ins are now available from our .NET Reflector add-in showcase in one handy, productivity bundle.

Unfortunately for all of us, Peli’s talents are now in intense demand, and so he hasn’t been able to enhance his add-ins, or create any more, for quite some time.

On the upside, he’s happy for us to wrap his most popular (and up-to-date) tools into one convenient bundle, which you can download and use to make .NET Reflector even more indispensable. In no particular order, the available addins are:

• CodeMetrics
  Analyzes and computes several code quality metrics on your assemblies, such as cyclomaatic complexity and number of local variables in a method (to name just two). If you find this useful, then you might also like NDepend.
• Review
  A lightweight code annotation addin.
• Graph
  Shows assembly dependency graphs. If you like this, then you should definitely check out Denis Markelov’s Assembly Visualizer addin, and maybe even Refractor.
• ComLoader
  Allows the importing of COM/OLE type libraries using .NET Reflector’s file menu. You may prefer to do this via the command-line, but at least now you have options.

These addins will make the standalone component of .NET Reflector an even more powerful code review tool, so download the whole set (it’s completely free for all versions of Reflector), and give them a try.

There is additional documentation available as part of the bundle, and although we’ve tested these addins in versions 6 & 7 of Reflector, please bear in mind that they are provided as-is. If you have any questions, join us on the forums & we’ll see what we can do!

(or “How to Check if Production Code is Obfuscated“. Another Guest post by David Connell (with a little help from Dom Smith, Jason Crease, Clive Tong, and Chris Massey)

David Connell, back again, and still a software developer at Red Gate. Here at Red Gate we are careful to obfuscate released software in order to help protect our intellectual property, and the obfuscation is performed by one of our other products, SmartAssembly, which should be run by our build system automatically. If you recall, I’ve been looking at a way to use .NET Reflector to automatically check whether our products are obfuscated, and I’ve made the full source code for the solution available at the bottom of this post.

To recap, a while ago, one of our testers, Robin Hellen, said that he wanted his automated tests to check that files were definitely being obfuscated. I quickly realised that I could use the .NET Reflector API to solve this challenge (Having already had some experience with it).

The easist way for me to solve this was to produce a WinForms application that:

1. scans a folder looking for assemblies
2. loads the assemblies
3. displays whether or not the assemblies are obfuscated.
4. attempts to work out which features of SmartAssembly were used when the assemblies were built.

Before I go on too much further I must explain that here at Red Gate we typically split our desktop applications into 2 tiers. A UI front end and a back end that actually does the work. The back end is typically called the engine as it caries out the actual work. This “Engine” has no UI and can normally be at least easily Integration tested, if not Unit tested.

However, in this case, because the engine is interfacing with .NET Reflector it has to have some UI components. This is because the fact that Reflector is a Windows application is currently hardwired into the code, and the usual pattern of separation isn’t there, and so the engine really wants to be able to create windows. Thankfully, it can be fairly easily used by Robin for his automated testing, where the UI front end can display the information that the engine produces.

At this stage, I must also thank Jason Crease (tester on SmartAssembly) and Ryan Haney (UX designer on .NET Reflector) for their assistance with the final steps in getting this tool working.

Creating the application was mainly a process of using the Microsoft Visual Studio debugger, Intellisense, and JetBrains Resharper to find the methods in the Reflector API that were useful for achieving the application’s aims.

The back end/engine code for this tool was pretty much covered in my previous blog post, so it’s worth taking a look at that to refresh your memory. Since then, I have made some minor changes to the backend, mainly to clean up the API and remove any idiosyncrasies. In addition, having teamed up with the previously mentioned Jason & Ryan, we came up with a quick and clean UI for the tool:

You can filter by company and sort by single column, and users can also double-click a given line to get more details about the application and how it’s obfuscated.

All this functionality is wrapped up in the Engine code and, as I mentioned, the UI is a simple visualization over the top. This is another way of saying that the menu items at the top of the tool window are not currently wired up to anything – they came with the stock UI. I may get around to cleaning them up at a later stage.

On a somewhat related note, SmartAssembly has recently rolled-out a new type of obfuscation called “Method Parent Obfuscation”, and I have not yet investigated supporting this – I can certainly take a look if there’s a need. My currently implementation is not extensible, but I’d like to refactor it at a later date to improve the base code.

Anyway, please play with the code, change it to your needs, and most of all have fun programming and using the.NET Reflector API.

 Download the source code for the Obfuscation Checker

It’s our first release of 2012, and it’s a leap year, so we’re jumping right ahead to EA build 7 (we actually released build 6 quietly over the holidays, but a lot of the work was preparation for Build 7). We’ve been focusing on fine-tuning our integration with Visual Studio, as well as making the best use of our resident UX specialist. We released this at the very end of last week, so the dust has settled, the post-it notes have all been moved, and now is a good time to take a look at the latest enhancements.

Let’s see what’s new.

Setting Break Points

Clive has previously talked about the type by type decompilation we’ve been working on, which lets us provide exactly the code you need, without asking you to jump out to Reflector.exe. We wanted to keep improving the debugging experience, so since the New Year break we’ve been working on integrating more closely with this process inside of Visual Studio.

In the latest EA build, if you have hit F12 to Go To Definition on something (and we’ve decompiled it for you), you can now hit F9 or click in the glyph margin to set a break point. Reflector will automatically generate the necessary pdb file for you, and you’ll be able to start a debugging session to run the code like it was your own.

In fact, once the pdb files are generated, you should be able to perform every native Visual Studio debugging action on the newly decompiled code, be it toggling a breakpoint, inserting new ones, setting a new ‘Break at a Function’ breakpoint, etc.

For a running application, you can also view whether the symbols for your recently generated pdb files were loaded by the Visual Studio debugger via the Modules window.

Stepping Into Code

We’ve also made some progress working alongside the Step Into functionality. So if you’ve generated a pdb for the code you’re looking at, you should be able to just hit F11 to animate the code, and look at what it’s doing. If, for some reason, we can’t step into some code, Reflector will tell you exactly which function it stepped over so you can look at it in more depth.

Naturally, you can also choose to stop displaying these alerts. However, at the moment, there’s no way to turn them back on again, although we’re planning on working that into a future release.

PDB Generation

You’ll also be able to generate multiple pdbs as you’re working by right-clicking in the Reflector Object Browser (or even on the references in your solution explorer) and selecting “Enable Debugging”.

Generating pdbs can take a little time, especially if you’re doing lots of them at once or doing it for especially large assemblies, but you should only have to do it once for each assembly you want to look at. Naturally, we’re going to keep working on this process to make it faster.

Finally we thought we’d give the trial dialog screens a bit of a facelift for the New Year, and as part of our continuing UI overhaul.

As always, we want to hear about what you think we’re doing right or wrong, and indeed any feedback you’d like to share with us. Contact us at eap@reflector.net or on the EAP forums.

Previous posts mentioning 7.5

• .NET Reflector V7.5 EAP Build 1
• .NET Reflector V7.5 EAP Build 2
• Morrissey: Byte Code Manipulation using Reflector
• .NET Reflector V7.5 EAP Build 3
• .NET reflector V7.5 EAP Build 4
• A little pre-Christmas housekeeping – early access build 5

What’s your background?

When I was a schoolboy there weren’t any computers on the school premises. The senior students were allowed to submit programs on green sheets which were sent away, transcribed and then executed on a mainframe at a college 30 miles away; after two days you got back a paper tape and a printout of the results. I got hold of a book on FORTRAN and managed to persuade some of the seniors to submit the programs for me. This modern generation have it easy.

When I was in the third year, I convinced my parents to buy a TRS-80, though had to get a holiday job to contribute towards it. Using this, my school kindly let me take computing exams on the understanding that I taught myself, which I did. I also wrote to ICL and they sent me a book on 2900 assembler, so I also got to play with low level stuff. After this it was a BBC-B micro and an obsession with writing chess programs, in a combination of BASIC and 6502 assembler.

I was lucky to get sponsorship for my university days, and hence spent a year before university working on a dual array processor - a machine with two grids of 32×32 processors which could efficiently run lots of algorithms written in FORTRAN (in the manner of modern graphics card). During the year, I was mainly writing test programs, so spent time learning C and reading about compilers and Lisp, and hence wrote my first Lisp interpreter in C and my first compiler. I also came across the lazy programming language Lispkit Lisp.

I started a Maths degree here in Cambridge, but spent the summer and Christmas vacations working in Manchester. This time I was in a team working on a multiprocessor machine programmed using functional languages. The actual processors worked using a low level language, DACTL, and I had a lot of interesting work on benchmarking and writing about efficient optimisation of DACTL. I was also lucky enough there to be introduced to computational mathematics such as type theory and denotational semantics.

After a maths degree, I realised that I wasn’t the one who was going to solve the Poincarre Conjecture. I decided that computing was my future, and so took the one year conversion course and then got a job for a local company.

It’s hard to describe how fantastic a place Harlequin was. During my time there I wrote large chunks of an ML compiler, ported the Common Lisp system to the DEC Alpha (which taught me loads about low level debugging, link loaders and compilers), ported the garbage collector and compiler from Unix to Windows and wrote most of a CORBA ORB which allowed objects written in Common Lisp to interact with objects implemented in languages like C, and Java. I got to travel to various trade shows in Europe and the US, and they even re-employed me after I left to start a Phd in Computer Science (though I only managed a year of work on generating programs from constructive mathematical proofs). The best part of working in Common Lisp is that we had to implement all sorts of stuff – link loaders to allow us to interact with C (this was before the days of shared libraries), GUI libraries and full compilers. A modified version of the Lisp system also ran on a space probe.

After Harlequin, I worked for another Cambridge company, adding COM support to their scheduling system. This eventually extended to writing an OLEDB layer which exposed the internal object model via a set of COM objects, and via a set of table objects which you could query via OLEDB using an SQL interpreter (which I also wrote). During my time at this company, .NET came along, so we started implementing things in a mixture of C# and Common Lisp using various methods to bridge the gap.

After that, I came here to Red Gate where I first worked on an email archiving solution for Exchange. I implemented most of the archiving and retrieval tasks and the scheduler that ran them, a web service for accessing the email repository, and the C#/javascript combination responsible for seamlessly integrating retrieval and display of archived emails into OWA (Outlook Web Access). After a year or so, I moved into the .NET group where I’ve done a small amount of work on the profilers, but have mainly been involved in work on Reflector.

What are you working on at the moment?

Reflector – all of it, including the extensions that make up Reflector Pro like Visual Studio integration and pdb generation.

If you could make one change to the .NET Framework, what would it be?

I’d implement all of it in managed code. In my days of working on Lisp systems, the garbage collector, for example, was written mainly in Lisp with a small amount of portable assembler (much like IL) – the only C was the code that passed various library entry points into the system start-up code. There’s nothing more annoying that following a trail using Reflector only to find that the framework branches out into external code which you can’t see. I’d have written the C# compiler in C# from the early days, something that Microsoft are only just doing now as part of the Roslyn project.

From a C# standpoint, I’d also have wished to find a better pattern for extending the language. The F# team seem to have done well by having a notion of a computational workflow, a pattern that can be used to implement many extensions such as sequences and async. In the Common Lisp world, the core language is very small and hence easily understandable, and macros can be used by libraries to extend the syntax, with macroexpansion allowing you to see the transformations that the compiler is making.

What’s the most interesting / satisfying project you’ve worked on, and why?

The most exciting three months’ work I have ever done was porting the Harlequin Lisp system to run on the Dec Alpha. This involved lots of very low level detail. First you wrote a description of the machine language for the Alpha, and then wrote translations of the intermediate language into this machine language.

You then had to cross compile the system using the Common Lisp system running on a different architecture.

You then spent time debugging this in order to get a base amount of functionality, such as the compiler, running.

You then implemented the parts of the link loader that were specific to the architecture so that you could load the “C” code for talking to X Windows.

Then you sat back and watched the system start up and display windows on the screen. And you did all of this in an exciting, fully engaging three months of effort.

What do you do to relax?

Sport! I started out as a competitive swimmer when I was 9 and have done some swimming ever since. Over the years, I’ve also practiced martial arts of various kinds, typically up to three times a week when I was in my 30s. My current favourites are squash, 5-a-side football, cricket (on the two days a year the weather is suitable in the UK), table tennis and running (10km).

At Harlequin we used to juggle most lunchtimes, and I still do a little juggling, but very badly.

I love hill walking in the Lake District, and have recently discovered chess, though I’m truly hopeless at it. For the last ten years I’ve also vainly tried the monthly IBM ponder, which has a fantastic range of puzzles.

What’s your favourite book (technical and / or non-technical), and why?

My favourite book around the subject of philosophy, mathematics and proof is Goedel, Esher, Bach, though I admit to last having read it 20 years ago. It is a fascinating mix of ideas of around proof, symmetry and intelligence.

My favourite technical books are The Art of the MetaObject Protocol and the Smalltalk Blue Book. Both books show the beauty behind the design of reflective programming systems.

The Science Fiction story that had the most effect on me (when I was 8 and the teacher read it to us) was A Sound Of Thunder, which contains the time travel paradox idea and the Butterfly effect that you see everywhere these days.

A few years ago I really enjoyed The Life Of Pi, though sadly it turned out not to be a book on mathematics.

Do you have any advice / suggestions / questions for other developers?

First, always be willing to help others. Not only does that help them, but you usually learn something new yourself, either from the way they work or from their mental model of whatever you are trying to debug.

Second, if you don’t know something, say you don’t! Making up unsubstantiated rubbish just confuses other peoples’ mental models and isn’t helpful.

Third: read, read, read… new ideas help clarify the ideas you already have. Podcasts can be useful but it’s harder to skip to the interesting bits without sitting through all of the filler. Read a computer science paper every now and then from http://lambda-the-ultimate.org/

Fourth: you can achieve a reasonable level of skill in almost everything, though you need to be willingly to put the effort in.

Oh, and don’t worry about getting old – lots of ideas from the old days are finding their time as we speak.

Roger is a hardened veteran from Red Gate’s SQL Tools division, where he championed the cause of clear technical communication and information architecture. He has stared down development teams, and menaced project managers into doing what they know in their hearts to be right for their users. He’s also been tied to his chair using Christmas lights, which he’s not very pleased about…

What’s your background?

I was Red Gate’s first graduate technical author four years ago, and I’ve spent most of my time since working on the SQL Tools. Primarily, I’ve been looking after the documentation, user interface text, user assistance, and bits of marketing for SQL Compare and SQL Source Control, though I’ve done bits and pieces for most of the SQL tools over the years. Before that, I was pushing invoices around for a large chain bookshop, and before that I was doing an English Literature degree.

It’s not an obvious techy trajectory, but I’ve always messed around with computers. I wrote my first lines of code on a BBC Micro, way back when, and taught myself HTML instead of revising for my chemistry GCSEs. In hindsight, that last part proved to be a poor judgement call.

What are you working on at the moment?

Getting to grips with Reflector, and working with Greg to figure out where to take it. Phrases like “strategic marketing planning” smell of oleaginous corporate double-speak, so let’s just say I’m working out what to do next. It’ll involve giving the website a sound kicking, but the first big deal is going to be to talk to a bunch of our users and find out what they actually care about.
Right now, as in, today, I’m looking at some tech comms bugs we’ve got raised against Reflector. There’s plenty of stuff we should be able to make easier to understand.

If you could make one change to the .NET Framework, what would it be?

If I’m honest, I’m only just wrapping my head around it after a few years immersed in SQL, so I’ll have to get back to you on that.

One thing I will say is that it would be nice if .NET languages were taught wider, earlier. IT education in schools is basically just teaching people to use Excel and Powerpoint. It’s tragic. I’d like to see more kids coding, and coding in richer languages. It doesn’t have to be .NET, I guess, but I’d love to see more people with basic coding skills.

What’s the most interesting / satisfying project you’ve worked on, and why?

I’ve had a chance to do quite a lot of varied stuff here, so it’s hard to choose, but it’s probably been SQL Source Control. I was on the project from the beginning, when it was a couple of back-of-a-napkin sketches, and it’s been deeply nifty watching it turn into a big, successful product.

That said, the borderline-unhinged, pony-based gamification project on SQL Prompt was pretty good fun (if you’re interested, ask about it in the comments thread)

What do you do to relax?

I do a lot of cooking. I’m sure plenty of people would think that’s the opposite of relaxing, but it definitely helps me unwind. Making things is always satisfying like that. I read a lot, too, and I’m not averse to a spot of scuba diving.

What’s your favourite book (technical and / or non-technical), and why?

My favourite technical book isn’t very technical, I’m afraid, but it’s bloody useful. Human Factors for Technical Communicators is a really thorough introduction to the underlying cognitive psychology and learning theory for UX and tech comms. It’s a pity it hasn’t been updated in a while.

Non-technically, it’s Virginia Woolf’s novel The Waves. I could bore you for hours on why, and once wrote a long and deeply pretentious paper on the way it explores collective consciousness and identity creation. It’s also beautifully written (the book, not my paper).

Do you have any advice / suggestions for other product marketing specialists or technical authors?

Umm… get out of the latter and into the former? That isn’t going to make me any friends, but the days of “old school” tech comms are decidedly numbered. Seriously, the paper-manuals dinosaurs need to look up and see the incoming asteroid. For the rest, it’s all about point of need assistance, and wider content strategy; and frankly, tech comms and marketing are blurry now, and are only going to get blurrier.

Even if you don’t much like the sound of that, there’s something deeply applicable to both fields I’ll share: it’s basically impossible to do too much user research.

We’ve released our 5th early access build

The previous few builds have been about making the Visual Studio integration more seamless and morphing from being a Visual Studio Add-in to a Visual Studio Package. The whole team is working towards making seamless, dynamic decompilation and automatic ‘Step Into’(F11) code without source a reality.

To help, we came up with the ‘ROB’. For the world outside it’s known as the ‘Reflector Object Browser’. You can now right click on any assembly in the ‘ROB’ to make it debuggable. This generates the .pdb file for that assembly in the cache directory, and enables you to dynamically step into the implementation of an assembly by just hitting F11. Similarly, you can also double-click on any method in the ‘ROB’ to dynamically generate the code for it in Visual Studio.

So, why this new early access build just within a week of the previous early access build? Well, we decided that this sprint would be all about doing some housekeeping tasks which we’ve wanted to do for a long time, but didn’t manage to prioritize earlier. We’ve now managed to fix quite a few bugs around general usability, ‘Go to Definition’ functionality, licensing, and SmartAssembly.

Here is an entire list of what’s new for this EAP:

• ‘Go to Decompiled Definition’
  We re-introduced the ‘Go to Decompiled Definition’ right-click menu item in the Visual Studio text editor. It enables you to go to the definition of a type decompiled by Reflector, if there is a conflict with the Visual Studio ‘Go to Definition’ behaviour. For example, right-click on ITypeDescriptorContext, and click ‘Go To Decompiled Definition’:
  

  The Go to Decompiled Definition menu item

  This takes you to:

  

  Viewing the decompiled code.

• Issues with different versions of the same assembly
  There were problems with dynamic code generation for two versions of an assembly being shown in the ‘Reflector Object Browser’. For example, if you have two different versions of mscorlib, you should now be able to inspect the code for each version simultaneously.

• Better ‘Go to Definition’ support
  ‘Go to Definition’(F12) should now work for many more keywords which weren’t enabled previously, for example the ‘this’ keyword.

• ‘Flatten namespaces’
  We fixed the long-lingering bug with the flatten namespaces dialog box. It seemed to appear regardless of whether the flatten namespaces option was turned on, and this is now fixed.

• Usability enhancements
  We managed to pull out a list of usability issues from our long-standing pool. We’ve looked at: Activation/Deactivation menu items, inclusion of icons in various places, some messages in the ‘ROB’, and sorting on the ‘Choose Assemblies to Debug’ dialog box (now enabled by version type and Isdecompiled check box in). We also have a modal dialog to let a user know that their methods are being decompiled whenever a request for dynamic decompilation is made.

• SmartAssembly bugs
  Last but not the least, we’ve been able to fix few SmartAssembly issues sent in by those of you who tried our previous EA builds. Most of these were around licensing and installation.

As always we’d love to here your feedback on the latest EAP or anything to do with .NET Reflector so please drop us a line on the forums or the EAP pages.

Previous posts mentioning 7.5

• .NET Reflector V7.5 EAP Build 1
• .NET Reflector V7.5 EAP Build 2
• Morrissey: Byte Code Manipulation using Reflector
• .NET Reflector V7.5 EAP Build 3
• .NET reflector V7.5 EAP Build 4

The work on getting Reflector working inside Visual Studio is progressing fairly quickly. In the previous EAP, we detoured a little, re-implementing the existing Addin as package (for users of VS2010 onwards) in order to allow us to get tighter integration into Visual Studio.

This has allowed us to work with the F12 shortcut and associated “Go To Definition” command, dynamically decompiling source as needed.

As in previous EAPs, the Reflector Object Browser (ROB) is populated with the assemblies that are referenced by your solution. You can then navigate through these assemblies using the Reflector tree, double-clicking at any time to decompile and display the source in an editor window. For example, here I navigated to AppDomain in the ROB and double-clicked…

I can then place the cursor on the method invocation of PrepareContractedDelegate, and hit F12…

This will dynamically decompile the method (if needed) and display it in an editor window. Binding to the F12 key makes the whole navigation process a lot less fiddly than having to bring up a context menu in order to go to the next piece of decompiled code.

We have plans to push this functionality further after a period of consolidation. You can now chose to make an assembly debuggable (our term for generating an associated pdb file) from three different places.

(1) The original .NET Reflector dialog

(2) The Reflector object browser

(3) And the references of a project

We’ve therefore spent some time updating the progress mechanism that these three entry points use… we didn’t have time to get that finished for the EAP, but there are some good usability designs that we will get implemented in the near future.

Things we didn’t quite finish off in this sprint, and which will be carried across to the next sprint include tidying up the .NET Reflector dialog, and improving the speed of the dynamic decompilation (in particular the time taken when you first select a given assembly). We are hoping to get that next EA in before the Xmas holiday.

Just so you’re aware, if you do choose to use this EAP, you’ll need to manually uninstall any existing EA3 package from Visual Studio, which you can do via Reflector or via the Visual Studio extension Manager. As usual, we are very grateful for feedback, as it us ensure that we stay on the right track.

Previous posts mentioning 7.5

• .NET Reflector V7.5 EAP Build 1
• .NET Reflector V7.5 EAP Build 2
• Morrissey: Byte Code Manipulation using Reflector
• .NET Reflector V7.5 EAP Build 3

What are we doing?

Acting on some conversations we’ve had with the guys at Microsoft, we’re currently in the process of changing how we integrate with Visual Studio. Specifically, we’re moving away from being a Visual Studio add-in, and towards being a Visual Studio package.

But why?

The short answer is that it gives us a whole lot more flexibility in terms of what we can do within Visual Studio. If you’re interested in a few more specifics, you should check out the series of articles written by Keyvan Nayyeri, discussing the differences between visual studio add-ins and packages.

What’s the catch?

We’re putting out these builds every two weeks and we’re in the middle of a fairly large chunk of work, so there are bits of Reflector which look pretty ugly, and bits of functionality which flat out do not work. These include:

• Resource viewer isn’t displaying
• The menu items from previous versions of Reflector are not currently automatically cleaned up

There is also a small bug in the Visual Studio integration: If you’ve previously integrated the Reflector package with Visual Studio (i.e. if you grabbed the EA build last week, before we’d had a chance to catch a few trailing issues), attempting to integrate this latest package will cause a (fairly generic) error. This is because we haven’t quite got the automatic updating process working, but there is a very simple work-around. Before you integrate this latest build of Reflector with Visual Studio, open VS, go to the Extension Manager, and uninstall the previous Reflector extension. Problem solved.

What’s Shiny?

We just added Visual Studio 11 integration, which you’ll be able to find in Reflector ->Tools ->Integration options. It’s pretty new, so if you run into any problems please let us know. Clive has also exposed some more interfaces in the Reflector API (to do with byte code manipulation).

Data-Driven Development

We’ve implemented Feature Usage reporting by default in all the EAP builds – essentially, it dramatically changes the way we develop and improve the product by giving us quantitative feedback we just can’t get any other way. The technology exists in all of our builds, but it is only turned on by default in our EAP. Rest assured that all reports are completely anonymous, and only contain information about Reflector itself (i.e. nothing about what you’re using it to decompile etc.). If you have any questions about this, feel free to get in touch.

Of course, we still need your input! Please do keep letting us know about bugs you find, improvements we could make, and what you think of our new package & integration. Drop us a line in the EAP forums or to eap@reflector.net, and keep track of what’s been updated via our EAP gateway.

As always, if you want to be kept up to date on what we’re working on, you should join us on twitter or Google+.

Previous posts mentioning 7.5

• .NET Reflector V7.5 EAP Build 1
• .NET Reflector V7.5 EAP Build 2