The documentation for interface implementation stated that implementing members "must be public" without clarifying this applies only to implicit implementation. Additionally, it incorrectly suggested that internal interfaces always require explicit implementation, when in fact they can use implicit implementation as long as all types in the signature are publicly accessible.

Changes Made

Updated the core statement on line 29 to clarify that the public requirement applies specifically to implicit implementation:

To implement an interface member using implicit implementation, the corresponding member of the implementing class must be public, non-static, and have the same name and signature as the interface member. However, when an interface has internal accessibility or uses internal types in its signature, you can use explicit interface implementation instead, which doesn't require the implementing member to be public.

Revised "Working with internal interfaces" section to accurately explain:

• Internal interfaces can typically be implemented using implicit implementation with public members, as long as all types in the interface signature are publicly accessible
• Explicit interface implementation is only required when internal types are used in member signatures
• Added comprehensive example demonstrating both scenarios

Enhanced code example showing:

// Internal interface that CAN use implicit implementation
internal interface ILoggable
{
    void Log(string message); // string is public, so implicit implementation works
}

// Internal interface that REQUIRES explicit implementation  
internal interface IConfigurable
{
    void Configure(InternalConfiguration config); // Internal type prevents implicit implementation
}

public class ServiceImplementation : ILoggable, IConfigurable
{
    // Implicit implementation works for ILoggable
    public void Log(string message) { ... }
    
    // Explicit implementation required for IConfigurable
    void IConfigurable.Configure(InternalConfiguration config) { ... }
}

This provides accurate guidance on when each implementation approach is needed and addresses the confusion around internal interfaces and accessibility requirements.

Fixes #44194.

💡 You can make Copilot smarter by setting up custom instructions, customizing its development environment and configuring Model Context Protocol (MCP) servers. Learn more Copilot coding agent tips in the docs.

Internal previews