static (Referencia de C#)

En esta página se trata la palabra clave del modificador static. La palabra clave static también forma parte de la directiva using static.

Use el modificador static para declarar un miembro estático, que pertenece al propio tipo en lugar de a un objeto específico. El modificador static se puede usar para declarar clases static. En las clases, las interfaces y las estructuras, puede agregar el modificador static a los campos, los métodos, las propiedades, los operadores, los eventos y los constructores. El modificador static no se puede usar con indizadores ni finalizadores. Para más información, vea Clases estáticas y sus miembros.

A partir de C# 8,0, puede agregar el modificador static a una función local. Una función local estática no puede capturar variables locales o el estado de la instancia.

A partir de C# 9.0, puede agregar el modificador static a una expresión lambda o un método anónimo. Una expresión lambda o un método anónimo estático no pueden capturar variables locales o el estado de la instancia.

Ejemplo: clase estática

La siguiente clase se declara como static y contiene solo métodos static:

static class CompanyEmployee
{
    public static void DoSomething() { /*...*/ }
    public static void DoSomethingElse() { /*...*/  }
}

Una declaración de constantes o tipos es implícitamente un miembro static. No se puede hacer referencia a un miembro static mediante una instancia, sino que se hace a través del nombre de tipo. Por ejemplo, considere la siguiente clase:

public class MyBaseC
{
    public struct MyStruct
    {
        public static int x = 100;
    }
}

Para hacer referencia al miembro static x, use el nombre completo, MyBaseC.MyStruct.x, a menos que el miembro sea accesible desde el mismo ámbito:

Console.WriteLine(MyBaseC.MyStruct.x);

Mientras que una instancia de una clase contiene una copia independiente de todos los campos de instancia de la clase, solo hay una copia de cada campo static.

No se puede usar this para hacer referencia a métodos static o descriptores de acceso de propiedades.

Si la palabra clave static se aplica a una clase, todos los miembros de esta deben ser static.

Las clases, las interfaces y las clases static pueden tener constructores static. Se llama a un constructor static en algún momento entre el inicio del programa y la creación de una instancia de la clase.

Nota

La palabra clave static tiene usos más limitados que en C++. Para ver una comparación con la palabra clave de C++, vea Clases de almacenamiento (C++).

Para mostrar miembros static, es recomendable una clase que represente al empleado de una empresa. Supongamos que la clase contiene un método de recuento de empleados y un campo para almacenar el número de empleados. El método y el campo no pertenecen a ninguna instancia de ningún empleado, sino que pertenecen a la clase de empleados en su conjunto. Se deben declarar como miembros static de la clase.

Ejemplo: campo estático y método

En este ejemplo se lee el nombre y el identificador de un nuevo empleado, se incrementa en uno el recuento de empleados y se muestra la información del nuevo empleado, así como el nuevo número de empleados. Este programa lee el número actual de empleados desde el teclado.

public class Employee4
{
    public string id;
    public string name;

    public Employee4()
    {
    }

    public Employee4(string name, string id)
    {
        this.name = name;
        this.id = id;
    }

    public static int employeeCounter;

    public static int AddEmployee()
    {
        return ++employeeCounter;
    }
}

class MainClass : Employee4
{
    static void Main()
    {
        Console.Write("Enter the employee's name: ");
        string name = Console.ReadLine();
        Console.Write("Enter the employee's ID: ");
        string id = Console.ReadLine();

        // Create and configure the employee object.
        Employee4 e = new Employee4(name, id);
        Console.Write("Enter the current number of employees: ");
        string n = Console.ReadLine();
        Employee4.employeeCounter = Int32.Parse(n);
        Employee4.AddEmployee();

        // Display the new information.
        Console.WriteLine($"Name: {e.name}");
        Console.WriteLine($"ID:   {e.id}");
        Console.WriteLine($"New Number of Employees: {Employee4.employeeCounter}");
    }
}
/*
Input:
Matthias Berndt
AF643G
15
 *
Sample Output:
Enter the employee's name: Matthias Berndt
Enter the employee's ID: AF643G
Enter the current number of employees: 15
Name: Matthias Berndt
ID:   AF643G
New Number of Employees: 16
*/

Ejemplo: inicialización estática

En este ejemplo se muestra que se puede inicializar un campo static mediante otro campo static que aún no se ha declarado. Los resultados están sin definir hasta que se asigna explícitamente un valor al campo static.

class Test
{
    static int x = y;
    static int y = 5;

    static void Main()
    {
        Console.WriteLine(Test.x);
        Console.WriteLine(Test.y);

        Test.x = 99;
        Console.WriteLine(Test.x);
    }
}
/*
Output:
    0
    5
    99
*/

Especificación del lenguaje C#

Para obtener más información, consulte la Especificación del lenguaje C#. La especificación del lenguaje es la fuente definitiva de la sintaxis y el uso de C#.

Consulte también