¿Qué es un ayudante? ¿Es un patrón de diseño? ¿Es un algoritmo?

Tal vez un poco irónico, pero como no puedo encontrar esta respuesta en ningún lado a través de Google, para asegurarme de que Ingeniería de Software tenga la respuesta:

¿Qué es un ayudante?

He visto que el nombre se usa en todas partes (nombres de módulos, nombres de clases, nombres de métodos), como si la semántica fuera profunda y significativa, pero en el contexto de la informática (aunque no tengo un título en ella), yo ' ¡Nunca he visto una descripción o definición en ningún lado!

¿Es un patrón de diseño? ¿Es un algoritmo? Una vez trabajé en un programa en el que el módulo y la clase se llamaban algo algo útil (donde algo también era bastante genérico) y rápidamente lo renombré por algo que tenía sentido para mí, ¡pero siento que me falta algo aquí!

Una clase Helper es un código de olor menos conocido en el que un codificador ha identificado algunas operaciones misceláneas y de uso común e intentó hacerlas reutilizables al agruparlas en una agrupación antinatural. Los sucesivos desarrolladores han entrado en el proyecto y no se han dado cuenta de que existe la clase auxiliar, y en consecuencia han reescrito las mismas operaciones comunes, o incluso creado más clases auxiliares.

Pero en serio, el principal problema con las clases Helper es que generalmente son operaciones que actúan en una clase específica, lo que obviamente significa en términos OO que sufren un caso agudo de Feature Envy . Esta falla al empaquetar el comportamiento con los datos sobre los que actúa es la razón por la cual los desarrolladores con tanta frecuencia (en mi experiencia) no lo encuentran.

Además de esto, como ya ha identificado SomethingSomethingHelper es en realidad un nombre terrible. No es descriptivo, y no le da una idea real de qué tipo de operaciones realiza la clase (¿ayuda?), Lo que también significa que no es obvio al agregar nuevos comportamientos si pertenecen o no a la clase Helper. Rompería esas clases según las líneas de comportamiento relacionado que se agrupan lógicamente, y luego cambiaría el nombre de las nuevas clases para reflejar lo que hace.

Un ayudante es una clase o método adicional inofensivo, siempre que complemente un componente externo. Cuando hace lo contrario, indica un mal diseño porque el código ha sido excluido de su autoridad, si es que existe alguna autoridad.

Aquí hay un ejemplo de un ayudante inofensivo, utilizo un método llamado FindRepque cuenta el número de ceros a la izquierda.

digits = digits.Remove(0, TextHelper.FindRep('0', digits, 0, digits.Length - 2));

El método auxiliar es muy simple, pero muy inconveniente para copiar y pegar, y el marco no proporciona ninguna solución.

public static int FindRep(char chr, string str, int beginPos, int endPos)
{
    int pos;

    for (pos = beginPos; pos <= endPos; pos++)
    {
        if (str[pos] != chr)
        {
            break;
        }
    }

    return pos - beginPos;
}

Y aquí hay un ejemplo de un mal ayudante:

public static class DutchZipcodeHelper
{
    public static bool Validate(string s)
    {
        return Regex.IsMatch(s, @"^[1-9][0-9]{3}[A-Z]{2}$", RegexOptions.IgnoreCase);
    }
}

public class DutchZipcode
{
    private string value;

    public DutchZipcode(string value)
    {
        if (!DutchZipcodeHelper.Validate(value))
        {
            throw new ArgumentException();
        }

        this.value = value;
    }

    public string Value
    {
        get { return value; }
    }
}

Mi compañía solía usar la metodología de la clase Base / clase Helper donde cada objeto tendría dos clases. Tendría una clase Person que contenía todas las propiedades y definiciones de la clase y una clase PersonHelper que contenía todos los métodos, sentencias SQL y Logic que manipulaban la clase Person. Esto funcionó bien para nosotros porque todas nuestras aplicaciones usan declaraciones SQL para manipular datos y fue muy fácil para nosotros encontrar y modificar las declaraciones SQL según sea necesario.

Desde entonces hemos avanzado y ahora colocamos todo en la clase Persona / Base. Dejamos de usar la convención de nombres Helper porque queríamos tener menos archivos en nuestros proyectos. Además, la longitud de algunos de los nombres de clase se descontrolaba. jajaja

No es un gran ejemplo, pero entiendes la idea.

s = CompanyName.PersonHelper.GetPerson()
s = CompanyName.Person.GetPerson()

No digo que usar la convención de nomenclatura auxiliar sea la solución perfecta, pero funcionó para nosotros durante algunos años.