Why cannot we specify access modifiers inside an interface in C#?

Interface members in C# traditionally cannot have access modifiers because interfaces define a contract that implementing classes must follow. The purpose of an interface is to specify what methods or properties a class must provide to the outside world, making all interface members implicitly public.

Prior to C# 8.0, adding any access modifier to interface members would result in a compiler error. However, C# 8.0 introduced default interface methods, which allow access modifiers for specific scenarios involving method implementations within interfaces.

Why Interface Members Are Public by Default

Interfaces serve as contracts that define what functionality a class must expose. Since the primary purpose is external accessibility, all interface members are implicitly public −

interface IExample {
    void Method();        // implicitly public
    int Property { get; } // implicitly public
}

C# 7.0 and Earlier Behavior

In versions prior to C# 8.0, adding any access modifier to interface members generates a compiler error −

using System;

interface IInterface {
    void Save(); // Valid - implicitly public
}

class MyClass : IInterface {
    public void Save() {
        Console.WriteLine("Save method implemented");
    }
}

class Program {
    public static void Main() {
        IInterface obj = new MyClass();
        obj.Save();
    }
}

The output of the above code is −

Save method implemented

However, adding explicit access modifiers would cause compilation errors in C# 7.0 and earlier −

interface IInterface {
    public void Save();    // Compiler error in C# 7.0
    private void Helper(); // Compiler error in C# 7.0
}

C# 8.0 Changes with Default Interface Methods

C# 8.0 introduced default interface methods, allowing interfaces to contain method implementations. With this feature, access modifiers became necessary to control visibility of these implementations −

using System;

interface IAdvancedInterface {
    void PublicMethod(); // Still implicitly public
    
    // Default implementation with private helper
    void ProcessData() {
        HelperMethod();
        Console.WriteLine("Processing data...");
    }
    
    private void HelperMethod() {
        Console.WriteLine("Helper method called");
    }
}

class Implementation : IAdvancedInterface {
    public void PublicMethod() {
        Console.WriteLine("Public method implemented");
    }
}

class Program {
    public static void Main() {
        IAdvancedInterface obj = new Implementation();
        obj.PublicMethod();
        obj.ProcessData(); // Uses default implementation
    }
}

The output of the above code is −

Public method implemented
Helper method called
Processing data...

Comparison of Interface Evolution

Key Rules for Interface Access Modifiers

• Abstract interface members are always implicitly public and cannot have explicit access modifiers.

• Default interface methods (C# 8.0+) can have access modifiers to control their visibility.

• Private members in interfaces are only accessible within the interface itself.

• Protected members in interfaces are accessible to implementing classes.

Conclusion

Interface members traditionally cannot have access modifiers because interfaces define public contracts. C# 8.0 introduced default interface methods, allowing access modifiers for implemented methods while maintaining the rule that abstract interface members remain implicitly public. This evolution provides more flexibility while preserving the core contract-based nature of interfaces.