Skip to main content

How to Resolve Error "The inherited members 'Member1' and 'Member2' have the same signature in type 'DerivedClass', so they cannot be overridden" in C#

The Compiler Error CS0462 is a Generic Substitution Conflict error. The message reads: "The inherited members 'Member1' and 'Member2' have the same signature in type 'DerivedClass', so they cannot be overridden".

This error occurs when a generic base class defines two methods that typically have different signatures (e.g., one takes an int, the other takes a T). However, when a derived class inherits from that base class and specifies the generic type argument (e.g., Base<int>), the generic T is replaced by int. This results in two methods having the exact same signature. Since the signatures are identical in the derived scope, the compiler cannot determine which base method you intend to override.

This guide explains how generic substitution causes this collision and how to redesign your class to avoid it.

Understanding Generic Signature Collisions​

In a generic class definition, void Method(int x) and void Method(T x) are distinct because T is unknown.

However, when you define a class that inherits from Base<int>, the compiler effectively performs a "Find and Replace":

  1. void Method(int x) remains void Method(int x).
  2. void Method(T x) becomes void Method(int x).

Now the derived class has two virtual methods with the signature Method(int). If you try to override this method, the compiler faces an impossible choice: it does not know which of the two base slots in the Virtual Method Table (vtable) you want to replace.

Scenario: The Colliding Overrides​

This error happens when you create a specific implementation of a generic base class where the specific type matches an existing overload.

Example of error:

// The Generic Base Class
public class Repository<T>
{
    // Signature A: Accepts an Integer
    public virtual void Save(int id) 
    {
        System.Console.WriteLine("Saving by ID (int)");
    }

    // Signature B: Accepts a Generic T
    public virtual void Save(T item) 
    {
        System.Console.WriteLine("Saving by Item (T)");
    }
}

// The Derived Class
// We specify T = int. Now both Save methods look like 'void Save(int)'.
public class IntRepository : Repository<int>
{
    // ⛔️ Error CS0462: The inherited members 'Repository<int>.Save(int)' 
    // and 'Repository<int>.Save(int)' have the same signature in type 
    // 'IntRepository', so they cannot be overridden.
    public override void Save(int value)
    {
        System.Console.WriteLine("Overriding...");
    }
}
note

Even though the methods were distinct in the parent, they act as duplicates in the child context. You cannot override ambiguous members.

Solution 1: Rename the Generic Method​

The most robust solution is to ensure the method names are distinct in the base class. This avoids any possibility of collision, regardless of what type T becomes.

Solution: rename one of the methods to be more descriptive.

public class Repository<T>
{
    // Renamed to avoid potential conflict
    public virtual void SaveId(int id) 
    {
        System.Console.WriteLine("Saving by ID");
    }

    // Kept as general Save
    public virtual void Save(T item) 
    {
        System.Console.WriteLine("Saving Item");
    }
}

public class IntRepository : Repository<int>
{
    // ✅ Correct: No ambiguity. 
    // This overrides 'Save(T item)' which is now 'Save(int item)'.
    public override void Save(int item)
    {
        System.Console.WriteLine($"Saving int item: {item}");
    }

    // This overrides 'SaveId(int id)'.
    public override void SaveId(int id)
    {
        System.Console.WriteLine($"Saving ID: {id}");
    }
}

Solution 2: Use a Wrapper Type​

If you cannot rename the methods in the base class (e.g., it is part of a library or a strict API contract), you must ensure that T is never int. You can achieve this by wrapping the integer in a struct or class.

This ensures the signatures remain distinct: Save(int) vs Save(IntWrapper).

Solution:

// A simple wrapper for the integer
public struct IntWrapper
{
    public int Value;
    public IntWrapper(int v) => Value = v;
}

// Now T is 'IntWrapper', not 'int'
public class WrapperRepository : Repository<IntWrapper>
{
    // ✅ Correct: Overrides Save(T), which is Save(IntWrapper)
    public override void Save(IntWrapper item)
    {
        System.Console.WriteLine($"Saving wrapper: {item.Value}");
    }

    // ✅ Correct: Overrides Save(int), which is distinct
    public override void Save(int id)
    {
        System.Console.WriteLine($"Saving ID: {id}");
    }
}

Conclusion​

CS0462 highlights a design flaw where generic polymorphism collapses into ambiguity.

  1. Analyze the Hierarchy: Look at the base class. Does it have overloads that mix concrete types (like int) with generic types (T)?
  2. Check the Inheritance: Did you inherit with Base<int> (or whatever concrete type was used in the overload)?
  3. Refactor: The best fix is always to rename the base methods to be unique (e.g., SaveId vs SaveItem) so they never collide.

Table of Contents