Palabra clave static en C#: Dominando variables, métodos y clases estáticas

Palabra clave static en C#

Esta guía explica la palabra clave static en C#, cubriendo variables estáticas, métodos y clases con ejemplos claros y reales.

En C#, aplicar la palabra clave static a un miembro crea una única instancia compartida para todos los objetos de ese tipo. En lugar de que cada instancia tenga su propia copia, el miembro estático vive una vez por tipo.

---

Variables estáticas en C#

Cuando un campo se declara static, puedes acceder a él directamente a través del nombre de la clase, sin crear un objeto.

using System;
namespace StaticKeyword {
    class Student {
        // variable estática compartida por todos los estudiantes
        public static string department = "Computer Science";
    }
    class Program {
        static void Main(string[] args) {
            // Accede al campo estático vía el nombre de la clase
            Console.WriteLine("Department: " + Student.department);
            Console.ReadLine();
        }
    }
}

Salida

Department: Computer Science

El campo department es compartido por cada instancia de Student, así que lo referenciamos como Student.department.

---

Variables estáticas vs. variables de instancia

Las variables de instancia pertenecen a objetos individuales, cada uno con su propia copia. Por ejemplo:

class Student {
    public string studentName;
}
class Program {
    static void Main(string[] args) {
        Student s1 = new Student();
        Student s2 = new Student();
    }
}

Aquí, s1 y s2 tienen campos studentName separados. En contraste, un campo estático es común a todas las instancias y puede accederse sin crear un objeto.

Ejemplo: Variables estáticas vs. de instancia

using System;
namespace StaticKeyword {
    class Student {
        public static string schoolName = "Programiz School"; // compartido
        public string studentName; // único
    }
    class Program {
        static void Main(string[] args) {
            Student s1 = new Student();
            s1.studentName = "Ram";
            Console.WriteLine("Name: " + s1.studentName); // instancia
            Console.WriteLine("School: " + Student.schoolName); // estático
            Student s2 = new Student();
            s2.studentName = "Shyam";
            Console.WriteLine("Name: " + s2.studentName);
            Console.WriteLine("School: " + Student.schoolName);
            Console.ReadLine();
        }
    }
}

Salida

Name: Ram
School: Programiz School
Name: Shyam
School: Programiz School

El campo estático schoolName es idéntico para todos los estudiantes, haciéndolo eficiente en memoria y lógicamente consistente.

---

Métodos estáticos en C#

Los métodos estáticos se invocan en la clase misma, no en una instancia. Solo pueden acceder a otros miembros estáticos.

class Test {
    public static void Display() {
        // implementación
    }
}
class Program {
    static void Main(string[] args) {
        Test.Display();
    }
}

Todos los objetos de Test comparten el mismo método Display, así que lo llamas vía el nombre de la clase.

Ejemplo: Métodos estáticos y no estáticos

using System;
namespace StaticKeyword {
    class Test {
        public void Display1() {
            Console.WriteLine("Non static method");
        }
        public static void Display2() {
            Console.WriteLine("Static method");
        }
    }
    class Program {
        static void Main(string[] args) {
            Test t1 = new Test();
            t1.Display1(); // llamada de instancia
            Test.Display2(); // llamada estática
            Console.ReadLine();
        }
    }
}

Salida

Non static method
Static method

Nota: El método Main en sí es estático, permitiéndole ejecutarse sin una instancia.

---

Clases estáticas

Una clase estática no puede ser instanciada y solo puede contener miembros estáticos. Es útil para agrupar métodos auxiliares.

using System;
namespace StaticKeyword {
    static class Test {
        static int a = 5;
        static void Display() {
            Console.WriteLine("Static method");
        }
        static void Main(string[] args) {
            // Test t1 = new Test(); // ❌ Error de compilación
            Console.WriteLine(a);
            Display();
        }
    }
}

Intentar instanciar Test resulta en errores de compilación CS0723 y CS0712, confirmando su naturaleza estática.

Las clases estáticas no pueden ser heredadas. Por ejemplo:

static class A { /* ... */ }
// class B : A { /* ... */ } // ❌ Error

---

Accediendo a miembros estáticos dentro de la clase

Dentro de la misma clase, puedes referirte a campos y métodos estáticos directamente, sin el calificador de clase.

using System;
namespace StaticKeyword {
    class Test {
        static int age = 25;
        public static void Display() {
            Console.WriteLine("Static method");
        }
        static void Main(string[] args) {
            Console.WriteLine(age); // acceso directo
            Display(); // acceso directo
            Console.ReadLine();
        }
    }
}

Salida

25
Static method

Aquí, age y Display se usan sin prefijarlos con Test..