Rename

Rename is a refactoring feature in the Visual Studio integrated development environment (IDE) that provides an easy way to rename identifiers for code symbols such as fields, local variables, methods, namespaces, properties, and types. Rename can be used to change the names in comments and in strings and to change the declarations and calls of an identifier.

Rename refactoring is available from the following Visual Studio features:

Rename Operations

When you execute Rename, the refactoring engine performs a rename operation specific for each code symbol, described in the following table.

Remarks

Renaming Implemented or Overridden Members

When you Rename a member that either implements/overrides or is implemented/overridden by members in other types, Visual Studio displays a dialog box that says the rename operation will cause cascading updates. If you click Continue, the refactoring engine recursively finds and renames all members in base and derived types that have implements/overrides relationship with the member being renamed.

The following code example contains members with implements/overrides relationship.

interface IBase
{
    void Method();
}
public class Base
{
    public void Method()
    { }
    public virtual void Method(int i)
    { }
}
public class Derived : Base, IBase
{
    public new void Method()
    { }
    public override void Method(int i)
    { }
}
public class C : IBase
{
    public void Method()
    { }
}

In the previous example, renaming C.Method() also renames Ibase.Method() because C.Method() implements Ibase.Method(). Next, the refactor engine recursively sees that Ibase.Method() is implemented by Derived.Method() and renames Derived.Method(). The refactor engine does not rename Base.Method(), because Derived.Method() does not override Base.Method(). The refactoring engine stops here unless you have Rename overloads checked in the Rename dialog box.

If Rename overloads is checked, the refactor engine renames Derived.Method(int i) because it overloads Derived.Method(), Base.Method(int i) because it is overridden by Derived.Method(int i), and Base.Method() because it is an overload of Base.Method(int i).

Renaming Properties of Anonymous Types

When you rename a property in anonymous types, the rename operation will propagate to properties in other anonymous types that have the same properties. The following examples illustrate this behavior.

var a = new { ID = 1};
var b = new { ID = 2};

In the preceding code, renaming ID will change ID in both statements because they have the same underlying anonymous type.

var companyIDs =
    from c in companylist
    select new { ID = c.ID, Name = c.Name};

var orderIDs =
    from o in orderlist
    select new { ID = o.ID, Item = o.Name};

In the preceding code, renaming ID will only rename one instance of ID because companyIDs and orderIDs do not have the same properties.

See Also

Tasks

How to: Rename Identifiers

Concepts

Refactoring

Reference

Anonymous Types (C# Programming Guide)

Other Resources

Source Control for Visual Studio