C# 中 internal abstract 的作用

编程技术
,
1

internal abstract 是 C# 中用于类（class）或类成员（如方法 method、属性 property）的两个关键字的组合。它们各自有独立的含义，组合在一起则定义了一种特定的行为和可见性。

定义

让我们分别理解这两个关键字，然后看它们的组合：

  1. internal (内部的)：

    • 这是一个 访问修饰符。
    • 它限制了类型或成员的可见性，使其 只能在同一个程序集 (assembly) 内被访问。
    • 程序集通常是一个 .dll 或 .exe 文件。
    • 这意味着在当前项目（编译成一个程序集）中的任何代码都可以访问 internal 成员，但项目外部（其他程序集）的代码则不能直接访问。

  2. abstract (抽象的)：

    • 用于类时：
      • 表明这个类是一个 抽象类。
      • 抽象类 不能被直接实例化（不能使用 new关键字创建对象）。
      • 它通常作为其他类的 基类，提供一个共同的定义或部分实现。
      • 抽象类可以包含抽象成员和非抽象成员。
    • 用于方法或属性时：
      • 表明这个成员是一个 抽象成员。
      • 抽象成员 只有声明，没有具体的实现（没有方法体）。
      • 抽象成员必须在非抽象的派生类中被 重写 (override) 并提供实现。
      • 抽象成员只能存在于抽象类中。

internal abstract 组合起来的作用：

当一个类被声明为 internal abstract class 时：

  • internal：这个抽象类只能在它所在的程序集内部被继承和使用。其他程序集无法看到或继承这个抽象类。
  • abstract：这个类不能被直接实例化，它必须被同一个程序集内的其他类继承。继承它的非抽象派生类必须实现其所有抽象成员。

主要目的和场景

  1. 程序集内部的扩展点/契约：
    你可能正在开发一个库或框架，希望在库的内部定义一些基础行为或结构，供库内部的其他组件来继承和实现。但你不希望这些内部的抽象设计暴露给库的使用者（其他程序集），避免它们错误地继承或依赖这些内部实现细节。

  2. 隐藏实现细节，强制内部规范：
    通过 internal abstract，你可以强制程序集内部的某些组件遵循特定的接口或行为模式，而无需将这些模式公开为公共 API 的一部分。这有助于保持公共 API 的简洁性，同时在内部实现更复杂的、受控的扩展机制。

  3. 版本控制和重构的灵活性：
    由于 internal abstract 类和其成员不属于公共 API，因此在后续版本中修改或重构它们时，不必太担心破坏外部程序集的兼容性（因为外部程序集本来就无法访问它们）。

示例

// AssemblyA.dll

// 这是一个只能在 AssemblyA 内部被继承的抽象类
internal abstract class InternalBaseProcessor 
{
    // 这是一个只能在 AssemblyA 内部被重写的抽象方法
    internal abstract void ProcessData(string data);

    // 这是一个 AssemblyA 内部可以使用的具体方法
    internal void Log(string message) 
    {
        Console.WriteLine($"[LOG]: {message}");
    }

    public void PublicHelperMethod() // 假设它也想提供一个公开的辅助方法
    {
        Console.WriteLine("Public helper method from InternalBaseProcessor's hierarchy.");
    }
}

// 同一个程序集 (AssemblyA) 内的类可以继承它
internal class ConcreteProcessor : InternalBaseProcessor
{
    internal override void ProcessData(string data)
    {
        Log($"Processing: {data.ToUpper()}"); // 可以调用基类的 internal 方法
        Console.WriteLine($"Data processed: {data.ToUpper()}");
    }
}

public class ServiceInAssemblyA
{
    public void DoWork()
    {
        // 可以创建 ConcreteProcessor，因为它也在 AssemblyA 中
        InternalBaseProcessor processor = new ConcreteProcessor(); 
        processor.ProcessData("some internal data");
        processor.PublicHelperMethod();
    }
}

// AssemblyB.dll (引用 AssemblyA.dll)

public class UserInAssemblyB
{
    public void TryUse()
    {
        // 下面这行会产生编译错误，因为 InternalBaseProcessor 是 internal 的
        // AssemblyA.InternalBaseProcessor processor; 

        // 下面这行也会产生编译错误，因为 ConcreteProcessor 是 internal 的
        // AssemblyA.ConcreteProcessor concrete = new AssemblyA.ConcreteProcessor();

        // 如果 ServiceInAssemblyA 是 public，并且 DoWork 是 public，则可以这样用
        AssemblyA.ServiceInAssemblyA service = new AssemblyA.ServiceInAssemblyA();
        service.DoWork(); // 这会间接使用到 InternalBaseProcessor 和 ConcreteProcessor
                          // 但是 AssemblyB 本身无法直接访问或继承它们
    }
}

总结来说，internal abstract 定义了一个 仅限于当前程序集内部使用的、不可实例化的基类（或基类成员），它强制其在同一程序集内的派生类提供具体实现，同时将这些设计细节对外部程序集隐藏起来。