Classe aninhada C#

Classe aninhada em C#

Neste tutorial, você aprenderá sobre a classe aninhada em C# com a ajuda de exemplos.

Em C#, podemos definir uma classe dentro de outra classe. É conhecido como uma classe aninhada. Por exemplo,

class OuterClass {
  ...
  class InnerClass {
    ...
  }
}

Aqui, criamos a classe InnerClass dentro da classe OuterClass . O InnerClass é chamada de classe aninhada.

---

Acessar membros

Para acessar membros das classes aninhadas, primeiro precisamos criar seus objetos.

1.Criar objeto da classe Outer

OuterClass obj1 = new OuterClass();

Aqui, criamos o obj1 objeto da classe OuterClass .

2. Criar objeto de classe interna

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

Você pode ver que usamos OuterClass.InnerClass para criar o obj2 objeto da classe interna. Isso ocorre porque InnerClass é a classe aninhada de OuterClass .

Uma vez que criamos o objeto de classes individuais, podemos usar o nome do objeto e o operador ponto para acessar os membros de cada classe.

Exemplo:classe aninhada C#

using System;
namespace CsharpNestedClass {
 
  // outer class
  public class Car {

    public void displayCar() {
      Console.WriteLine("Car: Bugatti");
    }
 
    // inner class
    public class Engine {
      public void displayEngine() {
        Console.WriteLine("Engine: Petrol Engine");
      }
    }
  }
  class Program {
    static void Main(string[] args) {

      // create object of outer class
      Car sportsCar = new Car();

      // access method of outer class
      sportsCar.displayCar();
 
      // create object of inner class
      Car.Engine petrolEngine = new Car.Engine();
      
      // access member of inner class
      petrolEngine.displayEngine();
 
      Console.ReadLine();
 
    }
  }
}

Saída

Car: Bugatti
Engine: Petrol Engine

No programa acima, aninhamos o Engine classe dentro do Car classe.

Dentro do Program classe, criamos objetos da classe externa e da classe interna.

// object of outer class
Car sportsCar = new Car();

// object of nested class
Car.Engine petrolEngine = new Car.Engine();

Em seguida, usamos esses objetos para acessar métodos de cada classe.

• sportsCar.displayCar() - acessar o método de classe externa usando o objeto de Car
• petrolEngine.displayEngine() - acessar o método de classe interna usando o objeto de Engine

Observação :Não podemos acessar os membros da classe interna usando o objeto da classe externa. Por exemplo,

// error code
sportsCar.displayEngine();

Aqui, não podemos acessar o displayEngine() método da classe interna Engine usando o sportsCar objeto da classe externa.

---

Acessar membros da classe externa dentro da classe interna

Podemos acessar membros da classe externa dentro da classe interna. Para isso usamos um objeto da classe externa. Por exemplo,

using System;
namespace CsharpNestedClass {

  // outer class
  public class Car {
 
    public string brand = "Bugatti";

    // nested  class
    public class Engine {
      public void displayCar() {

        // object of outer class
        Car sportsCar = new Car();
        Console.WriteLine("Brand: " + sportsCar.brand);
      }
    }
  }

  class Program {
    static void Main(string[] args) {

       // object of inner class
       Car.Engine engineObj = new Car.Engine();
       engineObj.displayCar();

      Console.ReadLine();
    }
  }
}

Saída

Brand: Bugatti

No exemplo acima, aninhamos o Engine classe dentro do Car classe. Observe a linha,

// inside Engine class
Car sportsCar = new Car();
Console.WriteLine("Brand: " + sportsCar.brand);

Aqui, usamos o objeto da classe Car para acessar o campo marca .

---

Acessar membros estáticos da classe externa dentro da classe interna

Se precisarmos acessar membros estáticos da classe externa, não precisamos criar seu objeto. Em vez disso, podemos usar diretamente o nome da classe externa. Por exemplo,

using System;
namespace CsharpNestedClass {

  // outer class
  public class Car {
    //static member of outer class
    public static string brand = "Bugatti";

    // nested class
    public class Engine {
      public void display() {
        
        // access static member of outer class
        Console.WriteLine("Brand: " + Car.brand);
      }
    }
  }
  class Program {
    static void Main(string[] args) {

      // object of inner class
       Car.Engine obj = new Car.Engine();
       obj.display();

      Console.ReadLine();
    }
  }
}

Saída

Brand: Bugatti

No exemplo acima, aninhamos o Engine classe dentro do Car classe. Car tem um campo estático marca .

Aqui, acessamos o campo estático marca dentro da classe interna (Engine ) usando o nome da classe externa (Car ).

Console.WriteLine("Brand: " + Car.brand);

---

Herdando a classe externa

Como uma classe regular, também podemos herdar a classe externa. Por exemplo,

using System;
namespace CsharpNestedClass {
 
  // outer class
  class Computer {

    public void display() {
      Console.WriteLine("Method of Computer class");
    }
 
    // nested class
    public class CPU {
 
    }
   }

    class Laptop : Computer {
 
    }

  class Program  {
    static void Main(string[] args) {
 
      // object of derived class
      Laptop obj = new Laptop();
      obj.display();     
 
      Console.ReadLine();
    }
  }
}

Saída

Method of Computer class

No exemplo acima, derivamos a classe Laptop da classe externa Computer .

Por isso, podemos acessar o display() método da classe Computer usando o objeto da classe Laptop .

---

Herdando classe interna

Em C#, podemos herdar a classe interna também. Por exemplo,

using System;
namespace CsharpNestedClass {

  // outer class
  class Computer {

    // nested  class
    public class CPU {
      public void display() {
        Console.WriteLine("Method of CPU class");
      }

    }
  }
    
  // inheriting inner class
  class Laptop : Computer.CPU {

  }

  class Program  {
    static void Main(string[] args) {

      // object of derived class
      Laptop obj = new Laptop();
      obj.display();     

      Console.ReadLine();
    }
  }
}

Saída

Method of CPU class

No exemplo acima, derivamos o Laptop classe da classe interna CPU .

Observe que usamos o nome da classe externa junto com a classe aninhada para herdar a classe interna.

class Laptop : Computer.CPU {}