0Pricing
C# Academy · Lección

Constructores estáticos

Inicialice el estado estático exactamente una vez.

Constructores estáticos es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C# Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C# Academy incluye 4 lecciones en total.

¿Qué es un constructor estático?

Un constructor estático inicializa los datos estáticos de una clase. Se ejecuta automáticamente una vez, antes de que la clase se use por primera vez, y nunca se llama directamente.

using System;

class App
{
    public static string Version;

    static App()
    {
        Version = "1.0.0";
        Console.WriteLine("Static constructor ran");
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine(App.Version);
    }
}

Reglas de sintaxis

Un constructor estático usa la palabra clave static, tiene el nombre de la clase, no recibe parámetros y no tiene modificador de acceso.

using System;

class Config
{
    public static int MaxUsers;

    static Config()
    {
        MaxUsers = 100;
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine("Max: " + Config.MaxUsers);
    }
}

Se ejecuta exactamente una vez

Sin importar cuántas veces use la clase, el constructor estático se ejecuta una sola vez, la primera vez que se necesita.

using System;

class Counter
{
    public static int Instances;

    static Counter()
    {
        Console.WriteLine("Initializing static state");
        Instances = 0;
    }

    public Counter() { Instances++; }
}

class Program
{
    static void Main()
    {
        new Counter();
        new Counter();
        Console.WriteLine("Instances: " + Counter.Instances);
    }
}

¿Cuándo se activa?

El entorno de ejecución lo llama justo antes del primer acceso a cualquier miembro estático O de la primera creación de una instancia, lo que ocurra primero.

using System;

class Lazy
{
    public static string Data;

    static Lazy()
    {
        Console.WriteLine("Triggered now");
        Data = "ready";
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine("Before access");
        Console.WriteLine(Lazy.Data);
    }
}

Inicialización de datos estáticos complejos

Use un constructor estático cuando los campos estáticos necesiten una lógica real de configuración, no solo literales sencillos.

using System;
using System.Collections.Generic;

class Lookup
{
    public static Dictionary<int, string> Table;

    static Lookup()
    {
        Table = new Dictionary<int, string>();
        for (int i = 1; i <= 3; i++)
            Table[i] = "Item" + i;
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Lookup.Table[2]);
    }
}

Constructor estático frente a inicializador de campo

Puede usar inicializadores en línea para valores sencillos. Un constructor estático es adecuado para configuraciones que necesitan instrucciones, bucles o gestión de errores.

using System;

class Settings
{
    public static int Simple = 10;        // inline initializer
    public static int Computed;            // needs logic

    static Settings()
    {
        Computed = Simple * Simple;
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Settings.Simple + ", " + Settings.Computed);
    }
}

No se permiten parámetros

Como el entorno de ejecución lo llama por usted, un constructor estático no puede aceptar argumentos. Todas sus entradas deben ser otros datos estáticos o constantes.

using System;

class Clock
{
    public static int StartHour;

    static Clock()
    {
        StartHour = 9;
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine("Start: " + Clock.StartHour);
    }
}

Combinación de constructores estáticos y de instancia

Una clase puede tener ambos. El estático se ejecuta una vez para el tipo; el de instancia se ejecuta para cada objeto.

using System;

class Game
{
    public static string Title;
    public int Score;

    static Game()
    {
        Title = "Coddy Quest";
    }

    public Game(int score)
    {
        Score = score;
    }
}

class Program
{
    static void Main()
    {
        var g = new Game(50);
        Console.WriteLine(Game.Title + " score " + g.Score);
    }
}

Garantía de orden

Se garantiza que el constructor estático finaliza antes de que se ejecute cualquier cuerpo de constructor de instancia que lo active, por lo que el estado estático siempre está listo.

using System;

class Service
{
    public static string Endpoint;

    static Service()
    {
        Endpoint = "https://api.example.com";
    }

    public Service()
    {
        Console.WriteLine("Using " + Endpoint);
    }
}

class Program
{
    static void Main()
    {
        new Service();
    }
}

Úselos con moderación

Los constructores estáticos añaden una comprobación única antes de usar la clase y pueden perjudicar el rendimiento si se usan en exceso o si producen una excepción. Manténgalos pequeños y fiables.

using System;

class Cache
{
    public static int[] Data;

    static Cache()
    {
        Data = new int[] { 2, 4, 6, 8 };
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Cache.Data[3]);
    }
}

Integración

Los constructores estáticos son ideales para configurar una sola vez datos compartidos de solo lectura, como tablas de búsqueda o configuraciones cargadas a partir de constantes.

using System;
using System.Collections.Generic;

class Currency
{
    public static Dictionary<string, string> Symbols;

    static Currency()
    {
        Symbols = new Dictionary<string, string>
        {
            ["USD"] = "$",
            ["EUR"] = "E",
            ["JPY"] = "Y"
        };
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine("USD symbol: " + Currency.Symbols["USD"]);
    }
}

Comprobación rápida

Compruebe cuánto comprende sobre los constructores estáticos.

Recapitulación

Un constructor estático usa static ClassName(), no tiene parámetros ni modificador de acceso. Se ejecuta una vez, automáticamente, antes de que la clase se use por primera vez, para inicializar el estado estático que necesita una lógica real. Úselo con moderación para configuraciones únicas de datos compartidos.

using System;

class Demo
{
    public static int Value;
    static Demo() { Value = 42; }
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Demo.Value);
    }
}

Preguntas frecuentes

¿La lección «Constructores estáticos» es gratis?

Sí — el texto completo de «Constructores estáticos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C# Academy, actualiza a CoddyKit PRO. El curso de C# Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Constructores estáticos»?

Inicialice el estado estático exactamente una vez. Practicas C# Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C# Academy?

No se requiere experiencia previa. C# Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Constructores estáticos»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C# Academy?

Sí. Cada lección de C# Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Definición de constructores
  2. Encadenamiento de constructores con this
  3. Inicializadores de objetos y colecciones
  4. Constructores estáticos
← Volver a C# Academy