JetBrains Home | ReSharper Home | ReSharper Docs and Demos | Download ReSharper

This help describes an outdated version of ReSharper. Click here for help on the latest version of the product.

The Change Signature refactoring combines several different modifications that can be made to signatures of methods, constructors, properties, and indexers.

The refactoring perform the following modifications:

• Methods
  • Change name and return type
  • Change parameters names and types
  • Add and remove parameters
  • Reorder parameters
• Properties
  • Change name and return type
• Constructors
  • Change parameters names and types
  • Add and remove parameters
  • Reorder parameters
• Indexers
  • Change name
  • Change parameters names and types
  • Add and remove parameters
  • Reorder parameters

Along with changing the signature itself, ReSharper searches for all usages of the method, property, constructor, or indexer and alters all calls, implementations and overridings that can be safely modified to reflect the change.

Warning    Changing a return type or a parameter type may cause errors which you will need to correct manually in the code.

The refactoring is also applicable to type constructors and indexers (only you cannot change their names or return types).

To change a signature

• 1. Select the method, property, constructor, or indexer either in Class View or Object Browser, or position the caret at its name in the editor.
  2. Do one of the following:
     • On the main menu, click ReSharper | Refactor | Change Signature.
     • Right-click the symbol, and on the shortcut menu click Refactor | Change Signature.
     • Press Ctrl + F6.
     • Press Ctrl + Shift + R, and then select Change Signature.

     Note    If you select a method that overrides or implements some other methods, you will see a question box asking whether you want to modify the base methods. Click Yes if you want to change the base methods. Click No if you want to change only the selected method without modifying the base ones.

     The Change Signature dialog box opens.

     

  3. In the Name and Return type text boxes, specify new values if necessary.
  4. In the Parameters area, you can perform the following operations:
     • Change types, names, modifiers and default values of existing parameters.
     • Add new parameters (using the Add button).

       If you add a new parameter, you need to specify its type, name, and default value that will be used to update existing method calls.

     • Remove existing parameters (using the Remove button).
     • Reorder parameters (using the Move Up and Move Down buttons).
  5. In the Calls area, specify whether you need to change existing method calls:
     • If you want to modify existing method calls, select the Modify option.

       For example, if you add to the method a new parameter with the default value "1", refactoring is applied as shown in the table below.

       Before	After
       public class SampleClass { public void Foo(int a) { ... } public void CallFoo() { Foo(0); } }	public class SampleClass { public void Foo(int a, int b) { ... } public void CallFoo() { Foo(0,1); } }

     • If you do not want to change the existing method calls, you can override the method and delegate calls. In this case, select the Delegate via overloading method option.

       For example, if you add to the method a new parameter with the default value "1" to the method, refactoring is applied as follows.

       Before	After
       public class SampleClass { public void Foo(int a) { ... } public void CallFoo() { Foo(0); } }	public class SampleClass { public void Foo(int a) { Foo(a, 1); } public void Foo(int a, int b) { ... } public void CallFoo() { Foo(0); } }

  6. Check the result in the Signature preview text box, and click Continue.

     Note     If you changed some parameter type or a return type to a type not used in the current namespace or to a type that can be resolved ambiguously, ReSharper suggests you to select the type and its full name in the devoted dialog box.

     

• If no conflicts are found, the changes are applied immediately.

  See Also

  Refactoring Code