Skip to main content

How to Resolve Error "CS0526: Interfaces cannot contain instance constructors" in C#

The Compiler Error CS0526 is a design restriction error. The message reads: "Interfaces cannot contain instance constructors".

In C#, an Interface is a pure contract that defines a set of members (methods, properties, events) that a class must implement. Interfaces are never instantiated directly (you cannot write new IMyInterface()). Because they cannot be created as objects themselves, they have no use for a constructor, which exists solely to initialize an object. The responsibility of initialization belongs entirely to the concrete Class or Struct that implements the interface.

This guide explains why this restriction exists and how to achieve your initialization goals using alternative patterns.

Understanding Interface Instantiation​

Constructors are special methods called when an instance is created using the new keyword.

  • Classes: Can be instantiated (new MyClass()). They need constructors to set up their state.
  • Interfaces: Are abstract definitions. They contain no state (fields) and cannot be instantiated. Therefore, defining a constructor inside one is logically impossible because there is no scenario where the runtime would call it.

Scenario 1: Defining Initialization Logic in an Interface​

This error often occurs when a developer treats an interface like an Abstract Class, attempting to define "setup" code that every implementation should run.

Example of error​

Attempting to write a constructor inside the interface block.

public interface IService
{
    // ⛔️ Error CS0526: Interfaces cannot contain instance constructors.
    // The compiler forbids this because you can never 'new' an IService.
    public IService()
    {
        System.Console.WriteLine("Service Initialized");
    }

    void DoWork();
}

Solution: Use an Abstract Class​

If you need to share initialization logic (code that runs when the object is created), you must use an Abstract Class instead of an interface. Abstract classes can hold state and constructors.

// ✅ Correct: Change 'interface' to 'abstract class'
public abstract class BaseService
{
    // Constructors are valid here
    protected BaseService()
    {
        System.Console.WriteLine("Service Initialized");
    }

    public abstract void DoWork();
}

public class EmailService : BaseService
{
    public override void DoWork() { /* ... */ }
}

Scenario 2: Trying to Enforce Constructor Signatures​

Sometimes developers try to define a constructor in an interface not to write code, but to enforce that every implementing class must have a specific constructor (e.g., "All Plugins must accept a configuration string").

Example of error​

Trying to define a constructor signature in the interface to force compliance.

public interface IPlugin
{
    // ⛔️ Error CS0526: You cannot enforce constructor signatures via interfaces.
    IPlugin(string config); 
    
    void Execute();
}

Solution: The Abstract Factory Pattern​

C# interfaces cannot enforce constructor signatures because constructors are not part of the instance's public interface—they are part of the creation process.

To solve this, define a separate interface for the Factory (the creator) that creates your object.

// 1. The main interface (what the object DOES)
public interface IPlugin
{
    void Execute();
}

// 2. The factory interface (how to CREATE the object)
public interface IPluginFactory
{
    // ✅ Correct: This method enforces that a string must be passed
    // to get an IPlugin instance.
    IPlugin Create(string config);
}

// Implementation
public class AudioPlugin : IPlugin 
{ 
    public AudioPlugin(string config) { /* init */ }
    public void Execute() { }
}

public class AudioPluginFactory : IPluginFactory
{
    public IPlugin Create(string config)
    {
        return new AudioPlugin(config);
    }
}

Conclusion​

CS0526 reminds you that interfaces define behavior, not creation.

  1. Remove the Constructor: Simply delete the constructor from the interface file.
  2. Move Logic: Place the initialization logic in the Implementing Class.
  3. Change Type: If you need shared initialization logic, switch from an interface to an abstract class.

Table of Contents