Miembros y métodos estáticos

¡Bienvenido a la siguiente lección! En esta lección, aprenderá sobre los miembros y métodos estáticos en C#, su propósito y cómo utilizarlos eficazmente en sus programas. ¡Comencemos!

¿Qué son los miembros estáticos?

Los miembros estáticos pertenecen a la propia clase, no a ninguna instancia específica de ella. Se comparten entre todas las instancias y se puede acceder a ellos sin crear un objeto de la clase.

Punto clave: Utilice miembros estáticos para valores o métodos que sean iguales en todas las instancias.

Definición de campos estáticos

Para definir un campo estático, utilice la palabra clave static. Ejemplo:

Punto clave: Los campos estáticos se comparten entre todas las instancias de la clase.

using System;

class Counter {
    public static int Count = 0; // Static field

    public Counter() {
        Count++; // Increment count for each object created
    }
}

class Program {
    static void Main() {
        new Counter(); // Create first object
        new Counter(); // Create second object

        Console.WriteLine("Total Count: " + Counter.Count); // Outputs: Total Count: 2
    }
}

¿Qué son los métodos estáticos?

Los métodos estáticos se pueden llamar desde la propia clase sin necesidad de una instancia. Utilícelos para funciones de utilidad u operaciones que no dependan de los datos de una instancia. Ejemplo:

Consejo: Utilice métodos estáticos para funcionalidades que no estén vinculadas a objetos específicos.

using System;

class MathUtils {
    public static int Add(int a, int b) {
        return a + b;
    }
}

class Program {
    static void Main() {
        int result = MathUtils.Add(5, 3); // Call static method
        Console.WriteLine("Sum: " + result); // Outputs: Sum: 8
    }
}

Propiedades estáticas

Las propiedades estáticas permiten un acceso controlado a los campos estáticos. Ejemplo:

Punto clave: Las propiedades estáticas ofrecen una forma clara de acceder a los campos estáticos y modificarlos.

using System;

class Configuration {
    private static string appName = "MyApp"; // Static field

    public static string AppName { // Static property
        get { return appName; }
        set { appName = value; }
    }
}

class Program {
    static void Main() {
        Console.WriteLine("App Name: " + Configuration.AppName); // Get static property
        Configuration.AppName = "SuperApp"; // Set static property
        Console.WriteLine("Updated App Name: " + Configuration.AppName);
    }
}

Constructores estáticos

Un constructor estático se llama automáticamente para inicializar campos estáticos o realizar otras tareas puntuales para una clase. Ejemplo:

Consejo: Los constructores estáticos no pueden tener modificadores de acceso ni parámetros y se llaman una sola vez.

using System;

class Logger {
    public static string LogFilePath;

    // Static constructor
    static Logger() {
        LogFilePath = "logs.txt"; // Initialize static field
        Console.WriteLine("Static constructor called.");
    }
}

class Program {
    static void Main() {
        Console.WriteLine("Log File Path: " + Logger.LogFilePath);
    }
}

Desafío práctico

Cree una clase TemperatureConverter con los métodos estáticos CelsiusToFahrenheit() y FahrenheitToCelsius() para convertir temperaturas. Ejemplo:

using System;

class TemperatureConverter {
    public static double CelsiusToFahrenheit(double celsius) {
        return (celsius * 9 / 5) + 32;
    }

    public static double FahrenheitToCelsius(double fahrenheit) {
        return (fahrenheit - 32) * 5 / 9;
    }
}

class Program {
    static void Main() {
        Console.WriteLine("25°C to Fahrenheit: " + TemperatureConverter.CelsiusToFahrenheit(25));
        Console.WriteLine("77°F to Celsius: " + TemperatureConverter.FahrenheitToCelsius(77));
    }
}

Buenas prácticas para los miembros estáticos

Estas son algunas buenas prácticas:

• Utilice miembros estáticos para funcionalidades o datos independientes de las instancias de una clase.
• Evite utilizar campos estáticos en exceso para mantener la modularidad y la facilidad de prueba.
• Utilice constructores estáticos para inicializar datos estáticos una sola vez durante el ciclo de vida de la aplicación.

Consejo: Mantenga los miembros estáticos simples y enfocados.

¡Excelente trabajo!

¡Felicidades! Ha aprendido a utilizar miembros, métodos y constructores estáticos para definir funcionalidades a nivel de clase en C#. En la próxima lección, exploraremos las enumeraciones y las estructuras para administrar conjuntos fijos de valores y agrupar datos relacionados. ¡Sigamos programando!