Pages

Topics

Tools

↑↓navigate↵openescclose
All guides

C# new vs override: Choosing Between Method Hiding and Overriding

Understand the difference between the C# new and override keywords, when to use each, and how they affect polymorphism and runtime behavior.

~5 min readC#
#C##inheritance#method hiding#override
Diagram comparing C# new and override behavior in inheritance, showing method resolution through base class references.

In C#, the new and override keywords both allow a derived class to declare a method with the same signature as a base class method. The difference is not syntactic preference; it changes how the method is dispatched at runtime and how it behaves when accessed through a base class reference. Understanding this distinction is essential for designing inheritance hierarchies that behave predictably.

What new and override Actually Do

The override keyword is used to replace a method declared in a base class. The base method must be virtual, which usually means it is declared with virtual or abstract, or it is itself an override of a virtual method. The derived method becomes part of the same virtual method slot. When you call the method through a base class reference, the runtime looks up the most derived override and executes it. This is the foundation of polymorphism.

The new keyword, on the other hand, hides a method that exists in the base class. The base method does not need to be virtual. The derived method is a completely separate method that happens to have the same name and signature. If you call the method through a base class reference, the base class method runs, not the derived one. The new keyword marks the hiding as intentional and suppresses the compiler warning that would otherwise appear when you hide a member without an explicit keyword.

How Method Resolution Works with Base Class References

Consider a simple hierarchy:

csharp
public class Base { public virtual void Show() { Console.WriteLine("Base.Show"); } } public class DerivedOverride : Base { public override void Show() { Console.WriteLine("DerivedOverride.Show"); } } public class DerivedNew : Base { public new void Show() { Console.WriteLine("DerivedNew.Show"); } }

Now create instances and call Show through a Base reference:

csharp
Base b1 = new DerivedOverride(); b1.Show(); // Output: DerivedOverride.Show Base b2 = new DerivedNew(); b2.Show(); // Output: Base.Show

When the method is override, the runtime uses the actual type of the object (DerivedOverride) to resolve the call. When the method is new, the compiler uses the static type of the reference (Base) to resolve the call. This behavior is consistent even if you cast the reference to Base explicitly.

When to Use override

Use override when you want the derived class to provide a different implementation of a base method, and you want that implementation to be used regardless of the reference type. This is the correct choice for methods that represent polymorphic behavior, such as ToString(), Equals(), or any method that should vary based on the actual object type.

For example, a Shape base class might have a virtual Area() method. Each derived shape overrides it to compute its own area. When you iterate over a collection of Shape references, calling Area() on each element invokes the correct implementation because of overriding.

When to Use new

The new keyword is appropriate when you intentionally want to hide a base method and do not want polymorphic dispatch. This is rare in well-designed hierarchies, but it can be useful when the base class is not under your control and you want to provide a method with the same name that behaves differently for your derived class—but only when the caller knows the derived type.

A common scenario is when you inherit from a third-party class and need to add a method that happens to have the same name as an existing non-virtual method. Using new allows you to define your own method without altering the base class behavior. However, this can lead to subtle bugs because calls through base references still hit the base implementation.

Common Pitfalls and Misunderstandings

One frequent mistake is assuming that new and override are interchangeable when the base method is virtual. If you use new on a virtual method, you break the existing override chain. The original virtual method is still represented by the base virtual slot, while the new method is a separate declaration. Further derived classes can override only a virtual method; a non-virtual new method is not an override target. If the new method is declared virtual, it starts a separate override chain that is not connected to the original one. This can cause confusing behavior.

Another issue is the compiler warning CS0108, which appears when you hide a base member without new. The warning is a signal that you might be doing something unintended. If you see it, decide whether you actually want to hide the method or whether you should use override instead.

Consider this example:

csharp
public class Base { public void Log() { Console.WriteLine("Base.Log"); } } public class Derived : Base { public void Log() { Console.WriteLine("Derived.Log"); } // Warning CS0108 }

Adding new suppresses the warning but does not change the runtime behavior. The method is still hidden, not overridden.

Practical Example: Extending a Base Class

Suppose you have a base class that provides a Save() method, and you want to add extra behavior in a derived class without breaking existing callers that use base references.

csharp
public class Repository { public void Save() { // Save to database Console.WriteLine("Saving to database"); } } public class LoggingRepository : Repository { public new void Save() { Console.WriteLine("Logging before save"); base.Save(); Console.WriteLine("Logging after save"); } }

If you call Save() on a LoggingRepository variable, the new method runs. But if you assign it to a Repository variable, the base Save() runs, and the logging is skipped. This is often not what developers expect. If you need polymorphic behavior, the base method should be virtual and the derived method should use override.

Maintainability and Compatibility Considerations

The choice between new and override has long-term consequences. Overriding a virtual method preserves polymorphism and makes your derived class work correctly in generic code that operates on base types. Hiding a method with new creates a fragile situation: if the base class later adds a virtual keyword to that method, your new method will not automatically become an override, and the behavior may change unexpectedly.

When you design a base class, marking a method as virtual is a commitment that derived classes can override it. If you do not want that flexibility, leave it non-virtual. When you write a derived class, prefer override whenever the base method is virtual and you want to replace its behavior. Use new only when you are certain that the method should be hidden and that callers will always use the derived type.

In a codebase, excessive use of new can make inheritance hierarchies harder to reason about. A developer reading a call site that uses a base reference cannot know whether the actual implementation is the base method or a hidden one, because the compiler resolves it based on the reference type. This hidden dependency often leads to bugs that are difficult to trace. Overriding, by contrast, makes the runtime behavior explicit and predictable.

Try matching browser tools

All tools

Small utilities that fit C# work — they run entirely in this browser tab, so nothing you paste leaves your device.

All C# guides

More in C#

All C# guides

The guides filed next to this one in C#, in library order.