Sobrecarga de constructores de C#

1. Constructores en C#
2. Sobrecarga de constructores en C#
3. Formas de sobrecarga de constructores

La sobrecarga de constructores es un tema tratado en este artículo en C#. Para comenzar, lo primero que debemos hacer es comprender qué son los constructores en C#.

Constructores en C#

Un constructor es un método de clase particular que se llama cada vez que se produce una instancia de esa clase. Este método se activa automáticamente cuando se crea una instancia de la clase.

La función principal del constructor es inicializar los campos privados de la clase antes de construir una instancia de la clase. Esto sucede simultáneamente con la creación de la instancia.

Si no crea manualmente un constructor para la clase, el compilador lo hará por usted y lo nombrará el constructor predeterminado de la clase. El valor cero se asigna a todos los campos numéricos de la clase, y el valor " " o Null se asigna a todas las clases de cadenas y campos de objetos cuando se utiliza el constructor predeterminado.

Sobrecarga de constructores en C#

La creación de numerosos constructores, cada uno con una combinación única de argumentos y una cantidad variable de esos parámetros se denomina sobrecarga de constructores. Nos permite utilizar una clase de forma diferente a como lo haríamos normalmente.

La sobrecarga de los constructores de una clase puede hacer que la misma clase actúe de manera diferente según el contexto. Cuando el objeto se inicializa primero, es posible que solo muestre un mensaje de texto básico.

Aún así, podría hacer algunos cálculos matemáticos cuando se inicializa por segunda vez con un argumento diferente. La sobrecarga de constructores en C# es posible, al igual que la sobrecarga de métodos en otros lenguajes de programación, y para hacer uso de la sobrecarga de constructores, dos o más constructores deben compartir el mismo nombre pero tener funciones distintas.

Formas de sobrecarga de constructores

La sobrecarga de constructores es posible que la llevemos a cabo de varias maneras, por ejemplo, con diferentes tipos de parámetros, diferente número de parámetros y diferente orden de parámetros.

Con diferentes tipos de parámetros

Para este procedimiento, diseñaremos dos constructores de teléfonos, cada uno de los cuales tendrá los mismos argumentos. En este caso, podemos generar constructores con los mismos argumentos ya que el tipo de datos incluidos dentro de los parámetros es diferente.

En la clase Phone, hemos construido dos constructores con el mismo nombre pero que toman tipos de datos distintos entre sí. El primer constructor acepta una cadena como argumento, mientras que el otro acepta números enteros.

class Phone {
  Phone(string pbrand) {
    Console.WriteLine("Phone Brand is: " + pbrand);
  }
  Phone(int pprice) {
    Console.WriteLine("Phone Price is: " + pprice);
  }

Hemos sobrecargado el constructor en el método principal con varios argumentos. En este caso, el Objeto p llama al constructor con un parámetro de tipo cadena, mientras que el Objeto p1 llama al constructor con un argumento de tipo int.

static void Main(string[] args) {
  Phone p = new Phone("iPhone x ");
  Console.WriteLine();

  Phone p1 = new Phone(10000);
  Console.ReadLine();
}
}

Código fuente completo:

using System;

namespace Shanii {
  class Phone {
    Phone(string pbrand) {
      Console.WriteLine("Phone Brand is: " + pbrand);
    }
    Phone(int pprice) {
      Console.WriteLine("Phone Price is: " + pprice);
    }

    static void Main(string[] args) {
      Phone p = new Phone("iPhone x ");
      Console.WriteLine();

      Phone p1 = new Phone(10000);
      Console.ReadLine();
    }
  }
}

Producción :

Phone Brand is: iPhone x
Phone Price is: 10000

Con diferentes números de parámetro

El siguiente ejemplo muestra que el constructor Teléfono tiene dos constructores, uno sin parámetros y otro con uno.

Creamos dos constructores de Teléfono con el mismo nombre en la clase Teléfono. Uno no requiere ningún parámetro, mientras que el otro requiere un parámetro.

class Phone {
  Phone() {
    Console.WriteLine("A Phone Constructor with no parameter");
  }
  Phone(string pbrand) {
    Console.WriteLine("A Phone constructor with one parameter");
    Console.WriteLine("Phone Brand: " + pbrand);
  }
}

Ahora que hemos creado constructores, los usaremos en la función Main() para llamar a sus respectivos métodos. Como puedes ver, ambos objetos p y p1 llaman a constructores con el mismo nombre.

El constructor relevante se invoca en función del valor del parámetro proporcionado al constructor.

static void Main(string[] args) {
  Phone p = new Phone();
  Console.WriteLine();

  Phone p1 = new Phone("Samsung S22 ultra");
  Console.ReadLine();
}

Código fuente completo:

using System;
namespace Shanii {

  class Phone {
    Phone() {
      Console.WriteLine("A Phone Constructor with no parameter");
    }
    Phone(string pbrand) {
      Console.WriteLine("A Phone constructor with one parameter");
      Console.WriteLine("Phone Brand: " + pbrand);
    }

    static void Main(string[] args) {
      Phone p = new Phone();
      Console.WriteLine();

      Phone p1 = new Phone("Samsung S22 ultra");
      Console.ReadLine();
    }
  }
}

Producción :

A Phone Constructor with no parameter

A Phone constructor with one parameter
Phone Brand: Samsung S22 ultra

Con diferente orden de parámetro

Aquí hay dos constructores diferentes, cada uno de los cuales tiene la misma cantidad de argumentos. Esto es factible porque el orden del tipo de datos en los parámetros puede tomar varias formas.

En el primer constructor de Teléfono, el tipo de datos de cadena viene antes que el tipo de datos int, mientras que en el segundo constructor de Teléfono, el tipo de datos int viene antes que el tipo de datos de cadena, lo que hace una diferencia entre ambos. los constructores de Teléfonos.

Phone(string pbrand, int pprice) {
  Console.WriteLine("Phone Brand: " + pbrand);
  Console.WriteLine("Phone Price: " + pprice);
}
Phone(int Andriodversion, string pbrand) {
  Console.WriteLine("Phone Andriod Version: " + Andriodversion);
  Console.WriteLine("Phone Brand: " + pbrand);
}

Hemos sobrecargado los constructores pasando los argumentos en varios ordenes en la función Main().

static void Main(string[] args) {
  Phone p = new Phone("Samsung Galaxy s22", 10000);
  Console.WriteLine();

  Phone p1 = new Phone(15, " iPhone 13 pro");
  Console.ReadLine();
}

Código fuente completo:

using System;
namespace Shanii {
  class Phone {
    Phone(string pbrand, int pprice) {
      Console.WriteLine("Phone Brand: " + pbrand);
      Console.WriteLine("Phone Price: " + pprice);
    }
    Phone(int Andriodversion, string pbrand) {
      Console.WriteLine("Phone Andriod Version: " + Andriodversion);
      Console.WriteLine("Phone Brand: " + pbrand);
    }
    static void Main(string[] args) {
      Phone p = new Phone("Samsung Galaxy s22", 10000);
      Console.WriteLine();

      Phone p1 = new Phone(15, " iPhone 13 pro");
      Console.ReadLine();
    }
  }
}

Producción :

Phone Brand: Samsung Galaxy s22
Phone Price: 10000

Phone Andriod Version: 15
Phone Brand:  iPhone 13 pro