0Pricing
C# Academy · Lección

Clases estáticas para utilidades

Agrupe funciones auxiliares en clases estáticas.

Clases estáticas para utilidades es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C# Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C# Academy incluye 4 lecciones en total.

¿Qué es una clase estática?

Una clase estática se declara con static class. Solo puede contener miembros estáticos y no se puede crear una instancia de ella. Es el lugar natural para las funciones auxiliares.

using System;

static class StringUtils
{
    public static string Shout(string s) => s.ToUpper() + "!";
}

class Program
{
    static void Main()
    {
        Console.WriteLine(StringUtils.Shout("hello"));
    }
}

No se pueden crear instancias

Nunca escriba new para una clase estática. Todo acceso se realiza directamente mediante el nombre de la clase.

using System;

static class MathUtils
{
    public static int Cube(int x) => x * x * x;
}

class Program
{
    static void Main()
    {
        // No instance needed
        Console.WriteLine(MathUtils.Cube(3));
    }
}

Solo se permiten miembros estáticos

El compilador garantiza que todos los miembros de una clase estática sean estáticos. No se permiten campos ni constructores de instancia.

using System;

static class Temperature
{
    public static double ToFahrenheit(double c) => c * 9 / 5 + 32;
    public static double ToCelsius(double f) => (f - 32) * 5 / 9;
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Temperature.ToFahrenheit(100));
        Console.WriteLine(Temperature.ToCelsius(32));
    }
}

Agrupación de auxiliares relacionados

Una clase estática agrupa funciones relacionadas por un tema y les proporciona un espacio de nombres claro, como Validation.IsEmail(...).

using System;

static class Validation
{
    public static bool IsPositive(int n) => n > 0;
    public static bool IsEmail(string s) => s.Contains("@") && s.Contains(".");
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Validation.IsPositive(5));
        Console.WriteLine(Validation.IsEmail("a@b.com"));
    }
}

La clase Math integrada

La clase Math de .NET es una clase estática. Nunca se crea una instancia de ella; simplemente se llama a Math.Sqrt, Math.Max y otros métodos similares.

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine(Math.Max(3, 9));
        Console.WriteLine(Math.Sqrt(144));
        Console.WriteLine(Math.Round(3.14159, 2));
    }
}

Clase estática con campos estáticos

Una clase estática puede contener campos estáticos para constantes compartidas o configuraciones que usen sus métodos.

using System;

static class Pricing
{
    public static decimal Tax = 0.08m;

    public static decimal WithTax(decimal price) => price + price * Tax;
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Pricing.WithTax(100m));
    }
}

Funciones puras

Los métodos auxiliares funcionan mejor como funciones puras: la salida depende únicamente de las entradas, sin estado oculto. Esto hace que sean predecibles y fáciles de probar.

using System;

static class Geometry
{
    public static double RectArea(double w, double h) => w * h;
    public static double TriArea(double b, double h) => 0.5 * b * h;
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Geometry.RectArea(4, 5));
        Console.WriteLine(Geometry.TriArea(6, 3));
    }
}

Composición de métodos auxiliares

Los auxiliares estáticos pueden llamarse entre sí para crear operaciones más grandes a partir de otras más pequeñas.

using System;

static class TextUtils
{
    public static string Clean(string s) => s.Trim().ToLower();
    public static string Slug(string s) => Clean(s).Replace(" ", "-");
}

class Program
{
    static void Main()
    {
        Console.WriteLine(TextUtils.Slug("  Hello World  "));
    }
}

Clase estática frente a miembros estáticos en una clase normal

Si un tipo contiene solo auxiliares, haga que toda la clase sea estática. Si combina auxiliares con instancias, manténgala como una clase normal con algunos miembros estáticos.

using System;

static class Convert2
{
    public static int FeetToInches(int feet) => feet * 12;
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Convert2.FeetToInches(3) + " inches");
    }
}

Cómo mantener localizables los auxiliares

Agrupe los auxiliares en clases estáticas con nombres descriptivos (DateUtils, StringUtils) para que otros desarrolladores puedan encontrarlos fácilmente.

using System;

static class DateUtils
{
    public static bool IsWeekend(DayOfWeek d) =>
        d == DayOfWeek.Saturday || d == DayOfWeek.Sunday;
}

class Program
{
    static void Main()
    {
        Console.WriteLine(DateUtils.IsWeekend(DayOfWeek.Sunday));
        Console.WriteLine(DateUtils.IsWeekend(DayOfWeek.Monday));
    }
}

Integración

Las clases auxiliares estáticas centralizan la lógica sin estado tras un nombre claro y reducen la duplicación en el código base.

using System;

static class MoneyUtils
{
    public static string Format(decimal amount) => "$" + amount.ToString("0.00");
    public static decimal ApplyDiscount(decimal price, double pct) =>
        price * (decimal)(1 - pct / 100);
}

class Program
{
    static void Main()
    {
        decimal discounted = MoneyUtils.ApplyDiscount(80m, 25);
        Console.WriteLine(MoneyUtils.Format(discounted));
    }
}

Comprobación rápida

Compruebe cuánto comprende sobre las clases estáticas.

Recapitulación

Una clase estática (static class X) no se puede instanciar y solo puede contener miembros estáticos. Es el lugar habitual para funciones auxiliares sin estado y constantes, agrupadas bajo un nombre descriptivo. La clase Math integrada es un ejemplo conocido.

using System;

static class Util
{
    public static int Double(int n) => n * 2;
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Util.Double(21));
    }
}

Preguntas frecuentes

¿La lección «Clases estáticas para utilidades» es gratis?

Sí — el texto completo de «Clases estáticas para utilidades» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C# Academy, actualiza a CoddyKit PRO. El curso de C# Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Clases estáticas para utilidades»?

Agrupe funciones auxiliares en clases estáticas. Practicas C# Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C# Academy?

No se requiere experiencia previa. C# Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Clases estáticas para utilidades»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C# Academy?

Sí. Cada lección de C# Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Métodos y campos estáticos
  2. Clases estáticas para utilidades
  3. Constantes y campos readonly
  4. Diseño estático frente a diseño de instancia
← Volver a C# Academy