C# | Diferencia entre constructores estáticos y constructores no estáticos – Part 1

Requisito previo: Constructores en C#

Los constructores estáticos se utilizan para inicializar los miembros estáticos de la clase y se les llama implícitamente antes de la creación de la primera instancia de la clase. Los constructores no estáticos se utilizan para inicializar los miembros no estáticos de la clase. A continuación se muestran las diferencias entre los constructores estáticos y los constructores no estáticos.

• Declaración: los constructores estáticos se declaran usando un modificador estático explícitamente, mientras que todos los demás constructores restantes son constructores no estáticos. Los constructores no estáticos también se pueden llamar constructores de instancias , ya que necesitan una instancia para ejecutarse.
  Ejemplo:

// C# Program to demonstrate
// how to declare the static
// constructor and non-static
// constructor
using System;
  
class Geeks{
    
// Static variable
static int s;
  
// Non-static variable
int ns;
  
// Declaration of
// static constructor
static Geeks()
{
    Console.WriteLine("It is static constructor");
}
  
// Declaration of
// non-static constructor
public Geeks()
{
    Console.WriteLine("It is non-static constructor");
}
  
// Main Method
static void Main(string[] args)
{
  
    // Static constructor will call implicitly
    // as soon as the class start to execute
    // the first block of code to execute
    // will be static constructor
  
    // Calling non-static constructor
    Geeks obj1 = new Geeks();
}
}

Producción:

It is static constructor
It is non-static constructor

• Llamadas: Los constructores estáticos siempre se llaman implícitamente, pero los constructores no estáticos se llaman explícitamente, es decir, creando la instancia de la clase.
  Ejemplo: en el programa anterior, tenemos un constructor estático, es decir, static Geeks(), que se llama implícitamente en el método principal. Vea la salida cuidadosamente, el código dentro del constructor estático se está ejecutando. Pero para llamar al constructor no estático, es decir , Geeks() , debe crear una instancia de la clase, es decir, obj1 . Entonces, la creación del objeto es llamar explícitamente al constructor no estático.
• Ejecución: el constructor estático se ejecuta tan pronto como comienza la ejecución de una clase y es el primer bloque de código que se ejecuta bajo una clase. Pero los constructores no estáticos se ejecutan solo después de la creación de la instancia de la clase. Cada vez que se crea la instancia de la clase, llamará al constructor no estático.
  Ejemplo:

// C# Program to demonstrate
// the execution of static
// constructor and non-static
// constructor
using System;
  
class Geeks{
  
// Declaration of
// static constructor
static Geeks()
{
    Console.WriteLine("Static constructor");
}
  
// Declaration of
// non-static constructor
public Geeks()
{
    Console.WriteLine("Non-Static constructor");
}
  
// Main Method
static void Main(string[] args)
{
  
    // static constructor will call implicitly
    // as soon as the class start to execute
    // the first block of code to execute
    // inside the class will be static
    // constructor
  
    // calling non-static constructor
    // here we are calling non-static
    // constructor twice as we are
    // creating two objects
    Geeks obj1 = new Geeks();
    Geeks obj2 = new Geeks();
}
}

Producción: 

Static constructor
Non-Static constructor
Non-Static constructor

• Explicación: En el programa anterior, se crean dos objetos de la clase Geeks() , es decir , obj1 y obj2 . obj1 y obj2 llamarán al constructor no estático dos veces porque cada vez que se crea la instancia de la clase, llamará al constructor no estático. Aunque, en el método Main (punto de entrada de un programa), la primera sentencia es “ Geeks obj1 = new Geeks(); ” pero tan pronto como el compilador encuentre el control del método principal, se transferirá a la clase y el bloque estático se ejecutará primero. Es por eso que puede ver en la salida que Static Constructor se llama primero.
• Tiempos de ejecución: un constructor estático siempre se ejecutará una vez en todo el ciclo de vida de una clase. Pero un constructor no estático puede ejecutar cero veces si no se crea ninguna instancia de la clase y n veces si se crean las n instancias.
  Ejemplo: en el programa anterior, puede ver que el constructor estático se ejecuta solo una vez, pero el constructor no estático se ejecuta 2 veces a medida que se crean las dos instancias de la clase. Si no va a crear una instancia de la clase, el constructor no estático no se ejecutará.
• Inicialización de campos: los constructores estáticos se utilizan para inicializar los campos estáticos y los constructores no estáticos se utilizan para inicializar los campos no estáticos.
  Ejemplo:

// C# Program to demonstrate
// initialization of fields
// by using static constructor
// and non-static constructor
using System;
  
class Geeks{
      
// Static variable
static int s;
  
// Non-static variable
int ns;
  
// Declaration of
// static constructor
static Geeks()
{
    Console.WriteLine("Static constructor");
}
  
// Declaration of
// non-static constructor
public Geeks()
{
    Console.WriteLine("Non-Static constructor");
}
  
// Main Method
static void Main(string[] args)
{
  
    // Static fields can
    // be accessed directly
    Console.WriteLine("Value of s is: " + s);
  
    // Calling non-static constructor
    Geeks obj1 = new Geeks();
  
    // Printing the value
    // of non-static field
    Console.WriteLine("Value of ns is: " + obj1.ns);
}
}

Producción: 

Static constructor
Value of s is: 0
Non-Static constructor
Value of ns is: 0

• Explicación: aquí, tanto los campos estáticos como los no estáticos se inicializan con el valor predeterminado. El valor predeterminado de tipo int es cero. El constructor estático inicializará solo campos estáticos. Aquí el campo estático es s . Mientras que el campo no estático ( ns ) es inicializado por el constructor no estático.
• Parámetros: no podemos pasar ningún parámetro a los constructores estáticos porque estos se llaman implícitamente y para pasar parámetros, tenemos que llamarlos explícitamente, lo que no es posible. Dará un error de tiempo de ejecución como se muestra en el siguiente ejemplo. Sin embargo, podemos pasar los parámetros a los constructores no estáticos.
  Ejemplo:

// C# Program to demonstrate
// the passing of parameters
// to constructor
using System;
  
class Geeks {
  
    // static variable
    static int s;
  
    // non-static variable
    int ns;
  
    // declaration of
    // static constructor
    // and passing parameter
    // to static constructor
    static Geeks(int k)
    {
  
        k = s;
        Console.WriteLine("Static constructor & K = " + k);
    }
  
    // declaration of
    // non-static constructor
    Geeks()
    {
        Console.WriteLine("Non-Static constructor");
    }
  
    // Main Method
    static void Main(string[] args)
    {
    }
}

Error de tiempo de ejecución:

prog.cs(18, 16): error CS0132: `Geeks.Geeks(int)’: El constructor estático no debe tener parámetros

• Sobrecarga: los constructores no estáticos pueden sobrecargarse, pero no los estáticos. La sobrecarga se realiza en los criterios de parámetros. Entonces, si no puede pasar los parámetros a los constructores estáticos, no podemos sobrecargarlo.
• Casos en los que el constructor será implícito: cada clase excepto la clase estática (que contiene solo miembros estáticos) siempre contiene un constructor implícito si el usuario no está definiendo un constructor explícito. Si la clase contiene campos estáticos, los constructores estáticos se definen implícitamente.