Constructor C#

En este artículo, aprenderemos:

¿Qué es un constructor?

El constructor de C# se invoca en el momento de la creación del objeto. Construye los valores, es decir, proporciona datos para el objeto, por eso se le conoce como constructor.

Un constructor es un método especial que se utiliza para inicializar un objeto. Cada clase tiene un constructor, si no declaramos explícitamente un constructor para cualquier clase de C#, el compilador crea un constructor predeterminado para esa clase. Un constructor no tiene ningún tipo de retorno. Los constructores son responsables de la inicialización de objetos y la asignación de memoria de su clase.

¿Reglas para crear Constructor?

Hay básicamente dos reglas definidas para el constructor.

1. El nombre del constructor debe ser el mismo que su nombre de clase
2. El constructor no debe tener un tipo de retorno explícito

Tipo de Constructores:

Hay dos tipos de constructores:

1. Constructor predeterminado (constructor sin argumentos)
2. Constructor parametrizado

Constructor predeterminado de C#:

Un constructor que no tiene parámetros se conoce como constructor por defecto.

Ejemplo:

using System; 
Class Student{
 int roll; float marks;
 public Student() //constructor
{ 
 roll=0; 
 marks=0.0; 
 }
 // other members 
}

 Student obj1 = new Student();

Constructor parametrizado de C#:

Class Student 
{ 
int roll; 
float marks;
public Student(int a, float b)//constructor
{ 
 roll = a; 
 marks = b; 
 } 
//other members
 }

 Student obj = new Student( 17 , 58.08F);

Sobrecarga del constructor:

Al igual que los métodos, un constructor también puede sobrecargarse. Los constructores sobrecargados se diferencian en función de su tipo de parámetros o número de parámetros. La sobrecarga de constructores no es muy diferente a la sobrecarga de métodos. En caso de sobrecarga de métodos, tiene varios métodos con el mismo nombre pero firma diferente, mientras que en la sobrecarga de Constructor tiene varios constructores con firma diferente, pero la única diferencia es que Constructor no tiene tipo de retorno en C#.

using System; 
public Class OverloadStudent 
{ 
public OverloadStudent () 
{ 
//Default constructor 
} 
public OverloadStudent (int age) 
{ 
//Single parameter constructor 
} 
public OverloadStudent (int age, string name) 
{ 
//two parameter constructor 
} 
} 

OverloadStudent obj=new OverloadStudent() ; //Default constructor will get called
OverloadStudent obj=new OverloadStudent(43) ; //Single parameter constructor will get called
OverloadStudent obj=new OverloadStudent(47,"Steve") ; //Two parameters constructor will get called

Diferencia entre el constructor de C# y los métodos de C#:

Constructor estático:

El constructor estático es un constructor especial que se llama antes de que se cree el primer objeto de la clase. Se utiliza para inicializar cualquier dato estático o para realizar una acción particular que debe realizarse una sola vez.
Se desconoce el momento de ejecución del constructor estático, pero definitivamente es antes de la creación del primer objeto; puede ser en ese momento. de montaje de carga.

//Example1
using System;
public Class Student
 {
 static Student() 
{ 
// initialize static members only.
 }
 // other methods here.
 }
// Example2
using System;
public class MyStaticClass 
{ 
static int count; 
static MyStaticClass() 
{ 
count = 0; 
Console.WriteLine("Static class is initialized"); 
} 
public static void MyMethod(string name) 
{ 
Console.WriteLine("Static class is initialized " + name); 
} 
}
MyStaticClass.MyMethod("Steve") ; //method call
//constructor will be called automatically

Output:
Static class is initialized Hello Steve

Reglas para constructor estático:

• Una clase solo puede tener un constructor estático
• El constructor estático no puede tener ningún parámetro
• El constructor estático no puede tener ningún especificador de acceso
• Se utiliza para inicializar los miembros de datos estáticos de la clase
• para cualquier cantidad de creación de objetos, el constructor estático se ejecuta solo una vez
• El constructor estático se ejecuta cuando se usa la clase
• El programador no puede invocar explícitamente al constructor estático

Podemos tener 2 constructores.

using System; 
public Class question {
 static Students()
 { 
//initialize static member only.
 } 
public Students() 
{ 
// codes for the first derive class constructor. 
 }
 } 

Constructor privado:

Un constructor privado es un constructor de instancia especial que se usa en una clase que solo contiene miembros estáticos.
Si una clase tiene uno o más constructores privados y ningún constructor público, entonces otras clases no pueden crear instancias de esta clase.

using System; 
public Class Student{
private Student() 
{ 
 Console.WriteLine("This is no parameter private constructor");
 }
 public Student(int a):this() 
{ 
Console.WriteLine("This is one parameter public constructor");
 }
 // other methods
 }

 Student obj = new Student(20) ; //it will work fine.

 Student obj = new Student() ; // error of inaccessibility will be occur.

Reglas para constructores privados:

• un uso del constructor privado es cuando solo tenemos un miembro estático.
• Proporciona la implementación del patrón de clase singleton
• Una vez que proporcionemos el constructor (privado/público/cualquiera), el compilador no agregará el constructor público sin parámetros a ninguna clase.