Constructor C#

En este tutorial, aprenderemos sobre los constructores de C# y sus tipos con la ayuda de ejemplos.

En C#, un constructor es similar a un método que se invoca cuando se crea un objeto de la clase.

Sin embargo, a diferencia de los métodos, un constructor:

tiene el mismo nombre que el de la clase
no tiene ningún tipo de retorno

Crear un constructor C#

Así es como creamos un constructor en C#

class Car {
  
  // constructor
  Car() {
    //code
  }

}

Aquí, Coche() es un constructor. Tiene el mismo nombre que su clase.

Llamar a un constructor

Una vez que creamos un constructor, podemos llamarlo usando el new palabra clave. Por ejemplo,

new Car();

En C#, se llama a un constructor cuando intentamos crear un objeto de una clase. Por ejemplo,

Car car1 = new Car();

Aquí, estamos llamando al Car() constructor para crear un objeto coche1 . Para obtener más información sobre los objetos, visite Clases y objetos de C#.

Tipos de Constructores

Existen los siguientes tipos de constructores:

Constructor sin parámetros
Constructor parametrizado
Constructor predeterminado

1. Constructor sin parámetros

Cuando creamos un constructor sin parámetros, se le conoce como constructor sin parámetros. Por ejemplo,

using System;

namespace Constructor {

  class Car {   

    // parameterless constructor
    Car() {
      Console.WriteLine("Car Constructor");
    }
 
    static void Main(string[] args) {

      // call constructor
      new Car();
      Console.ReadLine();
     
    }
  }
}

Salida

Car Constructor

En el ejemplo anterior, hemos creado un constructor llamado Car() .

new Car();

Podemos llamar a un constructor agregando un new palabra clave al nombre del constructor.

2. Constructor parametrizado de C#

En C#, un constructor también puede aceptar parámetros. Se llama un constructor parametrizado. Por ejemplo,

using System;

namespace Constructor {

  class Car {   

    string brand;
    int price;

    // parameterized constructor
    Car(string theBrand, int thePrice) {

      brand = theBrand;
      price = thePrice;
    }
  
    static void Main(string[] args) {

      // call parameterized constructor
      Car car1 = new Car("Bugatti", 50000);

      Console.WriteLine("Brand: " + car1.brand);
      Console.WriteLine("Price: " + car1.price);
      Console.ReadLine();
     
    }
  }
}

Salida

Brand: Bugatti
Price: 50000

En el ejemplo anterior, hemos creado un constructor llamado Car() . El constructor toma dos parámetros:theBrand y elPrecio .

Note la declaración,

Car car1 = new Car("Bugatti", 50000);

Aquí, estamos pasando los dos valores al constructor.

Los valores pasados al constructor se llaman argumentos. Debemos pasar el mismo número y tipo de valores como parámetros.

3. Constructor predeterminado

Si no hemos definido un constructor en nuestra clase, C# creará automáticamente un constructor predeterminado con un código vacío y sin parámetros. Por ejemplo,

using System;

namespace Constructor {

  class Program {  

    int a;

    static void Main(string[] args) {

      // call default constructor
      Program p1 = new Program();

      Console.WriteLine("Default value of a: " + p1.a);
      Console.ReadLine();
     
    }
  }
}

Salida

Default value of a: 0

En el ejemplo anterior, no hemos creado ningún constructor en el Programa clase. Sin embargo, mientras creamos un objeto, estamos llamando al constructor.

Program p1 = new Program();

Aquí, C# crea automáticamente un constructor predeterminado. El constructor predeterminado inicializa cualquier variable no inicializada con el valor predeterminado.

Por lo tanto, obtenemos 0 como el valor de int variable a .

Nota :En el constructor predeterminado, todos los campos numéricos se inicializan en 0, mientras que la cadena y el objeto se inicializan como nulos.

4. Copiar constructor en C#

Usamos un constructor de copia para crear un objeto copiando datos de otro objeto. Por ejemplo,

using System;

namespace Constructor {

  class Car {  
    string brand;

    // constructor
    Car (string theBrand) {
      brand = theBrand;
    }

    // copy constructor
    Car(Car c1) {
      brand = c1.brand;
    }

    static void Main(string[] args) {
      // call constructor
      Car car1 = new Car("Bugatti");

      Console.WriteLine("Brand of car1: " + car1.brand);

      // call the copy constructor
      Car car2 = new Car(car1);
      Console.WriteLine("Brand of car2: " + car2.brand);

      Console.ReadLine();
     
    }
  }
}

Salida

Brand of car1: Bugatti
Brand of car2: Bugatti

En el programa anterior, hemos utilizado un constructor de copias.

Car(Car c1) {
  brand = c1.brand;
}

Aquí, este constructor acepta un objeto de Car como su parámetro. Entonces, al crear el car2 objeto, hemos pasado el car1 objeto como un argumento para el constructor de copias.

Car car2 = new Car(car1);

Dentro del constructor de copias, hemos asignado el valor de la marca para coche1 objetar la marca variable para coche2 objeto. Por tanto, ambos objetos tienen el mismo valor de la marca .

5. Constructor Privado

Podemos crear un constructor privado usando el private especificador de acceso. Esto se conoce como constructor privado en C#.

Una vez que el constructor se declara privado, no podemos crear objetos de la clase en otras clases.

Ejemplo 1:Constructor privado

using System;

namespace Constructor {

  class Car {  
  
   // private constructor
   private Car () {
    Console.WriteLine("Private Constructor");    
    }
  }
    
    class CarDrive {

      static void Main(string[] args) {

      // call private constructor
      Car car1 = new Car();
      Console.ReadLine();
    }
  }
}

En el ejemplo anterior, hemos creado un constructor privado Car() . Dado que no se accede a los miembros privados fuera de la clase, cuando intentamos crear un objeto de Car

// inside CarDrive class
Car car1 = new Car();

obtenemos un error

error CS0122: 'Car.Car()' is inaccessible due to its protection level

Nota :Si un constructor es privado, no podemos crear objetos de la clase. Por lo tanto, todos los campos y métodos de la clase deben declararse estáticos, para que se pueda acceder a ellos usando el nombre de la clase.

6. Constructor estático de C#

En C#, también podemos hacer que nuestro constructor sea estático. Usamos el static palabra clave para crear un constructor estático. Por ejemplo,

using System;

namespace Constructor {

  class Car {  
  
   // static constructor
   static Car () {
    Console.WriteLine("Static Constructor");    
   }

    // parameterless constructor
    Car() {
     Console.WriteLine("Default Constructor");
   } 

    static void Main(string[] args) {

      // call parameterless constructor
      Car car1 = new Car();

      // call parameterless constructor again
      Car car2 = new Car();

      Console.ReadLine();
    }
  }
}

En el ejemplo anterior, hemos creado un constructor estático.

static Car () {
  Console.WriteLine("Static Constructor");    
}

No podemos llamar a un constructor estático directamente. Sin embargo, cuando llamamos a un constructor normal, el constructor estático se llama automáticamente.

Car car1 = new Car();

Aquí, estamos llamando al Car() constructor. Puede ver que el constructor estático también se llama junto con el constructor normal.

Salida

Static Constructor
Default Constructor
Default Constructor

El constructor estático se llama solo una vez durante la ejecución del programa. Es por eso que cuando volvemos a llamar al constructor, solo se llama al constructor normal.

Nota :Solo podemos tener un constructor estático en una clase. No puede tener parámetros ni modificadores de acceso.

Sobrecarga del constructor C#

En C#, podemos crear dos o más constructores en una clase. Se conoce como sobrecarga del constructor. Por ejemplo,

using System;

namespace ConstructorOverload {

  class Car {   
    
    // constructor with no parameter
    Car() {
      Console.WriteLine("Car constructor");
    }
     
    // constructor with one parameter
    Car(string brand) {
      Console.WriteLine("Car constructor with one parameter");
      Console.WriteLine("Brand: " + brand);
    }

    static void Main(string[] args) {

      // call constructor with no parameter
      Car car = new Car();

      Console.WriteLine();

      // call constructor with parameter
      Car car2 =  new Car("Bugatti");
     
      Console.ReadLine();
    }
  }
}

Salida

Car constructor

Car constructor with one parameter
Brand: Bugatti

En el ejemplo anterior, hemos sobrecargado el Car constructor:

un constructor tiene un parámetro
otro tiene dos parámetros

Según el número del argumento pasado durante la llamada al constructor, se llama al constructor correspondiente.

Aquí,

Objeto coche - llama al constructor con un parámetro
Objeto coche2 - llama al constructor con dos parámetros

Para obtener más información, visite Sobrecarga de constructores de C#.

Ámbito variable de C# C# esta palabra clave

Lenguaje C