Si la lógica funciona en la interfaz miembros, en oposición a la ejecución miembros, a continuación, escribir un método de ayuda [o método de extensión] se aconseja.
public IRandom
{
byte NextByte();
}
public static class IRandomExtensions
{
// logic that acts against public interface IRandom
// may be applied to all implementations
public static int GetNextUnbiasedInteger (this IRandom random) { }
public static IEnumerable<T> Shuffle<T> (
this IRandom random,
IEnumerable<T> items) { }
}
Si la lógica de negocio opera en contra de implementación miembros,
public class SomeCommand : ICommand
{
// an implementation-specific member, NOT a member
// of ICommand
public int SomeControlCount { get; set; }
}
// a method that references implementation-speciic
// details. where should this go?
public void DoSomething()
{
SomeCommand command;
int count = command.SomeControlCount;
}
entonces es probable que debe unirse más estrechamente esto a la clase de implementación. Si esto es una ocurrencia común, entonces una clase base puede tener sentido.
Personalmente, las jerarquías complejas son más problemáticas que lo que valen, use su propio juicio con respecto a la facilidad de mantenimiento, la legibilidad y la reutilización, ¡y debería estar bien!
Espero que esto ayude! :)
O al revés: haga que la clase auxiliar sea decoradora e inserte la clase de comando en la clase auxiliar. – Ozan
+1 Al pensar en la reutilización de código, no piense en "herencia", piense en "agregación". –