Visibilidad del constructor de clase anidada

Question

¿Hay alguna manera de limitar la creación de instancias de la clase anidada en C#? Quiero evitar la creación de una instancia de clase anidada desde cualquier otra clase, excepto la clase de anidación, pero para permitir el acceso completo a la clase anidada desde otro código.

Answer 1

Normalmente creo una interfaz para la funcionalidad que desea exponer a otras clases, a continuación, hago que la clase anidada sea privada e implemente esa interfaz. De esta forma, la definición de clase anidada puede permanecer oculta:

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

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

Answer 2

En resumen, no, no se puede hacer eso. Hay un modificador de accesibilidad "público" que significa "accesible por cualquier cosa dentro de mí o fuera de mí" y hay un modificador de accesibilidad "privado" que significa "accesible por cualquier cosa dentro de mí". No hay ningún modificador que signifique "accesible para la cosa inmediatamente fuera de mí, pero no para nada que esté fuera de ella", que es lo que necesitaría marcar como constructor. Eso simplemente no es un concepto que los diseñadores del sistema tipo pensaron sería útil.

¿Puedes describir por qué quieres este tipo loco de accesibilidad? Tal vez haya una mejor manera de obtener lo que quieres.

Answer 3

ACTUALIZACIÓN: respuesta incorrecta, ver los comentarios

El modificador interno es lo que busca:

public class OuterClass 
{ 
    public class NestedClass { 
     internal NestedClass() 
     { 

     } 
    } 
} 

NestedClass serán visibles para todos, pero es constructor estará disponible sólo para OuterClass.

Answer 4

Dado que no hay nada en la sintaxis C#, tendrá que implementar algo así como "un contrato" entre ellos. Se puede aprovechar el hecho de que la clase anidada puede acceder a los campos privados de su matriz:

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; 
    } 
} 

Por supuesto, se puede ajustar el contrato para manejar diferentes parámetros

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

Answer 5

Si necesita conocer a uno de los siguientes requisitos:

• Usted desea que la clase anidada a sellar,
• usted no quiere copiar todos m de la clase anidada firmas é todo a una interfaz como en Lee's answer,

he encontrado una solución similar a the one posted by ak99372, pero sin utilizar un inicializador estático:

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(); 
    } 
} 

La idea es que el constructor de la clase Nested sólo se puede acceder a la Factory clase, que está anidado un nivel más profundo. La clase Factory implementa explícitamente el método CreateInstance desde la interfaz privada IPrivateFactory, de modo que solo aquellos que pueden ver IPrivateFactory pueden llamar al CreateInstance y obtener una nueva instancia de Nested.

Código Outer fuera de la clase no se puede crear libremente los casos de Nested sin pedir Outer.GetNested(), porque

1. Outer.Nested 's constructor se privated, por lo que no se puede llamar directamente
2. Outer.Nested.Factory se pueden crear instancias , pero no se puede convertir a IPrivateFactory, por lo que no se puede llamar al método CreateInstance().

Tenga en cuenta que no recomendaría utilizar ese patrón en gran medida en el código de producción, pero es un truco que me parece útil tener en la manga en raras ocasiones.

Answer 6

Para la respuesta propuesta por Joshua Smith, me pareció necesario forzar el constructor estático de FriendClass para ejecutarlo, logrando invocar un método vacío de Initalize() en FriendClass desde el constructor estático de ParentClass.

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 */); 
} 

Tenga en cuenta que puede acceder a los miembros privados de Outer desde Nested.