I’m working on a fairly major refactoring project, merging a couple of
fairly large libraries together that have some overlapping/similar
functionality. I figured this would be the perfect time to try out the
reasonably new CodeRush Duplicate Code Detection
The solution I’m working on has eight projects - four unit test
projects, four shipping class libraries, and a total of 1248 C# code
I didn’t have duplicate code detection running in the background during
the initial pass at the merge. Instead, I ran the detection after the
initial pass to indicate some pain points where I need to start looking
at combining code. (Let me apologize in advance - I wanted to show you
the analysis results in a real life project, but because it’s a real
project, I can’t actually show you the code in which we’re detecting
duplicates. I can only show you the duplicate reports. With that…)
First, I started with the default settings (analysis level 4):
Running that pass took about eight seconds. I found a few duplicate
blocks in unit tests, which weren’t unexpected. Things having to do with
similar tests (specifically validating some operator overload
I wanted to do a little more, so I turned it up a notch to analysis
level 3 and ran another pass. This time the pass took about 12 seconds
and I found a lot more duplicates. This time the duplicates got into the
actual shipping code and started pointing out some great places to start
refactoring and merging code. This pass also grabbed more duplicates
across classes (whereas the previous pass only caught duplicates within
a single class/file).
Well, since one notch on the analysis level settings was good, two must
be better, right? Let’s crank it up to analysis level 2!
Once you get to level 2 and below, you get a warning: Analysis might
require significant CPU power and memory. I’m not too concerned with
this right now since I’m running the analysis manually, but if you turn
on the background analysis mechanism you’d probably want to verify
that’s really what you want.
Anyway, the third pass using analysis level 2 still only took about 12
seconds… and re-running it, to verify that time, only took around 5
seconds so I’m guessing there is some sort of caching in place. (But
don’t hold me to that.)
Now we’re talking! Tons of duplicates found on the level 2 run. However,
while the code is very similar, there aren’t as many “automatic fixes”
that the system can suggest.
I don’t fault CodeRush for this - the duplicates will require a bit of
non-automated thought to combine, which is why they pay us
(programmers). (If they could replace us with scripts, they’d do it,
right?) I’m sure the geniuses at DevExpress will shortly replace me with
a keystroke in CodeRush so they can hire my cat in my place, but until
then, I can use this as a checklist of things to look at.
Out of curiosity, I decided to do another run, this time at level 0 -
the tightest analysis level available. This run took ~50 seconds and
found so many duplicates it’s insane. Some are actionable, some are what
I’d call “false positives” (like argument validation blocks - I want the
validation to take place in the method being called so the stack trace
is correct if there’s an exception thrown). Still, this is good stuff.
Given the balance between the too-granular detection and the
not-granular-enough, I think I’m going to go with the level 2 pass,
address those things, and then maybe turn it up from there.
Overall, I was really impressed with the speed of this thing. I mean,
1248 files, thousands of classes… and it takes less than a minute to
do super-detailed analysis? That’s akin to magic.
Big props to DevExpress for a super-awesome tool that helps me improve
my code. And, hey, some of the automatic fixes that are built
don’t hurt, either. :)
If you want to use this on your project, head over and pick up
CodeRush. Honestly, it’s the first
thing I install right after Visual Studio, and this sort of feature is