C#接口中各类访问修饰符的使用及相关技术疑问

首先明确：你提供的代码能正常编译完全符合C# 8规范——C# 8允许对带访问修饰符的接口成员进行隐式实现，只要实现类的成员访问级别不低于接口成员的要求（比如你用public实现所有接口成员，完全满足各类修饰符的可见性要求）。此前的资料表述可能存在偏差。

疑问1：既然接口核心是公开契约，为何要添加访问修饰符？ #

接口的角色在C# 8中得到了扩展：它不再仅仅是对外暴露的公开契约，还可以作为代码复用载体、程序集内部契约、继承层次专属契约的定义工具。访问修饰符就是为了适配这些新场景，让接口设计更灵活：

下面针对每个修饰符给出具体场景示例：

1. public：传统公开契约 #

这是C# 8之前接口成员的默认行为，用于定义对外暴露的核心能力，所有实现类必须提供公开的实现，保证外部代码能通过接口调用该成员。

public interface IPaymentProcessor {
    public void ProcessPayment(decimal amount); // 对外公开的支付处理契约
}
public class AlipayProcessor : IPaymentProcessor {
    public void ProcessPayment(decimal amount) {
        Console.WriteLine($"支付宝支付：{amount:C}");
    }
}
// 外部代码可直接通过IPaymentProcessor调用ProcessPayment

2. internal：程序集内部专属契约 #

接口成员仅对同一程序集内的代码可见，实现类的对应成员也只能在程序集内被访问，用于定义程序集内部的协作规则，不对外暴露细节。

internal interface IDataCache {
    internal void CacheData(string key, object value); // 仅程序集内可见的缓存操作
}
public class RedisCache : IDataCache {
    public void CacheData(string key, object value) {
        Console.WriteLine($"缓存数据：{key}");
    }
}
// 外部程序集无法调用RedisCache.CacheData，也无法通过IDataCache引用该方法

3. protected：继承层次专属契约 #

接口成员只能被实现类的派生类访问，用于定义只有子类需要知晓的内部逻辑，避免对外暴露不必要的细节。

public interface IComponent {
    protected void Initialize(); // 仅派生类可见的初始化方法
}
public class BaseComponent : IComponent {
    protected void Initialize() {
        Console.WriteLine("组件初始化");
    }
}
public class AdvancedComponent : BaseComponent {
    public void Start() {
        Initialize(); // 派生类可直接调用初始化逻辑
    }
}
// 外部代码无法直接调用BaseComponent.Initialize

4. protected internal：混合访问契约 #

结合protected和internal的特性：实现类的派生类（无论是否在同一程序集）、同一程序集内的任何代码都能访问该成员，适配跨程序集继承但又需要程序集内调用的场景。

public interface IHybridService {
    protected internal void HybridOperation();
}
public class HybridServiceImpl : IHybridService {
    public void HybridOperation() {
        Console.WriteLine("混合访问操作");
    }
}
// 同一程序集内的任意代码可调用该方法，其他程序集的派生类也能调用

5. private protected：同程序集继承专属契约 #

仅允许同一程序集内的派生类访问，是限制最严格的修饰符，用于保护程序集内部继承层次的核心逻辑，避免外部程序集的子类篡改。

public interface IRestrictedContract {
    private protected void CoreLogic();
}
public class BaseService : IRestrictedContract {
    private protected void CoreLogic() {
        Console.WriteLine("程序集内部核心逻辑");
    }
}
// 同一程序集内的子类可调用，外部程序集的子类无法访问
public class DerivedService : BaseService {
    public void Execute() {
        CoreLogic();
    }
}

疑问2：为何要新增接口内直接实现成员的能力？ #

这个特性叫做默认接口方法（Default Interface Methods），核心解决三个痛点：

1. 接口升级的兼容性问题 #

给现有接口新增方法时，不用强制所有实现类都修改代码——接口可以提供默认实现，实现类可选择重写或直接使用默认逻辑，避免大规模修改现有代码。

public interface IUserManager {
    void CreateUser(string username);
    // 新增方法，带默认实现，现有实现类无需修改
    public void DeleteUser(string username) {
        Console.WriteLine($"默认删除用户：{username}");
    }
}
public class DbUserManager : IUserManager {
    public void CreateUser(string username) {
        Console.WriteLine($"数据库创建用户：{username}");
    }
    // 无需实现DeleteUser，直接使用接口默认逻辑
}

2. 实现跨类的代码复用 #

接口可以提供通用逻辑的实现，让所有实现类共享，不用每个类都重复编写相同代码。

public interface ICollectionHelper {
    int Count { get; }
    // 通用的判断空集合逻辑，所有实现类共享
    public bool IsEmpty() => Count == 0;
}
public class MyCustomList : ICollectionHelper {
    public int Count { get; private set; } = 0;
    // 无需自己编写IsEmpty方法，直接复用接口的默认实现
}

3. 模拟多继承的代码复用 #

C#不支持类的多继承，但通过默认接口方法，类可以同时“继承”多个接口的实现逻辑，实现多维度的代码复用。

public interface ILoggable {
    public void Log(string message) => Console.WriteLine($"日志：{message}");
}
public interface IReportable {
    public void GenerateReport() => Console.WriteLine("生成默认报告");
}
public class BusinessService : ILoggable, IReportable {
    // 自动获得两个接口的默认实现，无需自己编写
}

内容的提问来源于stack exchange，提问作者Eric Movsessian