Compartir a través de

Clases estáticas y miembros de clase estática (Guía de programación de C#)

Una clase estática es básicamente la misma que una clase no estática, pero hay una diferencia: no se puede crear una instancia de una clase estática. En otras palabras, no puede usar el nuevo operador para crear una variable del tipo de clase. Dado que no hay ninguna variable de instancia, se accede a los miembros de una clase estática mediante el propio nombre de clase. Por ejemplo, si tiene una clase estática denominada UtilityClass que tiene un método estático público denominado MethodA, llame al método como se muestra en el ejemplo siguiente:

UtilityClass.MethodA();

Una clase estática se puede usar como un contenedor cómodo para conjuntos de métodos que solo operan en parámetros de entrada y no tienen que obtener ni establecer ningún campo de instancia interno. Por ejemplo, en la biblioteca de clases de .NET, la clase estática System.Math contiene métodos que realizan operaciones matemáticas, sin necesidad de almacenar ni recuperar datos que sean únicos para una instancia determinada de la Math clase. Es decir, aplicas los miembros de la clase especificando el nombre de la clase y el nombre del método, como se muestra en el ejemplo siguiente.

double dub = -3.14;
Console.WriteLine(Math.Abs(dub));
Console.WriteLine(Math.Floor(dub));
Console.WriteLine(Math.Round(Math.Abs(dub)));

// Output:
// 3.14
// -4
// 3

Como sucede con todos los tipos de clase, el entorno de ejecución de .NET carga la información de tipos de una clase estática cuando se carga el programa que hace referencia a la clase. El programa no puede especificar exactamente cuándo se carga la clase. Sin embargo, se garantiza que se carguen y tengan sus campos inicializados y su constructor estático llamado antes de que se haga referencia a la clase por primera vez en el programa. Un constructor estático solo se llama una vez y una clase estática permanece en memoria durante la vigencia del dominio de aplicación en el que reside el programa.

Nota:

Para crear una clase no estática que permita crear solo una instancia de sí misma, consulte Implementación de Singleton en C#.

En la lista siguiente se proporcionan las características principales de una clase estática:

La creación de una clase estática es básicamente la misma que la creación de una clase que contiene solo miembros estáticos y un constructor privado. Un constructor privado impide que se cree una instancia de la clase. La ventaja de usar una clase estática es que el compilador puede comprobar para asegurarse de que no se agregan accidentalmente miembros de instancia. El compilador garantiza que no se pueden crear instancias de esta clase.

Las clases estáticas están selladas y, por tanto, no se pueden heredar. No pueden heredar de ninguna clase o interfaz, excepto Object. Las clases estáticas no pueden contener un constructor de instancia. aunque sí un constructor estático. Las clases no estáticas también deben definir un constructor estático si la clase contiene miembros estáticos que requieren inicialización no trivial. Para obtener más información, vea Constructores estáticos.

Ejemplo

Este es un ejemplo de una clase estática que contiene dos métodos que convierten la temperatura de Celsius a Fahrenheit y de Fahrenheit a Celsius:

public static class TemperatureConverter
{
    public static double CelsiusToFahrenheit(string temperatureCelsius)
    {
        // Convert argument to double for calculations.
        double celsius = Double.Parse(temperatureCelsius);

        // Convert Celsius to Fahrenheit.
        double fahrenheit = (celsius * 9 / 5) + 32;

        return fahrenheit;
    }

    public static double FahrenheitToCelsius(string temperatureFahrenheit)
    {
        // Convert argument to double for calculations.
        double fahrenheit = Double.Parse(temperatureFahrenheit);

        // Convert Fahrenheit to Celsius.
        double celsius = (fahrenheit - 32) * 5 / 9;

        return celsius;
    }
}

class TestTemperatureConverter
{
    static void Main()
    {
        Console.WriteLine("Please select the convertor direction");
        Console.WriteLine("1. From Celsius to Fahrenheit.");
        Console.WriteLine("2. From Fahrenheit to Celsius.");
        Console.Write(":");

        string? selection = Console.ReadLine();
        double F, C = 0;

        switch (selection)
        {
            case "1":
                Console.Write("Please enter the Celsius temperature: ");
                F = TemperatureConverter.CelsiusToFahrenheit(Console.ReadLine() ?? "0");
                Console.WriteLine($"Temperature in Fahrenheit: {F:F2}");
                break;

            case "2":
                Console.Write("Please enter the Fahrenheit temperature: ");
                C = TemperatureConverter.FahrenheitToCelsius(Console.ReadLine() ?? "0");
                Console.WriteLine($"Temperature in Celsius: {C:F2}");
                break;

            default:
                Console.WriteLine("Please select a convertor.");
                break;
        }

        // Keep the console window open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}
/* Example Output:
    Please select the convertor direction
    1. From Celsius to Fahrenheit.
    2. From Fahrenheit to Celsius.
    :2
    Please enter the Fahrenheit temperature: 20
    Temperature in Celsius: -6.67
    Press any key to exit.
 */

Miembros estáticos

Una clase no estática puede contener métodos estáticos, campos, propiedades o eventos. El miembro estático se puede llamar en una clase incluso cuando no existe ninguna instancia de la clase. El nombre de la clase siempre tiene acceso al miembro estático, no al nombre de la instancia. Solo existe una copia de un miembro estático, independientemente de cuántas instancias de la clase se creen. Los métodos y propiedades estáticos no pueden tener acceso a campos y eventos no estáticos en su tipo contenedor y no pueden tener acceso a una variable de instancia de ningún objeto a menos que se pase explícitamente en un parámetro de método.

Es más habitual declarar una clase no estática con algunos miembros estáticos, que declarar una clase completa como estática. Dos usos comunes de campos estáticos son mantener un recuento del número de objetos que se crean instancias o para almacenar un valor que se debe compartir entre todas las instancias.

Los métodos estáticos se pueden sobrecargar pero no invalidar, ya que pertenecen a la clase y no a ninguna instancia de la clase .

Aunque un campo no se puede declarar como static const, un campo const es esencialmente estático en su comportamiento. Pertenece al tipo , no a instancias del tipo . Por lo tanto, se puede acceder a const campos mediante la misma notación de ClassName.MemberName usada para los campos estáticos. No se requiere ninguna instancia de objeto.

C# no admite variables locales estáticas (es decir, variables declaradas en el ámbito del método).

Los miembros de clase estática se declaran mediante la palabra clave static antes del tipo de valor devuelto del miembro, como se muestra en el ejemplo siguiente:

public class Automobile
{
    public static int NumberOfWheels = 4;

    public static int SizeOfGasTank
    {
        get
        {
            return 15;
        }
    }

    public static void Drive() { }

    public static event EventType? RunOutOfGas;

    // Other non-static fields and properties...
}

Los miembros estáticos se inicializan antes de que se acceda al miembro estático por primera vez y antes del constructor estático, si hay uno, se llama a . Para acceder a un miembro de clase estática, use el nombre de la clase en lugar de un nombre de variable para especificar la ubicación del miembro, como se muestra en el ejemplo siguiente:

Automobile.Drive();
int i = Automobile.NumberOfWheels;

Si la clase contiene campos estáticos, proporcione un constructor estático que los inicialice cuando se cargue la clase.

Una llamada a un método estático genera una instrucción de llamada en lenguaje intermedio común (CIL), mientras que una llamada a un método de instancia genera una instrucción callvirt, que también comprueba si hay referencias de objeto null. Sin embargo, la mayoría de las veces la diferencia de rendimiento entre los dos no es significativa.

Especificación del lenguaje C#

Para obtener más información, vea Clases estáticas, miembros estáticos y de instancia y constructores estáticos en 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