Entendiendo clases anidadas en C#: Definición, uso y herencia

Entendiendo clases anidadas en C#

Explora cómo definir, acceder y heredar clases anidadas en C# con ejemplos prácticos que demuestran mejores prácticas.

En C#, una clase puede declararse dentro de otra clase. El tipo interno se denomina clase anidada. Por ejemplo:

class OuterClass {
    // ... miembros externos
    class InnerClass {
        // ... miembros internos
    }
}

Este ejemplo crea InnerClass dentro de OuterClass. El tipo interno solo es visible dentro del tipo externo a menos que su modificador de acceso lo permita de otro modo.

---

Accediendo a miembros de clase anidada

Para trabajar con tipos anidados, primero instancias cada clase por separado.

1. Crear una instancia de la clase externa

OuterClass outer = new OuterClass();

Aquí, outer es un objeto de OuterClass.

2. Crear una instancia de la clase anidada

OuterClass.InnerClass inner = new OuterClass.InnerClass();

Como InnerClass está anidada dentro de OuterClass, la calificas con el nombre del tipo externo.

Una vez instanciadas, puedes llamar a miembros a través de la referencia del objeto.

Ejemplo: Clase anidada con métodos

using System;
namespace NestedClassDemo {
    public class Car {
        public void DisplayCar() => Console.WriteLine("Car: Bugatti");
        public class Engine {
            public void DisplayEngine() => Console.WriteLine("Engine: Petrol Engine");
        }
    }
    class Program {
        static void Main(string[] args) {
            Car sportsCar = new Car();
            sportsCar.DisplayCar();
            Car.Engine petrolEngine = new Car.Engine();
            petrolEngine.DisplayEngine();
            Console.ReadLine();
        }
    }
}

Salida

Car: Bugatti
Engine: Petrol Engine

El ejemplo muestra cómo crear objetos tanto de la clase externa Car como de la anidada Engine e invocar sus métodos.

Ten en cuenta que no puedes llamar a un método del tipo anidado directamente desde la instancia externa:

// Inválido
sportsCar.DisplayEngine();

---

Accediendo a miembros de la clase externa desde dentro de una clase anidada

Las clases anidadas pueden referenciar miembros de su tipo contenedor. Puedes usar una instancia del tipo externo o el nombre del tipo externo para miembros estáticos.

Usando una instancia para acceder a miembros de instancia

using System;
namespace NestedClassDemo {
    public class Car {
        public string Brand = "Bugatti";
        public class Engine {
            public void ShowBrand() {
                Car car = new Car();
                Console.WriteLine("Brand: " + car.Brand);
            }
        }
    }
    class Program {
        static void Main(string[] args) {
            Car.Engine engine = new Car.Engine();
            engine.ShowBrand();
            Console.ReadLine();
        }
    }
}

Salida

Brand: Bugatti

Accediendo a miembros estáticos sin instanciación

using System;
namespace NestedClassDemo {
    public class Car {
        public static string Brand = "Bugatti";
        public class Engine {
            public void ShowBrand() {
                Console.WriteLine("Brand: " + Car.Brand);
            }
        }
    }
    class Program {
        static void Main(string[] args) {
            Car.Engine engine = new Car.Engine();
            engine.ShowBrand();
            Console.ReadLine();
        }
    }
}

Salida

Brand: Bugatti

---

Herencia involucrando clases anidadas

Las clases anidadas pueden participar en herencia como cualquier otro tipo.

Derivando una clase de una clase externa

using System;
namespace NestedClassDemo {
    class Computer {
        public void Display() => Console.WriteLine("Method of Computer class");
        public class CPU {
            // Miembros adicionales pueden añadirse aquí
        }
    }
    class Laptop : Computer {
        // Laptop hereda todos los miembros de Computer
    }
    class Program {
        static void Main(string[] args) {
            Laptop laptop = new Laptop();
            laptop.Display();
            Console.ReadLine();
        }
    }
}

Salida

Method of Computer class

Derivando una clase de una clase anidada

using System;
namespace NestedClassDemo {
    class Computer {
        public class CPU {
            public void Display() => Console.WriteLine("Method of CPU class");
        }
    }
    class Laptop : Computer.CPU {
        // Laptop hereda miembros de Computer.CPU
    }
    class Program {
        static void Main(string[] args) {
            Laptop laptop = new Laptop();
            laptop.Display();
            Console.ReadLine();
        }
    }
}

Salida

Method of CPU class

Al heredar una clase anidada, debes calificar el tipo con su nombre de clase externa, p.ej., Computer.CPU.