Change Signature refactoring

Using this refactoring, you can perform the following modifications:

warning

Changing a return type or parameter type, or removing parameters may cause errors, which you will need to correct manually.

note

If you changed type of some parameter or a return type to a type not available in the current namespace or to a type that can be resolved ambiguously, ReSharper will suggest specifying a full name for the type.

If you choose Delegate via overloading method in the Calls selector in the refactoring wizard, ReSharper leaves the existing declaration and calls it inside the new declaration, thus allowing you to leave the existing usages unchanged.

Note that this option is not available if you modify a function from an inheritance hierarchy.

For example, if you changed the name and reordered parameters of a method public string Foo(string s, int x), ReSharper will create the following code for you:

public string Foo(string s, int x)
{
    return String.Format("'{0}': {1} times", s, x);
}
public void Test()
{
    Foo("test", 10);
}

public string Bar(int x, string s)
{
    return String.Format("'{0}': {1} times", s, x);
}
public void Test()
{
    Bar(10, "test");
}

public string Foo(string s, int x)
{
    return String.Format("'{0}': {1} times", s, x);
}
public void Test()
{
    Foo("test", 10);
}

public string Foo(string s, int x)
{
    return Bar(x, s);
}
public string Bar(int x, string s)
{
    return String.Format("'{0}': {1} times", s, x);
}
public void Test()
{
    Foo("test", 10);
}

You can change function's signature by modifying its declaration right in the editor and then applying a quick-fix to invoke the solution-wide refactoring.

tip

To reorder parameters, place the caret at a parameter at function declaration or usage, press Ctrl+Alt+Shift and then use right and left arrows to change parameters' position. For more information, refer to Rearrange code elements.

For instance, if you reorder parameters in a method, a grey border appears around the method signature, notifying you that the refactoring is available. You can press AltEnter to find the refactoring in the action list:

After applying the quick-fix, a dialog shows your changes to the method signature:

You can click Next to apply the change solution-wide.

You can also apply the Change Signature refactoring when you add one new argument in any of the function's calls. In this case, ReSharper detects the incorrect call, highlights it and suggests the corresponding quick-fix:

This quick-fix will invoke the refactoring and update the declaration of the function and all its usages solution-wide. If necessary, ReSharper will display a call diagram to pick values for each specific call individually

tip

There are other refactorings that you can apply in-place.

If you are changing a function signature so that a new parameter is added, ReSharper provides several ways of updating function calls. Besides using 'null' or a constant value for all calls, you can update each individual call using visual representation of calls.

If you perform the refactoring with the wizard, select Resolve with call tree on the last page of the wizard and click Next. If you perform refactoring from a quick-fix on an updated function call, the tool window with all calls of the modified function opens automatically:

In this view, you can check the affected calls and locate them in the editor with a click. For each call, select the desired way of acquiring values for the newly added parameter, or select User edit to edit the call manually.

This feature is supported in the following languages and technologies:

The instructions and examples given here address the use of the feature in C#. For more information about other languages, refer to corresponding topics in the Languages and frameworks section.