嵌套类构造函数的可见性

Question

有没有办法限制C#中嵌套类的实例化？我想防止嵌套类从除嵌套类之外的任何其他类实例化，但允许从其他代码完全访问嵌套类。

Answer 1

通常，我会为要向其他类公开的功能创建一个接口，然后将嵌套类设为私有并实现该接口。这样嵌套类定义可以保持隐藏：

public class Outer
{
    private class Nested : IFace
    {
        public Nested(...)
        {
        }
        //interface member implementations...
    }

    public IFace GetNested()
    {
        return new Nested();
    }
}

Answer 2

如果您需要满足以下要求之一：

• 您希望密封嵌套类，
• 您不想将所有嵌套类的方法签名复制到 Lee的回答，

我找到了类似于ak99372发布的解决方案 ，但不使用静态初始值设定项：

public class Outer
{
    private interface IPrivateFactory<T>
    {
        T CreateInstance();
    }

    public sealed class Nested
    {
        private Nested() {
            // private constructor, accessible only to the class Factory.
        }

        public class Factory : IPrivateFactory<Nested>
        {
            Nested IPrivateFactory<Nested>.CreateInstance() { return new Nested(); }
        }
    }

    public Nested GetNested() {
        // We couldn't write these lines outside of the `Outer` class.
        IPrivateFactory<Nested> factory = new Nested.Factory();
        return factory.CreateInstance();
    }
}

这个想法是 Nested 类的构造函数只能由 Factory 类访问，该类嵌套更深一层。 Factory 类显式实现私有接口 IPrivateFactory 中的 CreateInstance 方法，以便只有那些可以看到 IPrivateFactory 的人可以调用CreateInstance并获取Nested的新实例。

Outer 类外部的代码无法在不询问 Outer.GetNested() 的情况下自由创建 Nested 的实例，因为

1. Outer.Nested< /code> 的构造函数是私有的，因此无法直接调用
2. Outer.Nested.Factory 可以实例化，但无法强制转换为 IPrivateFactory，因此无法调用其 CreateInstance() 方法。

请注意，我不建议在生产代码中大量使用该模式，但我发现这是一个在极少数情况下有用的技巧。

Answer 3

简而言之，不，你不能那样做。有一个可访问性修饰符“public”，意思是“可以被我内部或外部的任何东西访问”，还有一个可访问性修饰符“private”，意思是“可以被我内部的任何东西访问”。没有修饰符意味着“可以直接访问我之外的东西，但不能访问它之外的任何东西”，这就是您需要将构造函数标记为的修饰符。类型系统的设计者认为这根本不是一个有用的概念。

您能描述一下为什么您想要这种疯狂的可访问性吗？也许有更好的方法来获得你想要的东西。

Answer 4

由于 C# 语法中没有任何内容，因此您必须在它们之间实现类似“合同”的内容。您可以利用嵌套类可以访问其父级的私有字段的事实：

public class ParentClass
{
  private static Func<FriendClass> _friendContract;

  public class FriendClass
  {
      static FriendClass()
      {
          _friendContract= () => new FriendClass();
      }

      private FriendClass() { }
  }

  ///Usage
  public FriendClass MethodUse()
  {
      var fInstance = _friendContract();
      //fInstance.DoSomething();
      return fInstance;
  }
}

当然您可以调整契约来处理不同的参数

 private static Func<Arg1,Arg2,FriendClass> _friendContract;

Answer 5

使用 C# 11 的新静态抽象接口成员，您可以非常巧妙地限制嵌套类的实例化：

public class Outer
{
    protected interface INestedFactory<T> where T : INestedFactory<T>
    {
        public static abstract T CreateInstance();
    }

    public class SomeNested : INestedFactory<SomeNested>
    {
        private SomeNested() { }

        static SomeNested INestedFactory<SomeNested>.CreateInstance()
        {
            return new SomeNested();
        }
    }

    protected void CreateNested<T>() where T : INestedFactory<T>
    {
        T.CreateInstance();
    }
}

Answer 6

对于 Joshua Smith 提出的答案，我发现有必要强制 FriendClass 的静态构造函数运行，这是通过从 ParentClass 的静态构造函数调用 FriendClass 上的空静态 Initalize() 方法来实现的。

Answer 7

public class Outer
{
    public class Nested
    {
        readonly Outer Outer;

        public Nested(Outer outer /* , parameters */)
        {
            Outer = outer;

            // implementation
        }

        // implementation
    }

    public Nested GetNested(/* parameters */) => new Nested(this /* , parameters */);
}

请注意，您可以从 Nested 访问 Outer 的私有成员。