c# - qué - que es una clase en programacion

Clases internas privadas en C#: ¿por qué no se usan con más frecuencia?

Question

Soy relativamente nuevo en C # y cada vez que comienzo a trabajar en un proyecto de C # (solo trabajé en proyectos casi maduros en C #) me pregunto por qué no hay clases internas.

Tal vez no entiendo su objetivo. Para mí, las clases internas, al menos las clases internas privadas, se parecen mucho a los "procedimientos internos" en Pascal / Modula-2 / Ada: permiten dividir una clase principal en partes más pequeñas para facilitar la comprensión.

Ejemplo: aquí es lo que se ve la mayor parte del tiempo:

public class ClassA
{
   public MethodA()
   {
      <some code>
      myObjectClassB.DoSomething(); // ClassB is only used by ClassA
      <some code>
   }
}

public class ClassB
{
   public DoSomething()
   {
   }
}

Como ClassA se utilizará (al menos por un tiempo) solo por ClassA, supongo que este código se expresaría mejor de la siguiente manera:

   public class ClassA
   {
      public MethodA()
      {
         <some code>
         myObjectClassB.DoSomething(); // Class B is only usable by ClassA
         <some code>
      }

      private class ClassB
      {
         public DoSomething()
         {
         }
      }
   }

Me alegraría saber de usted sobre este tema. ¿Estoy en lo correcto?

Answer 1

Debe limitar las responsabilidades de cada clase para que cada una se mantenga simple, comprobable y reutilizable . Las clases internas privadas van en contra de eso. Contribuyen a la complejidad de la clase externa, no son verificables y no son reutilizables.

Answer 2

Las Pautas de diseño de marco tienen las mejores reglas para usar clases anidadas que he encontrado hasta la fecha.

Aquí hay una breve lista de resumen:

1. Utilice los tipos anidados cuando la relación entre tipo y tipo anidado es tal que se desea la semántica de accesibilidad de miembros.

2. NO use tipos públicos anidados como una construcción de grupo lógica

3. Evite el uso de tipos anidados expuestos públicamente.

4. NO use tipos anidados si es probable que se haga referencia al tipo fuera del tipo contenedor.

5. NO use tipos anidados si necesitan ser instanciados por el código del cliente.

6. NO defina un tipo anidado como miembro de una interfaz.

Answer 3

Las clases anidadas (probablemente sea mejor evitar la palabra "interno" como clases anidadas en C # son algo diferentes de las clases internas en Java) pueden ser muy útiles.

Un patrón que no se ha mencionado es el patrón de "mejor enumeración", que puede ser aún más flexible que el de Java:

public abstract class MyCleverEnum
{
    public static readonly MyCleverEnum First = new FirstCleverEnum();
    public static readonly MyCleverEnum Second = new SecondCleverEnum();

    // Can only be called by this type *and nested types*
    private MyCleverEnum()
    {
    }

    public abstract void SomeMethod();
    public abstract void AnotherMethod();

    private class FirstCleverEnum : MyCleverEnum
    {
        public override void SomeMethod()
        {
             // First-specific behaviour here
        }

        public override void AnotherMethod()
        {
             // First-specific behaviour here
        }
    }

    private class SecondCleverEnum : MyCleverEnum
    {
        public override void SomeMethod()
        {
             // Second-specific behaviour here
        }

        public override void AnotherMethod()
        {
             // Second-specific behaviour here
        }
    }
}

Podríamos hacer algo de soporte de idiomas para hacer algo de esto automáticamente, y hay muchas opciones que no he mostrado aquí, como no usar una clase anidada para todos los valores, o usar la misma clase anidada para múltiples valores, pero dándoles diferentes parámetros de constructor. Pero, básicamente, el hecho de que la clase anidada pueda llamar al constructor privado da mucho poder.

Answer 4

Personalmente, solo creo clases internas privadas si necesito crear colecciones en proceso de un objeto que pueden requerir métodos sobre ellas.

De lo contrario, podría causar confusión a otros desarrolladores que trabajan en el proyecto para encontrar realmente estas clases, ya que no están muy claros en cuanto a dónde se encuentran.