Here is a page to discuss what is a code ReFactoring operation and what is ReWorking instead. It is hoped that this will eventually be a fairly complete list of refactoring operations.
As a start:
Simple refactoring operations:
- change the name of a variable
- change the name of a class or structure definition
- change the name of a method or function
- change the type of a variable or class member
- change the name of a parameter in a function/method definition
- change a literal into a variable (or do the reverse).
- increase type strength of a variable or member (or do the reverse).
More involved refactoring operations:
- convert an inner class to a top-level class definition
- convert the users of class into using a class that inherits the first class.
- change to using a different CollectionStructure.
- take an inline chunk of code and turn it into a method or function (or do the reverse, take a method or function and pull its contents in line).
- convert a group of simple hashes/dictionaries with the same keys into a single hash/dictionary with a new class containing members from the old collection structures (or do the reverse, convert a dictionary/hash/list of objects into one collection structure for each member in the object's class, and stop using the class).
- convert a StaticClass into a DynamicClass (or do the reverse, convert a dynamic class into a static class).
- convert a class member into an instance member (or do the reverse, convert an instance member into a class member).
- change an interface into an abstract class (or do the reverse).
- change a for loop into a recursive procedure (or do the reverse).
Database centric refactoring operations:
- move an InlineSqlStatement into a StoredProcedure (or do the reverse).
- move a StoredProcedure into a SqlFunction (or do the reverse).
- change a SQL filter into an application language implemented filter (or do the reverse).
DataOriented -> InformationOriented refactoring sequences: