Skip to main content

How to Resolve Error "CS0111: Type 'type' already defines a member called 'name' with the same parameter types" in C#

The Compiler Error CS0111 is a Method Overloading error. The message reads: "Type 'MyClass' already defines a member called 'MethodName' with the same parameter types".

In C#, you can have multiple methods with the same name (Overloading), provided they have unique Signatures. A method's signature consists of its Name and its Parameter Types (and their order).

Crucially, the Return Type and the Parameter Names are not part of the signature. If you define two methods where the only difference is the return type or the names of the variables, the compiler sees them as identical duplicates and raises CS0111.

Understanding Method Signatures​

The compiler distinguishes methods based on:

  1. The Method Name.
  2. The number of parameters.
  3. The data types of parameters (in specific order).
  4. Parameter modifiers (ref, out, in).

The compiler ignores:

  1. The Return Type.
  2. The names you give to the parameters.

Scenario 1: Differing Only by Return Type​

This is the most common mistake. Developers often try to overload a method to return different data types while keeping the input identical.

Example of error​

public class DataFetcher
{
    // Method 1: Takes nothing, returns int
    public int GetData()
    {
        return 100;
    }

    // ⛔️ Error CS0111: Type 'DataFetcher' already defines a member called 'GetData' 
    // with the same parameter types.
    // The compiler ignores the 'string' vs 'int' return type. 
    // It sees 'GetData()' defined twice.
    public string GetData()
    {
        return "100";
    }
}

Solution: Rename the Methods​

Since C# cannot overload based on return type, you must give the methods distinct names.

public class DataFetcher
{
    // ✅ Correct: Unique names resolve the conflict
    public int GetIntData()
    {
        return 100;
    }

    public string GetStringData()
    {
        return "100";
    }
}

Scenario 2: Differing Only by Parameter Names​

Changing the variable name inside the parentheses does not make the method unique. (int x) and (int y) are identical to the compiler because they are both (int).

Example of error​

public class Calculator
{
    public void Add(int x) { }

    // ⛔️ Error CS0111: The compiler sees 'Add(int)'. 
    // Changing 'x' to 'y' does not change the signature.
    public void Add(int y) { }
}

Solution: Change Parameter Types​

To overload validly, the types or the number of parameters must differ.

public class Calculator
{
    // Signature: Add(int)
    public void Add(int x) { }

    // ✅ Correct: Signature is Add(double), which is unique.
    public void Add(double y) { }
    
    // ✅ Correct: Signature is Add(int, int), which is unique.
    public void Add(int x, int y) { }
}

Scenario 3: Partial Classes Duplication​

When working with Partial Classes (common in generated code like WPF, WinForms, or ASP.NET), the class definition is split across multiple files. You might accidentally define a method in your code-behind file (MyClass.cs) that already exists in the generated file (MyClass.Designer.cs).

Example of error​

File 1 (Auto-Generated):

partial class UserControl
{
    public void InitializeComponent() { /* ... */ }
}

File 2 (Your Code):

partial class UserControl
{
    // ⛔️ Error CS0111: InitializeComponent is already defined in File 1.
    public void InitializeComponent() { }
}

Solution​

Check your other files. If the method is auto-generated, you usually shouldn't declare it again. If you are trying to run code during initialization, look for a constructor or a partial method hook (like OnCreated) instead.

Conclusion​

CS0111 enforces the rules of Polymorphism.

  1. Check Return Types: You cannot have int Do() and string Do(). Rename one of them.
  2. Check Parameter Types: You cannot have void Do(int a) and void Do(int b). Change the type of the parameter or add more parameters.
  3. Check Partial Files: Ensure you aren't redefining a method that a code generator has already created for you.

Table of Contents