Clases estáticas, métodos, constructores y campos en C#

En C#, estático significa contenido no instanciable. No puedes crear objetos de clases estáticas, ni puedes acceder a miembros estáticos utilizando un objeto.

Las clases, variables, métodos, propiedades, operadores, eventos y constructores pueden definirse como estáticos utilizando la palabra clave de modificador estático.

Clase estática

public static class Calculator
{
　　　　private static int _resultStorage = 0;
　　　　
　　　　public static string Type = "Arithmetic";
　　　　public static int Sum(int num1, int num2)
　　　　{
　　　　　　　　return num1　+　num2;
　　　　}
　　　　public static void Store(int result)
　　　　{
　　　　　　　　_resultStorage = result;
　　　　}
}

La clase Calculator anterior es estática. Todos sus miembros también son estáticos.

No puedes crear objetos de clases estáticas. Por lo tanto, puedes acceder directamente a los miembros de la clase estática utilizando el nombre de la clase ClassName.MemberName, como se muestra a continuación.

class Program
{
　　　　static void Main(string[] args)
　　　　{
　　　　　　　　var result = Calculator.Sum(10,　25);　//Llamar a métodos estáticos
　　　　　　　　Calculator.Store(result);　
　　　　　　　　var calcType = Calculator.Type;　//　Acceder a variables estáticas
　　　　　　　　Calculator.Type = "Scientific";　//　Assign a value to the static variable
　　　　}
}

Static class rules

1. Static classes cannot be instantiated.

2. All members of a static class must be static. Otherwise, the compiler will give an error.

3. Static classes can contain static variables, static methods, static properties, static operators, static events, and static constructors.

4. Static classes cannot contain instance members and constructors.

5. Indexers and destructors cannot be static

6. var cannot be used to define static members. You must explicitly specify the member type after the static keyword.

7. Static classes are sealed classes, so they cannot be inherited.

8. Static classes cannot inherit from other classes.

9. Static class members can be accessed using ClassName.MemberName (i.e., class name.member name).

10. Static classes are retained in memory throughout the entire lifecycle of the application domain in which the program is located.

Static members in non-static classes

Normal classes (non-static classes) can contain one or more static methods, fields, properties, events, and other non-static members.

It is more practical to define non-static classes with some static members instead of declaring the entire class as static.

Static fields

You can use the static keyword to define static fields in non-static classes.

Static fields of non-static classes are shared among all instances. Therefore, changes made by one instance will reflect on other instances.

public class StopWatch
{
　　　　public static int InstanceCounter = 0;
　　　　//　Constructor de instancia
　　　　public StopWatch()
　　　　{
　　　　}
}
class Program
{
　　　　static void Main(string[] args)
　　　　{
　　　　　　　　StopWatch sw1　= new StopWatch();
　　　　　　　　StopWatch sw2　= new StopWatch();
　　　　　　　　Console.WriteLine(StopWatch.NoOfInstances);　//2　
　　　　　　　　StopWatch sw3　= new StopWatch();
　　　　　　　　StopWatch sw4　= new StopWatch();
　　　　　　　　Console.WriteLine(StopWatch.NoOfInstances);//4
　　　　}
}

Método estático

You can define one or more static methods in a non-static class. Static methods can be called without creating an object. You cannot call static methods using an object of a non-static class.

Static methods can only call other static methods and access static members. You cannot access non-static members of the class in static methods.

class Program
{
　　　　static int counter = 0;
　　　　string name = "Demo Program";
　　　　static void Main(string[] args)
　　　　{
　　　　　　　　counter++;　//　Static fields can be accessed
　　　　　　　　Display("Hello World!");　//　Static methods can be called
　　　　　　　　name = "New Demo Program";　//Error: Cannot access non-static member
　　　　　　　　SetRootFolder("C:\MyProgram");　//Error: Cannot invoke non-static method
　　　　}
　　　　static void Display(string text)
　　　　{
　　　　　　　　Console.WriteLine(text);
　　　　}
　　　　public void SetRootFolder(string path) { }
}

Reglas de los métodos estáticos

1. Los métodos estáticos se pueden definir utilizando la palabra clave static antes del tipo de retorno, y luego definir los modificadores de acceso.

2. Los métodos estáticos se pueden sobrecargar, pero no se pueden sobrescribir.

3. Los métodos estáticos pueden contener variables estáticas locales.

4. Los métodos estáticos no pueden acceder o llamar a variables no estáticas, a menos que se pasen explícitamente como parámetros.

Constructor estático

Una clase no estática puede contener un constructor estático sin parámetros. Puede definirse utilizando la palabra clave static, sin modificadores de acceso, como public, private y protected.

El siguiente ejemplo muestra la diferencia entre el constructor estático y el constructor de instancia.

public class StopWatch
{
　　　　//　Constructor estático
　　　　static StopWatch()
　　　　{
　　　　　　　　Console.WriteLine("Se llamó el constructor estático");
　　　　}
　　　　//　Constructor de instancia
　　　　public StopWatch()
　　　　{
　　　　　　　　Console.WriteLine("Se llamó el constructor de instancia");
　　　　}
　　　　//　Método estático
　　　　public static void DisplayInfo()
　　　　{
　　　　　　　　Console.WriteLine("Se llamó DisplayInfo");
　　　　}
　　　　//　Método de instancia
　　　　public void Start() { }
　　　　//　Método de instancia
　　　　public void Stop() { }
}

La clase no estática StopWatch contiene un constructor estático, también contiene un constructor no estático.

Cada vez que se usa un método estático o se crea una instancia por primera vez, el constructor estático se llama una vez. El siguiente ejemplo muestra que al llamar por primera vez al método static, se llama al constructor estático. Al llamar al método estático por segunda vez no se llama al constructor estático.

StopWatch.DisplayInfo();　//　Aquí se llama al constructor estático
StopWatch.DisplayInfo();　//　Aquí no se llamó al constructor

Se llamó el constructor estático.
Se llamó DisplayInfo
Se llamó DisplayInfo

El ejemplo siguiente muestra que al crear la instancia por primera vez, se llama al constructor estático.

StopWatch sw1　= new StopWatch();　//　Primero es el constructor estático, luego el constructor de instancia　
StopWatch sw2　= new StopWatch();//　Sólo se llamó el constructor de instancia　
StopWatch.DisplayInfo();

Se llamó el constructor estático
Se llamó el constructor de instancia
Se llamó el constructor de instancia
Se llamó DisplayInfo

Reglas del constructor estático

1. El constructor estático se define utilizando la palabra clave static, sin usar modificadores de acceso public, private o protected.

2. Las clases no estáticas pueden contener un constructor estático sin parámetros. No se permite el uso de constructores estáticos parametrizados.

3. El constructor estático se ejecutará solo una vez en su vida útil. Por lo tanto, si se utiliza una clase en varios lugares, no se puede determinar cuándo se llama en la aplicación.

4. El constructor estático solo puede acceder a miembros estáticos. No puede contener ni acceder a miembros de instancia.

Los miembros estáticos de las clases no estáticas se almacenan en una área especial de la memoria denominada “pila alta”. Los miembros estáticos de las clases no estáticas se comparten entre todas las instancias de la clase. Por lo tanto, los cambios realizados por una instancia se reflejarán en todas las otras instancias.