qué - herencia y polimorfismo c#

Herencia+Clases anidadas en C#

Question

Podemos tener clases anidadas en C #. Estas clases anidadas también pueden heredar OuterClass. Por ejemplo:

public class OuterClass
{
  // code here
  public class NestedClass : OuterClass
  {
    // code here
  }
}

es completamente aceptable.

También podemos lograr esto sin convertir a NestedClass en clase anidada en OuterClass como se muestra a continuación:

public class OuterClass
{
  // code here
}

public class NestedClass : OuterClass
{
  // code here
}

Me pregunto, ¿cuál es la diferencia entre los dos escenarios anteriores? ¿Qué se puede lograr en el escenario I que no se puede lograr en el escenario II? ¿Hay algo que obtengamos más haciendo que NestedClass "anide" en OuterClasss?

Answer 1

Heredar de una clase principal no permite que una clase anidada vea los miembros y métodos privados de sus padres, solo los protegidos (y públicos). Anidarlo dentro de la clase principal le permite ver todos los miembros privados e invocar sus métodos privados, independientemente de si la clase anidada hereda de la clase principal o no.

Answer 2

Las clases anidadas son diferentes de las subclases en la forma en que pueden acceder a las propiedades y campos privados de la clase contenedora al heredar de ella.

Las clases anidadas representan la combinación de herencia con encapsulación en OOP, en términos de implementación de patrón de diseño singleton, donde las dependencias están bien ocultas y una clase proporciona un único punto de acceso con acceso estático a las clases internas, mientras se mantiene la capacidad de instanciación.

Por ejemplo, utilizando la clase práctica para conectarse a la base de datos e insertar datos:

public class WebDemoContext
{
    private SqlConnection Conn;
    private string connStr = ConfigurationManager.ConnectionStrings["WebAppDemoConnString"].ConnectionString;

    protected void connect()
    {
        Conn = new SqlConnection(connStr);
    }

    public class WebAppDemo_ORM : WebDemoContext
    {
        public int UserID { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public string Phone { get; set; }
        public string Email { get; set; }
        public string UserName { get; set; }
        public string UserPassword { get; set; }

        public int result = 0;

        public void RegisterUser()
        {
            connect();
            SqlCommand cmd = new SqlCommand("dbo.RegisterUser", Conn);
            cmd.CommandType = CommandType.StoredProcedure;
            cmd.Parameters.AddWithValue("FirstName", FirstName);
            cmd.Parameters.AddWithValue("LastName", LastName);
            cmd.Parameters.AddWithValue("Phone", Phone);
            cmd.Parameters.AddWithValue("Email", Email);
            cmd.Parameters.AddWithValue("UserName", UserName);
            cmd.Parameters.AddWithValue("UserPassword", UserPassword);

            try
            {
                Conn.Open();
                result = cmd.ExecuteNonQuery();
            }
            catch (SqlException se)
            {
                DBErrorLog.DbServLog(se, se.ToString());
            }
            finally
            {
                Conn.Close();
            }
        }
    }
}

La clase WebAppDemo_ORM es una clase anidada dentro de WebDemoContext y, al mismo tiempo, hereda de WebDemoContext de esta forma la clase anidada puede acceder a todos los miembros de la clase contenedora, incluidos los miembros privados, que pueden ser efectivos para reducir DRY y lograr SOC .

Answer 3

el segundo ejemplo que proporcionó no es una clase anidada, sino una clase normal que deriva de OuterClass .

• los tipos anidados están por defecto a private visibilidad private , pero se pueden declarar con una visibilidad más amplia
• los tipos anidados pueden acceder a las propiedades, los campos y los métodos del tipo contenedor (incluso los declarados private y los heredados de los tipos base)

También eche un vistazo a esta pregunta aquí sobre cuándo y por qué usar clases anidadas.
Enlace MSDN: Tipos anidados (Guía de programación C #)

EDITAR
Para abordar el comentario de @ Henk sobre la diferencia en la naturaleza de ambas relaciones (herencia vs. tipos anidados): En ambos casos, usted tiene una relación entre las dos clases, pero son de naturaleza diferente. Cuando se deriva de una clase base, la clase derivada hereda todos private métodos, propiedades y campos (excepto private ) de la clase base. Esto no es cierto para la clase anidada. Las clases anidadas no heredan nada, pero tienen acceso a todo en la clase que lo contiene, incluso campos, propiedades y métodos private .

Answer 4

Es posible que sea demasiado tarde. Pero permítame agregar mis 2 centavos. Por favor , si pudiera entender su pregunta correctamente, quiere decir:

¿Cuál es la ventaja de una clase anidada que también heredó de su clase externa?

El punto clave es en la construcción

Primer código:

    public class OuterClass
{
    public OuterClass{console.writeln("OuterClaass Called");}

  public class NestedClass : OuterClass //It does Inherit
  {
    public NestedClass{console.writeln("NestedClass Called");}
  }
}

static void Main()
{
  outerClass.NestedClass nestedobject = new outerClass.NestedClass();
}

OutPut:

Clase externa llamada

NestedClass Llamado

Segundo código:

public class OuterClass
{
    public OuterClass{console.writeln("OuterClaass Called");}

  public class NestedClass //it dosent Inherit
  {
    public NestedClass{console.writeln("NestedClass Called");}
  }
}

static void Main()
{

  OuterClass.NestedClass nestedobject = new OuterClass.NestedClass();
}

Salida:

NestedClass llamado

En el primer código al construir el objeto NestedClass, el Constructor de la OutrClass también sería llamado y en mi opinión significa Composición Relación entre NestedClass y The OuterClass, pero en el segundo código Construcción de objetos de NestedClass y Outerclass no está limitado y se hace de forma independiente.

Espero que sea útil.