What's that you ask?

"Hey Mark, how are you doing on that crazy goal of shipping 100 refactorings in 2007?

Are you done? Have you reached 100 yet?"

Um, no.

...

But thanks for asking.

Look, my team has done their best. And I've tried to stay true to my original pledge to you. Unfortunately I've come to realize in these past few days that sometimes it's better to let go of your dreams.

So in light of my present failure to ship 100 refactorings in 2007, and in an effort to avoid embarrassment, I've realized that right now might be a good time to revise my previously stated goal.

I'm no longer going to try to ship 100 refactorings in 2007.

Sorry kids. I know you're disappointed that I've abandoned my goals so soon, and here we are not even halfway through 2007.

But I think it's important to be realistic and adjust expectations accordingly.

...

That's why I've decided to go for 125!!!

That's right kids! My brand new new-year's resolution is to ship 125 powerful high-quality refactorings in 2007!

Holy crap! That's at least two-boatloads more refactorings than your great-grandmother had. Why, back in her day they programmed mainframes in hex code by beating the cage with bones borrowed from giant angry animals who were still alive and mighty pissed-off (and semi-rubbery due to their semi-bonelessness)!

Back then, decomposing a parameter was about as fun as standing in a prickly pear patch while performing a tonsillectomy on a saber tooth tiger in heat!

Trust me, I know.

It's times like this you're thinking "Gee, some novocaine would really come in handy right about now for my freakin' HEAD that's about to explode like a crushed melon in this steroid-sucking feline's hot and oh-so-slobbery mouth!"

Siegfried??!! Siegfried!? Vare are you??!!

...

Uh, sorry.

Thankfully though, the user experience has improved somewhat since those dangerous developer days of yore.

...

Of course, it's just now occurring to me that perhaps I should run this new goal by the IDE Tools team *before* announcing to the public....

Naaaaaah!

They like surprises too! 

So, with my totally insane new resolution of 125 refactorings, it looks like we just might almost barely have a sliver of a snowball's chance in hell, as we're now precipitously close to hitting the 4/5^ths mark in this week's 2.2 release of Refactor! Pro.

Check out the momentum as we strive to our new goal and you'll see what I mean:

I know. At this point you've got to be wondering....

Or will I finally get my way-overdue comeuppance, and be forced to face the world in total humiliation and shame?

Only time will tell kids. Only time will tell.

This 2.2 release adds nineteen new refactorings, including five dedicated to ASP.NET development.

Total refactorings (not counting those in early experience): 94

Mind-blowing, eh kids?

Well, that's the trip you signed up for. So you better stay strapped in 'cause this jet-powered bucket o' high-quality refactorings won't be slowing down any time soon.

Yeeeeeeeee-haw!

Have I mentioned the price yet folks?

   Have I?

Offered at a ridiculously-low $99, you're now paying only a $1.04 per refactoring!

We're just doing what we can to drive down the price of the average refactoring to 99 cents or less.

Here's the complete list of 94+ refactorings shipping with Refactor! Pro 2.2 

Each refactoring listed here works in C#, Visual Basic, and C++, unless otherwise noted.

1. Add Block Delimiters (C# & C++)
   Embeds a child statement inside block delimiters (e.g., "{" & "}" in C# & C++).
2. Add Parameter
   Adds a new parameter to a method declaration and updates all calls accordingly.
3. Add Validator (ASP.NET)
   Adds one or more selected Validators to the active input control.
4. Boolean to Enum 
   Converts a Boolean type to an enumeration, updating client code if necessary.
5. Break Apart Parameters
   Places each parameter on a separate line.
6. Case to Conditional
   Converts the switch (C# or C++) or Select (VB) statement to a series of nested if-else conditionals. This refactoring is the opposite of conditional to case.
7. Change Tag (ASP.NET)  ** New in 2.2 **
   Changes a <tag></tag> pair to a user-specified tag.
8. Collapse Accessors  ** New in 2.2 **
   Collapses simple getter or setter code onto a single line.
9. Combine Conditionals
   Combines two or more neighboring conditionals with identical bodies into a single conditional statement where each conditional expression is logically OR’d.
10. Compress to Lambda Expression ** Early Experience in 2.2 **
    Converts an anonymous method to an equivalent lambda expression.
11. Compress to Null Coalescing Operation (C#)  ** New in 2.2 **
    Converts a ternary expression to an equivalent null coalescing operation.
12. Compress to Ternary Expression
    Converts an if/else conditional with assignments in each branch into a ternary expression. This refactoring is the opposite of Expand Ternary Expression.
13. Conditional to Case
    Converts the nested if-else conditionals into a switch (C# & C++) or Select (VB) statement. This refactoring is the opposite of Case to Conditional.
14. Convert Color to HEX (ASP.NET)  ** New in 2.2 **
    Converts a color to the equivalent hexadecimal representation.
15. Convert Color to Named Color (ASP.NET)  ** New in 2.2 **
    Converts a color to the equivalent named color representation.
16. Convert Color To RGB (ASP.NET)  ** New in 2.2 **
    Converts a color to the equivalent RGB representation.
17. Convert to Auto-implemented Property (C#)  ** New in 2.2 **
    Removes the backing store and converts this property to an Auto-implemented Property.
18. Create Backing Store (C#)  ** New in 2.2 **
    Converts an auto-implemented property to a conventional property with a backing store.
19. Create Method Contract
    Creates a contract for the current method, verifying that parameters are valid.
20. Create Method Stub 
    Generates a method for the selected call, with appropriate parameters and return result.
21. Create Multi-variable Declaration
    Converts neighboring variable declarations of the same type into a single declaration. This refactoring is the opposite of Split Multi-variable Declaration.
22. Create Overload
    Creates an overloaded method similar to the one at the caret, with fewer parameters.
23. Create Setter Method
    Generates an internal set method for this field.
24. Create With Statement (VB)
    Creates a With statement for the selected instance within the selection.
25. Decompose Parameter  ** New in 2.2 **
    Replaces a single parameter with one or more new parameters, each standing in for a property access on the original parameter.
26. Encapsulate Downcast ** Early Experience in 2.2 **
    Moves typecasting performed by method calling code into the method itself.
27. Encapsulate Field
    Encapsulates a field into a read-write property and replaces all occurrences of this field throughout the class with the newly declared property.
28. Expand Accessors  ** New in 2.2 **
    Expands single-line getter or setter code onto multiple lines.
29. Expand Null Coalescing Operation (C#)  ** New in 2.2 **
    Converts a null coalescing operation to an equivalent ternary expression.
30. Expand Ternary Expression
    Converts a ternary expression into an if/else block. This refactoring is the opposite of Conditional to Ternary Expression.
31. Extract ContentPlaceHolder (ASP.NET)
    Moves the selected content from a .master page to a new .aspx file, placing it inside <asp:content> tags, and inserts a new <asp:contentplaceholder> tag at the extraction point inside the master page.
32. Extract ContentPlaceHolder (and create master page) (ASP.NET)
    Moves the content that is *outside* of the selection (in the active .aspx page) to a new master page, inserting a <asp:contentplaceholder> tag to reference the extracted content, and then wraps the selection in the aspx page with <asp:content> tags and adds a MasterPageFile attribute to link to the new master page.
33. Extract Function (outside of class) (C++)
    Moves selected code into a new function within the enclosing namespace.
34. Extract Interface
    Extracts an interface based on public members in a class.
35. Extract Method
    Creates a new method from the selected code block. The selection is replaced with appropriate calling code to invoke the newly-declared method.
36. Extract Property
    Creates a new property from the selected code block. The selection is replaced with appropriate code to reference the newly-declared property.
37. Extract String to Resource ** Early Experience in 2.2 **
    Extracts the string at the caret into a resource file.
38. Extract Style (Class) (ASP.NET)
    Converts an inline style to a named class style.
39. Extract Style (id) (ASP.NET)
    Converts an inline style to a named id style.
40. Extract UserControl  ** New in 2.2 **
    Creates a UserControl for the selected block including content and dependent code.
41. Flatten Conditional
    Unindents the if or else statement for a conditional. This will apply one of the following refactorings: Replace Nested Conditional with Guard Clause, Remove Redundant Else, or Reverse Conditional followed by Remove Redundant Else. Flatten conditional is also smart enough to recognize “if (E) return true; else return false;” and convert that to “return E;”.
42. ForEach to For
    Converts a ForEach loop to a for-loop.
43. For to ForEach
    Converts a for-loop to a ForEach loop, inferring type based on the object being iterated.
44. Inline Format Item
    Inlines an existing String.Format argument into the text string, replacing the format item (e.g., "{0}", "{1}", etc.) , and creating a concatenated string if necessary. This refactoring will remove the call to String.Format if this is the last remaining argument.
45. Inline Recent Assignment
    Replaces the identifier at the caret with its most-recent assignment.
46. Inline Result
    Replaces final assignments to the temporary variable with a statement that immediately returns the value.
47. Inline Temp
    Replaces all references to a local variable with its initial value.
48. Inline With Statement (VB)
    Inlines the object reference of a With statement into all dot-references.
49. Introduce Constant
    Declares a new constant, initialized to the value of the string or number at the caret.
50. Introduce Format Item
    Introduces a new format item to the string (e.g., "{0}", "{1}", etc.) which represents the selected text, and if necessary creates a new String.Format call to surround the string. The selected text is moved out to become an argument to String.Format.
51. Introduce ForEach Action  ** New in 2.2 **
    Replaces the contents of the List-iterating loop with an anonymous method, which is passed as the Action delegate to the List<T>.ForEach method.
52. Introduce Local
    Creates a new local variable initialized to the selected expression. Replaces the selection with the new variable.
53. Introduce Local (replace all)
    Creates a new local variable initialized with the selected expression. Replaces the expression everywhere it appears inside the code block with the new variable.
54. Introduce Parameter Object ** Early Experience in 2.2 **
    Consolidates selected parameters into single object.
55. Introduce Result Variable
    Introduces a variable to accept a value, replacing early-exit return statements with assignments to the variable and consolidating multiple method exit points into one.
56. Introduce Setter Guard Clause  ** New in 2.2 **
    Introduces a value changed check at the start of a property setter, exiting early if the value matches the backing store.
57. Line-up Arguments  ** New in 2.2 **
    Moves arguments to this method call up so they all exist on the same line.
58. Line-up Parameters  ** New in 2.2 **
    Moves parameter declarations up so they all exist on the same line.
59. Lock to Try/Finally
    Converts a lock() statement into a try/finally statement.
60. Method to Property
    Creates a property from the current method.
61. Move Declaration Near Reference
    Moves the declaration statement for this local variable near its first reference.
62. Move Initialization to Declaration
    Combines a local variable's declaration with its first initialization.
63. Move Method to Header (C++)
    Moves a method from a source file into the class declaration (in the header file).
64. Move Method to Source File (C++)
    Move a method's implementation to a source file and create a declaration in the header file.
65. Move Style Attributes to CSS (ASP.NET)
    Moves styling attributes from the active control to a new CSS class and applies the class to the control.
66. Move to Code-behind (ASP.NET)
    Moves code located in <script> tags to the code-behind file.
67. Move Type to File
    Creates a new file with the same name as the type at the caret, adds the file to the project, and then moves the type to that file, along with any leading comments, attributes, and XML doc comments. This refactoring is available when the caret is on a type declaration and the file contains two or more types.
68. Optimize Namespace References
    Removes unused namespace references (using/imports statements in VB and C#, and unused #include files in C++).
69. Promote to Parameter ** Early Experience in 2.2 **
    Removes all references to the local declaration or field from the method, replacing it with a parameter. Calling code is adjusted to pass in the promoted field or expression.
70. Property to Method
    ● For read-only properties:
        Converts the property into a function.
    ● For write-only properties:
        Converts the property into a method.
    ● For read-write properties:
        Converts the property into two methods, creating a new function for the getter, and a new method for the setter.
71. Reduce Visibility ** Early Experience in 2.2 **
    Reduces the visibility of a method or property to match the highest calling visibility.
72. Remove Block Delimiters (C# & C++)
    Removes unnecessary block delimiters.
73. Remove Empty Handler
    Removes an empty event handler along with the event handler assignment.
74. Remove Parameter 
    Removes an unused parameter from a method declaration and updates all calls accordingly.
75. Remove Private Setter  ** New in 2.2 **
    Removes a private property setter that simply assigns a value to a field without any side-effects.
76. Remove Redundant Conditional
    Removes one of the if or else blocks of an if/else statement where one of the blocks has a guaranteed exit.
77. Remove Setter Guard Clause  ** New in 2.2 **
    Removes the value-changed check at the start of a property setter.
78. Remove Tag (ASP.NET)  ** New in 2.2 **
    Removes a tag pair while preserving inner content.
79. Remove Type Qualifier
    Removes a type qualifier from a reference and ensures the proper namespace reference is added to the file if needed. There is also a “Remove all type qualifiers” variant of this refactoring that removes all type qualifiers in a file that match the type qualifier at the caret.
80. Rename File to Match Type
    Renames the file (and updates the project) so the file name matches the type name. This refactoring is available when a file contains one type declaration and the file name does not match the type name.
81. Rename
    Renames the active local variable, function, method, field, property, parameter, type, namespace, CSS style (ASP.NET) global variable (C++), or macro (C++) and updates all references to the modified element.
82. Reorder Parameters
    Reorders parameters in the current method, and then updates calling code to reflect the new order.
83. Replace Temp with Query
    Replaces each reference to this local variable with a call to an extracted method, which returns the initial value assigned to this local.
84. Replace with Alias 
    Replaces the type at the caret position with an existing type alias.
85. Replace with Constant
    Replaces the  expression with a reference to a constant with the same value.
86. Replace with Local
    Replaces the selected expression with a reference to a local variable which was previously assigned this value.
87. Reverse Conditional
    Inverts the logic in this conditional statement and swaps the If and Else blocks.
88. Safe Rename
    Safely renames non-private methods and properties by creating a duplicate member to preserve the old signature, calling the renamed member from the old member. The old member is hidden from Intellisense and marked "Obsolete". References to the old member will generate compiler warnings directing developers to the new renamed member.
89. Simplify Expression
    Resolves an expression to its simplest form.
90. Split Initialization from Declaration
    Breaks an initialized declaration for a local variable into a declaration and a separate initialization statement.
91. Split Multi-variable Declaration
    Splits a single-line multi-variable declarations into multiple lines, with a separate variable declaration on each line. This refactoring is the opposite of Create Multi-variable Declaration.
92. Split Temporary Variable
    Splits a local variable which has too many assignments, declaring a new local at the first new assignment following the first reference.
93. Split With Statement (VB)
    Splits a With statement into two, one nested inside the other.
94. Surround with Update Panel (ASP.NET)
    Surrounds a contiguous block of text in the source view with <atlas:UpdatePanel …> and <ContentTemplate> tags.
95. Use IsNullOrEmpty
    Converts one or more expressions that test a string for null or empty values into a single call to String.IsNullOrEmpty.
96. Use StringBuilder
    Replaces the selected string concatenation operations with corresponding method calls on a local StringBuilder instance.
97. Use String.Compare
    Replaces the equality expression with a call to String.Compare.
98. Use String.Format
    Converts a composed string expression into a single String.Format call.
99. Using to Try/Finally
    Converts a using statement to a try/finally block.
100. Widen Scope
     Moves a variable declaration up (out) in scope.