Compartir a través de

static (Referencia de C#)

  • Artículo

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

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

Puede agregar el static modificador a una función local. Una función local estática no puede capturar variables locales ni estado de instancia.

class Calc1
{
    public void CalculateSum()
    {
        int a = 3;
        int b = 7;

        // Static local function - cannot access 'a' or 'b' directly
        static int Add(int x, int y)
        {
            return x + y;
        }

        int result = Add(a, b); 
        Console.WriteLine($"Sum: {result}");
    }
}
  /*
 Output:
 Sum: 10
 */

Puede agregar el static modificador a una expresión lambda o a un método anónimo. Un método lambda estático o anónimo no puede capturar variables locales ni estado de instancia.

class Calc2
{
    static void Main()
    {
        Func<int, int, int> add = static (a, b) => a + b;

        int result = add(5, 10);
        Console.WriteLine($"Sum: {result}");
    }
}
/*
Output:
Sum: 15
*/

Ejemplo: clase estática

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

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 static miembro a través de 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 staticx, use el nombre completo, MyBaseC.MyStruct.x, a menos que el miembro sea accesible desde el mismo ámbito:

Console.WriteLine(MyBaseC.MyStruct.x);

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

No es posible usar this para hacer referencia a métodos o accesores de propiedad de static.

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

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

Nota:

La static palabra clave tiene más usos limitados que en C++. Para comparar con la palabra clave de C++, consulte 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 para contar 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, En su lugar, 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 el contador de empleados por uno y se muestra la información del nuevo empleado y el nuevo número de empleados. Este programa lee el número actual de empleados del 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 puede inicializar un static campo mediante otro static campo que aún no se ha declarado. Los resultados no se definirán hasta que asigne explícitamente un valor al static campo.

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 el origen definitivo de la sintaxis y el uso de C#.

Consulte también