C#如何在类内一次性指定泛型类型参数并全局复用

C# 泛型参数属于编译期确定的类型符号，不支持将运行时Type实例直接作为泛型参数传入，你示例中DoSomething<WriteTypeOnce>()的写法无法通过编译。但可以通过两种无额外运行时开销的方案，完全实现你的核心需求：类内仅需修改一处即可替换所有目标类型引用，对外暴露的类为非泛型形式，外部实例化时无需传入泛型参数。

方案1：私有嵌套泛型类封装（最匹配需求） #

这个方案完全贴合你希望“类整体围绕单一类型设计、对外无泛型参数”的要求，所有类型绑定逻辑都能获得完整的编译期检查和IDE智能提示，无反射开销。
核心思路是：对外暴露的外层类保持非泛型，所有依赖目标类型的逻辑全部放入私有的嵌套泛型类中，仅在外层类初始化嵌套类实例时指定一次具体类型，后续修改目标类型仅需调整这一处声明。
示例代码：

// 对外公开的非泛型类，外部使用时直接实例化即可，无需传入任何泛型参数
public class ClassWhichDoesThings
{
    // 私有嵌套泛型类，所有和目标类型绑定的逻辑全部写在这里
    private class TypeDrivenLogic<TTarget>
    {
        public void RunAllTasks()
        {
            // 内部直接用TTarget作为泛型参数，无需重复写具体类型
            DoSomething<TTarget>();
            DoAnotherThing<TTarget>();
            AndAnother<TTarget>();
        }

        public TTarget CreateAThing(string input)
        {
            // 具体业务实现
            return default;
        }

        // 其他所有用到目标类型的成员、泛型方法都可以放在这里
        private void DoSomething<T>() { /* 原有业务逻辑 */ }
        private void DoAnotherThing<T>() { /* 原有业务逻辑 */ }
        private void AndAnother<T>() { /* 原有业务逻辑 */ }
    }

    // 👇 仅在这里指定一次目标类型，后续要换类型只需要改这一行
    private readonly TypeDrivenLogic<TheTypeIWantToSpecifyOnce> _coreLogic = new();

    // 外层类仅做公开接口转发，对外不暴露任何泛型实现细节
    public void ExecuteAllTasks() => _coreLogic.RunAllTasks();
    public TheTypeIWantToSpecifyOnce CreateAThing(string input) => _coreLogic.CreateAThing(input);
}

方案优势：

• 对外使用体验和普通非泛型类完全一致，外部代码无感知
• 内部泛型逻辑可以获得完整的编译期类型检查、智能提示，无性能损耗
• 类型封装性好，所有和目标类型耦合的逻辑都聚合在嵌套类中，结构清晰
• 替换目标类型时仅需修改一处声明，其余代码完全不需要调整

方案2：文件级类型别名（最轻量方案） #

如果类的逻辑不复杂，不需要额外封装嵌套类，可以利用C#的using别名功能，在代码文件顶部一次性定义类型别名，整个文件内所有位置都可以用别名代替具体类型，修改时仅需调整顶部的别名定义即可。
示例代码：

// 👇 在当前.cs文件最顶部定义别名，要换类型只改这一行
using TargetType = YourProject.TheTypeIWantToSpecifyOnce;

public class ClassWhichDoesThings
{
    public void RunAllTasks()
    {
        DoSomething<TargetType>();
        DoAnotherThing<TargetType>();
        AndAnother<TargetType>();
    }

    public TargetType CreateAThing(string input)
    {
        // 具体业务实现
        return default;
    }

    private void DoSomething<T>() { /* 原有业务逻辑 */ }
    private void DoAnotherThing<T>() { /* 原有业务逻辑 */ }
    private void AndAnother<T>() { /* 原有业务逻辑 */ }
}

方案优劣势：

• 优势：代码改动量极小，不需要额外封装嵌套类，同样是编译期替换，无性能损耗
• 劣势：别名是文件级生效，如果类拆分为多个partial类文件，每个文件都需要单独定义别名；类型聚合度不如嵌套泛型类方案。

不推荐的反射方案 #

如果一定要用运行时Type变量调用泛型方法，只能通过反射动态构造泛型方法实现，类似下面的写法：

Type writeTypeOnce = typeof(TheTypeIWantToSpecifyOnce);
MethodInfo genericDoSomething = GetType()
    .GetMethod(nameof(DoSomething), BindingFlags.Instance | BindingFlags.NonPublic)
    .MakeGenericMethod(writeTypeOnce);
genericDoSomething.Invoke(this, null);

这种写法没有编译期类型检查，性能差，代码冗余度高，完全违背简化维护的初衷，非极端场景不要使用。

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