static en C#: clases, métodos, campos y constructores static

static marca un miembro que pertenece al tipo, no a un objeto. Un campo de instancia existe una vez por objeto; un campo static existe una vez y punto. Un método de instancia se ejecuta sobre un objeto (order.Ship()); un método static se ejecuta sobre el tipo (Math.Round(x)) y no necesita ningún objeto.

Campos static: una copia, compartida

La forma más clara de ver la diferencia es un contador. Cada Order tiene su propio Id, pero el número de pedidos creados hasta el momento tiene que vivir en algún sitio compartido.

using System;

class Order
{
    private static int created;   // one copy for the whole program
    public int Id { get; }        // one copy per order
    public string Customer { get; }

    public Order(string customer)
    {
        created++;
        Id = created;
        Customer = customer;
    }

    public static int Created => created;
}

class Program
{
    static void Main()
    {
        var a = new Order("Ana");
        var b = new Order("Ben");
        var c = new Order("Chen");

        Console.WriteLine($"{a.Customer} #{a.Id}, {b.Customer} #{b.Id}, {c.Customer} #{c.Id}");
        Console.WriteLine($"Orders created: {Order.Created}");
    }
}

Salida:

Ana #1, Ben #2, Chen #3
Orders created: 3

A los miembros static se accede a través del nombre del tipo: Order.Created, no a.Created. C# no permite llegar a un miembro static a través de una instancia (error CS0176), lo que deja claro en el punto de llamada que el valor es compartido.

Métodos static

Un método static no tiene this. Solo trabaja con sus parámetros y con otros miembros static. Eso lo convierte en la forma natural de los métodos auxiliares que calculan algo a partir de sus entradas:

using System;

class Pricing
{
    public static decimal WithVat(decimal net, decimal rate) => Math.Round(net * (1 + rate), 2);

    public static string Format(decimal amount) => amount.ToString("0.00") + " EUR";
}

class Program
{
    static void Main()
    {
        decimal gross = Pricing.WithVat(49.90m, 0.23m);
        Console.WriteLine(Pricing.Format(gross));
        Console.WriteLine(Math.Max(3, 7)); // Math is full of static methods
    }
}

Salida:

61.38 EUR
7

El propio Main es static: el runtime lo llama antes de que exista ningún objeto.

El error CS0120: código static que usa miembros de instancia

Como Main es static, los principiantes suelen encontrarse este error en cuanto añaden un segundo método:

class Program
{
    int visits;
    void Greet() { Console.WriteLine("Hello"); }

    static void Main()
    {
        Greet();    // error CS0120: An object reference is required for the non-static field, method, or property 'Program.Greet()'
        visits++;   // error CS0120: An object reference is required for the non-static field, method, or property 'Program.visits'
    }
}

Un método static no tiene objeto, así que no hay ningún visits que incrementar. Hay dos soluciones, y la correcta depende de lo que sea el miembro:

• El miembro es de verdad un dato de cada objeto: crea un objeto y úsalo. var app = new Program(); app.Greet();
• El miembro no necesita estado de objeto: márcalo como static. static void Greet() { ... }

Marcar todo como static para que desaparezca el error funciona en un programa diminuto y se convierte en estado global en uno real. Decide preguntándote si el dato pertenece a un objeto o a todo el programa.

La dirección contraria siempre está permitida: los métodos de instancia pueden llamar libremente a los miembros static.

Clases static

Una clase declarada static solo puede contener miembros static y nunca puede instanciarse. Es un grupo con nombre de funciones y constantes.

using System;

static class Temperature
{
    public const decimal FreezingC = 0m;

    public static decimal ToFahrenheit(decimal c) => c * 9 / 5 + 32;
    public static decimal ToCelsius(decimal f) => (f - 32) * 5 / 9;
    public static bool IsFreezing(decimal c) => c <= FreezingC;
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Temperature.ToFahrenheit(25m));
        Console.WriteLine(Temperature.ToCelsius(212m));
        Console.WriteLine(Temperature.IsFreezing(-3m));
        // var t = new Temperature(); // error CS0712: Cannot create an instance of the static class 'Temperature'
    }
}

Salida:

77
100
True

El compilador hace cumplir el contrato: un miembro de instancia dentro de una clase static es el error CS0708, y new sobre ella es el error CS0712. Math, Console, File, Path y Enumerable son todas clases static. Los métodos de extensión también deben vivir en una clase static.

Constructores static y static readonly

Un campo static cuyo valor necesita más de una expresión puede asignarse en un constructor static, que el runtime ejecuta una vez, antes de que el tipo se use por primera vez:

using System;
using System.Collections.Generic;

class ShippingRates
{
    public static readonly IReadOnlyDictionary<string, decimal> ByCountry;
    public static readonly DateTime LoadedOn = new DateTime(2026, 1, 1);

    static ShippingRates()
    {
        Console.WriteLine("ShippingRates initialized");
        ByCountry = new Dictionary<string, decimal> { ["PT"] = 4.90m, ["ES"] = 5.50m, ["FR"] = 6.20m };
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine("Before first use");
        Console.WriteLine(ShippingRates.ByCountry["ES"]);
        Console.WriteLine(ShippingRates.ByCountry.Count);
        Console.WriteLine(ShippingRates.LoadedOn.ToString("yyyy-MM-dd"));
    }
}

Salida:

Before first use
ShippingRates initialized
5.50
3
2026-01-01

readonly significa que el campo solo puede asignarse en su inicializador o en el constructor static. Después no puede reasignarse, aunque el objeto al que apunta aún podría ser mutable, y por eso el diccionario se expone como IReadOnlyDictionary.

const frente a static readonly

Los dos te dan un valor con nombre compartido por todo el programa, y se diferencian en cuándo se fija el valor:

La fila de la copia importa en las bibliotecas: si el ensamblado A declara public const int MaxItems = 50; y el ensamblado B lo usa, B contiene el literal 50. Cambiar A a 100 no hace nada en B hasta que B se recompila. Para valores que pueden cambiar entre versiones, prefiere static readonly.

using static

Una directiva using static (C# 6) importa los miembros static de un tipo, para que puedas llamarlos sin el nombre del tipo:

using System;
using static System.Math;
using static System.Console;

class Program
{
    static void Main()
    {
        double radius = 3;
        double area = PI * Pow(radius, 2);
        WriteLine($"Area: {area:F2}");
        WriteLine(Max(12, 40));
    }
}

Salida:

Area: 28.27
40

Se lee bien en código con muchas matemáticas. En otros casos, úsala con moderación: un WriteLine o un Parse sueltos ocultan de qué tipo viene el método.

Estado static e hilos

Un campo static lo comparten todos los hilos del proceso. Incrementarlo desde varios hilos a la vez pierde actualizaciones, porque created++ es una lectura, una suma y una escritura, y dos hilos pueden intercalarlas. Usa Interlocked.Increment(ref created) para los contadores, o un lock para cualquier cosa más grande. Las aplicaciones web son el sitio habitual donde esto muerde: cada petición se ejecuta en algún hilo, así que un campo static que guarde "el usuario actual" lo comparten todos los usuarios.

Un detalle más: en una clase genérica, cada tipo construido tiene sus propios campos static. Cache<int>.Count y Cache<string>.Count son dos campos distintos.

Cuándo usar static

Buenos usos:

• Métodos auxiliares puros que calculan un resultado a partir de sus argumentos: formato, conversiones, validación.
• Constantes y datos de consulta de solo lectura compartidos por el programa.
• Métodos de fábrica, como TimeSpan.FromMinutes(5) o tu propio Temperature.FromCelsius(21).
• Métodos de extensión.

Malos usos:

• Estado global mutable (el usuario actual, un carrito de la compra, una configuración que cambia). Acopla todo el código que lo toca y hace que las pruebas dependan de lo que dejaron las demás.
• Todo lo que vayas a querer sustituir en las pruebas, como un reloj, una base de datos o un servicio de envío de correo. Las llamadas static no pueden sustituirse por una falsa; una instancia pasada al constructor sí.