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.

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:
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:
Base b1 = new DerivedOverride();
b1.Show(); // Output: DerivedOverride.Show
Base b2 = new DerivedNew();
b2.Show(); // Output: Base.ShowWhen 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:
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.
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 toolsSmall utilities that fit C# work — they run entirely in this browser tab, so nothing you paste leaves your device.
Related C# guides
All C# guidesC# Dispose vs Destructor: Key Differences Explained
c# dispose vs destructor: Understand the difference between Dispose and destructors in C#, when each runs, and how to manage unmanaged resources correctly.
C# Variable Declaration: Syntax and Practical Usage
Learn how to declare variables in C# with explicit types, var, and nullable annotations, and understand how defaults, scope, and readability affect your choices.
C# Primary Constructors for Classes: Syntax and Usage
Learn how to use C# primary constructors for classes: syntax, initialization, dependency injection, and limitations with practical examples.
C# IComparer: Custom Sorting with IComparer<T>
Learn how to implement IComparer<T> in C# to define custom sort order for arrays and lists, handle nulls, and avoid common performance pitfalls.
More in C#
All C# guidesThe guides filed next to this one in C#, in library order.