c# - 有没有办法让构造函数只对 C# 中的父类可见？

Question

我有一组继承 self 创建的抽象类的类。我想将抽象类用作创建抽象类具体实现实例的工厂。

除了父类之外，有什么方法可以在所有代码中隐藏构造函数。

基本上我想这样做

public abstract class AbstractClass
{
    public static AbstractClass MakeAbstractClass(string args)
    {
        if (args == "a")
            return new ConcreteClassA();
        if (args == "b")
            return new ConcreteClassB();
    }
}

public class ConcreteClassA : AbstractClass
{
}

public class ConcreteClassB : AbstractClass
{
}

但我想阻止任何人直接实例化这两个具体类。我想确保只有 MakeAbstractClass() 方法可以实例化基类。有什么办法吗？

更新
我不需要从抽象类外部访问 ConcreteClassA 或 B 的任何特定方法。我只需要我的抽象类提供的公共(public)方法。我真的不需要阻止具体类被实例化，我只是想避免它，因为它们不提供新的公共(public)接口(interface)，只是抽象类内部一些非常具体的东西的不同实现。

对我来说，最简单的解决方案是 make child classes as samjudson mentioned .但是我想避免这种情况，因为它会使我的抽象类文件比我希望的大很多。我宁愿将类分成几个文件以便组织。

我猜这没有简单的解决方案...

Answer 1

To me, the simplest solution is to make child classes as samjudson mentioned. I'd like to avoid this however since it would make my abstract class' file a lot bigger than I'd like it to be. I'd rather keep classes split out over a few files for organization.

没问题，只需使用 partial 关键字，您就可以将内部类拆分为任意数量的文件。您不必将其保存在同一个文件中。

上一个答案:

这是可能的，但只有反射(reflection)

public abstract class AbstractClass
{
    public static AbstractClass MakeAbstractClass(string args)
    {
        if (args == "a")
            return (AbstractClass)Activator.CreateInstance(typeof(ConcreteClassA), true);
        if (args == "b")
            return (AbstractClass)Activator.CreateInstance(typeof(ConcreteClassB), true);
    }
}

public class ConcreteClassA : AbstractClass
{
    private ConcreteClassA()
    {
    }
}

public class ConcreteClassB : AbstractClass
{
    private ConcreteClassB()
    {
    }
}

这是另一种模式，没有丑陋的MakeAbstractClass(string args)

public abstract class AbstractClass<T> where T : AbstractClass<T>
{
    public static T MakeAbstractClass()
    {
        T value = (T)Activator.CreateInstance(typeof(T), true);
        // your processing logic
        return value;
    }
}

public class ConcreteClassA : AbstractClass<ConcreteClassA>
{
    private ConcreteClassA()
    {
    }
}

public class ConcreteClassB : AbstractClass<ConcreteClassB>
{
    private ConcreteClassB()
    {
    }
}