Clases estáticas y sus miembros (Guía de programación de C#)Static Classes and Static Class Members (C# Programming Guide)

Una clase estática es básicamente lo mismo que una clase no estática, con la diferencia de que no se pueden crear instancias de una clase estática.A static class is basically the same as a non-static class, but there is one difference: a static class cannot be instantiated. En otras palabras, no puede usar el operador new para crear una variable del tipo de clase.In other words, you cannot use the new operator to create a variable of the class type. Dado que no hay ninguna variable de instancia, para tener acceso a los miembros de una clase estática, debe usar el nombre de la clase.Because there is no instance variable, you access the members of a static class by using the class name itself. 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 tal como se muestra en el ejemplo siguiente:For example, if you have a static class that is named UtilityClass that has a public static method named MethodA, you call the method as shown in the following example:

UtilityClass.MethodA();  

Es posible usar una clase estática como un contenedor adecuado para conjuntos de métodos que solo funcionan en parámetros de entrada y que no tienen que obtener ni establecer campos de instancias internas.A static class can be used as a convenient container for sets of methods that just operate on input parameters and do not have to get or set any internal instance fields. Por ejemplo, en la biblioteca de clases .NET Framework, la clase estática System.Math contiene métodos que realizan operaciones matemáticas, sin ningún requisito para almacenar o recuperar datos que sean únicos de una instancia concreta de la clase Math.For example, in the .NET Framework Class Library, the static System.Math class contains methods that perform mathematical operations, without any requirement to store or retrieve data that is unique to a particular instance of the Math class. Es decir, para aplicar los miembros de la clase, debe especificar el nombre de clase y el nombre de método, como se muestra en el ejemplo siguiente.That is, you apply the members of the class by specifying the class name and the method name, as shown in the following example.

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, Common Language Runtime (CLR) de .NET Framework carga la información de tipo de una clase estática cuando se carga el programa que hace referencia a la clase.As is the case with all class types, the type information for a static class is loaded by the .NET Framework common language runtime (CLR) when the program that references the class is loaded. El programa no puede especificar exactamente cuándo se carga la clase,The program cannot specify exactly when the class is loaded. pero existe la garantía de que se cargará, de que sus campos se inicializarán y de que se llamará a su constructor estático antes de que se haga referencia a la clase por primera vez en el programa.However, it is guaranteed to be loaded and to have its fields initialized and its static constructor called before the class is referenced for the first time in your program. 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.A static constructor is only called one time, and a static class remains in memory for the lifetime of the application domain in which your program resides.

Nota

Para crear una clase no estática que solo permita la creación de una instancia de sí misma, vea Implementing Singleton in C# (Implementar un singleton en C#).To create a non-static class that allows only one instance of itself to be created, see Implementing Singleton in C#.

La siguiente lista contiene las características principales de una clase estática:The following list provides the main features of a static class:

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.Creating a static class is therefore basically the same as creating a class that contains only static members and a private constructor. Un constructor privado impide que se creen instancias de la clase.A private constructor prevents the class from being instantiated. La ventaja de usar una clase estática es que el compilador puede comprobar que no se agregue accidentalmente ningún miembro de instancia.The advantage of using a static class is that the compiler can check to make sure that no instance members are accidentally added. El compilador garantizará que no se creen instancias de esta clase.The compiler will guarantee that instances of this class cannot be created.

Las clases estáticas están selladas y, por lo tanto, no pueden heredarse.Static classes are sealed and therefore cannot be inherited. No pueden heredar de ninguna clase excepto Object.They cannot inherit from any class except Object. Las clases estáticas no pueden contener un constructor de instancias, pero pueden contener un constructor estático.Static classes cannot contain an instance constructor; however, they can contain a static constructor. 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.Non-static classes should also define a static constructor if the class contains static members that require non-trivial initialization. Para obtener más información, vea Constructores estáticos.For more information, see Static Constructors.

EjemploExample

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:Here is an example of a static class that contains two methods that convert temperature from Celsius to Fahrenheit and from Fahrenheit to 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());
                Console.WriteLine("Temperature in Fahrenheit: {0:F2}", F);
                break;

            case "2":
                Console.Write("Please enter the Fahrenheit temperature: ");
                C = TemperatureConverter.FahrenheitToCelsius(Console.ReadLine());
                Console.WriteLine("Temperature in Celsius: {0:F2}", C);
                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áticosStatic Members

Una clase no estática puede contener métodos, campos, propiedades o eventos estáticos.A non-static class can contain static methods, fields, properties, or events. El miembro estático es invocable en una clase, incluso si no se ha creado ninguna instancia de la clase.The static member is callable on a class even when no instance of the class has been created. Siempre se tiene acceso al miembro estático con el nombre de clase, no con el nombre de instancia.The static member is always accessed by the class name, not the instance name. Solo existe una copia de un miembro estático, independientemente del número de instancias de la clase que se creen.Only one copy of a static member exists, regardless of how many instances of the class are created. Los métodos y las propiedades estáticos no pueden tener acceso a campos y eventos no estáticos en su tipo contenedor, y tampoco pueden tener acceso a una variable de instancia de un objeto a menos que se pase explícitamente en un parámetro de método.Static methods and properties cannot access non-static fields and events in their containing type, and they cannot access an instance variable of any object unless it is explicitly passed in a method parameter.

Es más habitual declarar una clase no estática con algunos miembros estáticos que declarar toda una clase como estática.It is more typical to declare a non-static class with some static members, than to declare an entire class as static. Dos usos habituales de los campos estáticos son llevar la cuenta del número de objetos de los que se han creado instancias y almacenar un valor que se debe compartir entre todas las instancias.Two common uses of static fields are to keep a count of the number of objects that have been instantiated, or to store a value that must be shared among all instances.

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.Static methods can be overloaded but not overridden, because they belong to the class, and not to any instance of the class.

Aunque un campo no se puede declarar como static const, el campo const es básicamente estático en su comportamiento.Although a field cannot be declared as static const, a const field is essentially static in its behavior. Pertenece al tipo, no a las instancias del tipo.It belongs to the type, not to instances of the type. Por lo tanto, se puede tener acceso a campos const mediante la misma notación ClassName.MemberName que se usa para los campos estáticos.Therefore, const fields can be accessed by using the same ClassName.MemberName notation that is used for static fields. No se requiere ninguna instancia de objeto.No object instance is required.

C# no admite variables locales estáticas (variables que se declaran en el ámbito del método).C# does not support static local variables (variables that are declared in method scope).

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:You declare static class members by using the static keyword before the return type of the member, as shown in the following example:

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 obtenga acceso por primera vez al miembro estático y antes de que se llame al constructor estático, en caso de haberlo.Static members are initialized before the static member is accessed for the first time and before the static constructor, if there is one, is called. 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:To access a static class member, use the name of the class instead of a variable name to specify the location of the member, as shown in the following example:

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

Si la clase contiene campos estáticos, proporcione un constructor estático que los inicialice al cargar la clase.If your class contains static fields, provide a static constructor that initializes them when the class is loaded.

Una llamada a un método estático genera una instrucción de llamada en Lenguaje Intermedio de Microsoft (MSIL), mientras que una llamada a un método de instancia genera una instrucción callvirt, que también comprueba si hay referencias a un objeto NULL,A call to a static method generates a call instruction in Microsoft intermediate language (MSIL), whereas a call to an instance method generates a callvirt instruction, which also checks for a null object references. pero la mayoría de las veces la diferencia de rendimiento entre las dos no es significativo.However, most of the time the performance difference between the two is not significant.

Especificación del lenguaje C#C# Language Specification

Para más información, vea las secciones sobre clases estáticas y sobre miembros de instancia y estáticos de la Especificación del lenguaje C#.For more information, see Static classes and Static and instance members in the C# Language Specification. La especificación del lenguaje es la fuente definitiva de la sintaxis y el uso de C#.The language specification is the definitive source for C# syntax and usage.

Vea tambiénSee also