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 para 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. No obstante, existe la garantía de que se cargará, sus campos se inicializarán y se llamará a su constructor estático antes de que se haga referencia a la clase por primera vez en el programa. Solo se llama una vez a un constructor estático, 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#.

La siguiente lista contiene las características principales de una clase estática:

  • Solo contiene miembros estáticos.

  • No se pueden crear instancias de ella.

  • Está sellada.

  • No puede contener constructores de instancia.

Por lo tanto, crear una clase estática es básicamente lo mismo que crear una clase que contiene solo miembros estáticos y un constructor privado. Un constructor privado impide que se creen instancias de la clase. La ventaja de usar una clase estática es que el compilador puede comprobar que no se agregue accidentalmente ningún miembro de instancia. El compilador garantiza que no se creen instancias de esta clase.

Las clases estáticas están selladas y, por lo tanto, no pueden heredarse. 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

A continuación, se muestra un ejemplo de una clase estática que contiene dos métodos que convierten la temperatura de grados Celsius a grados Fahrenheit y viceversa:

public static class TemperatureConverter
{
    public static double CelsiusToFahrenheit(string temperatureCelsius) =>
        double.Parse(temperatureCelsius) * 9 / 5 + 32;

    public static double FahrenheitToCelsius(string temperatureFahrenheit) =>
        (double.Parse(temperatureFahrenheit) - 32) * 5 / 9;
}

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();

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

            case "2":
                Console.Write("Please enter the Fahrenheit temperature: ");
                var 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 es invocable en una clase, incluso si no existe ninguna instancia de la clase. Siempre se tiene acceso al miembro estático con el nombre de clase, no con el nombre de instancia. Solo existe una copia de un miembro estático, independientemente del número de instancias de la clase que se creen. Para los tipos genéricos, cada tipo genérico cerrado tiene su propia copia de miembros estáticos. Los campos estáticos marcados con ThreadStaticAttribute tienen una copia por subproceso. 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 habituales de los campos estáticos son llevar la cuenta del número de objetos de los que se han creado instancias o 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 una 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 las instancias del tipo. Por lo tanto, se puede acceder a campos const mediante la misma notación ClassName.MemberName que se usa para los campos estáticos. No se requiere ninguna instancia de objeto.

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

Para declarar miembros de clases estáticas, use 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 => 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 obtenga acceso por primera vez al miembro estático y antes de que se llame al constructor estático, en caso de haberlo. Para tener acceso 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();
var i = Automobile.NumberOfWheels;

Si la clase contiene campos estáticos, proporcione un constructor estático que los inicialice al cargar 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 además busca referencias a un objeto NULL. No obstante, la mayoría de las veces la diferencia de rendimiento entre las 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

  • Last updated on