Classe abstraite, comment éviter la duplication du code ?

Question

J'ai le code suivant

internal abstract class Base
{
    public DateTime Time;
    public string Message;
    public string Log;
    public abstract void Invoke(string message);
}

internal class SubA : Base
{
    public override void Invoke(string message)
    {
        Time = DateTime.Now;
        // Do A
    }
}

internal class SubB : Base
{
    public override void Invoke(string message)
    {
        Time = DateTime.Now;
        // Do B
    }
}

J'ai ces classes SubA et SubB qui héritent de la classe de base, vous pouvez voir que j'ai un code qui se répète lui-même et qui règle l'heure, y a-t-il un moyen de déplacer le réglage de l'heure vers la classe de base ?

Answer 1

Vous pourriez faire quelque chose comme ça :

internal abstract class Base
{
    public DateTime Time;
    public string Message;
    public string Log;
    public void Invoke(string message){
         Time = DateTime.Now;
         this.InvokeInternal(message);
    }
    protected abstract void InvokeInternal(string message);
}

internal class SubA : Base
{
    protected override void InvokeInternal(string message)
    {
        // Do A
    }
}

internal class SubB : Base
{
    protected override void InvokeInternal(string message)
    {
        // Do B
    }
}

Answer 2

Il existe de nombreuses solutions possibles.

Cela dépend de la date à laquelle vous souhaitez que cette propriété soit définie.

Si vous le voulez immédiatement, vous pouvez le faire dans le constructeur de votre Base classe.

internal abstract class Base
{
    public DateTime Time;
    public string Message;
    public string Log;
    public abstract void Invoke(string message);

    public Base()
    {
        Time = DateTime.Now;
    }
}

internal class SubA : Base
{
    public override void Invoke(string message)
    {
        // Do A
    }
}

internal class SubB : Base
{
    public override void Invoke(string message)
    {
        // Do B
    }
}

Answer 3

Utilisez une méthode virtuelle à la place :

internal abstract class Base
{
    public DateTime Time;
    public string Message;
    public string Log;
    public virtual void Invoke(string message) {
        Time = DateTime.Now;
    }
}

internal class SubA : Base
{
}

internal class SubB : Base
{
}

Vous pouvez toujours surcharger la méthode dans les sous-classes où vous voulez une implémentation différente.

Answer 4

internal abstract class Base
{
    public DateTime Time;
    public string Message;
    public string Log;
    public virtual void Invoke(string message)
    {
        Time = DateTime.Now;
    }

}

internal class SubA : Base
{
    public override void Invoke(string message)
    { 
        base.Invoke(message);
        // Do A
    }
}

internal class SubB : Base
{
    public override void Invoke(string message)
    {
        base.Invoke(message);
        // Do B
    }
}

Answer 5

Il y a déjà beaucoup de réponses. En guise d'approche alternative (et un peu ninja), je vous propose de Lambda utilisées avec les propriétés des méthodes.

Dans votre cas ;

 public class Base
  {
    public DateTime Time;
    public string Message;
    public string Log;
    public Action<string> Invoke { get; set; }

    public Base()
    {
       this.Invoke = InvokeDefault;
    }

    private void InvokeDefault(string message)
    {
       Time = DateTime.Now;
    }
  }

De cette façon, nous fournissons un comportement par défaut à l'utilisateur de la fonction base classe. Avec lambda vous pouvez créer des instances avec différentes Invoke méthodes comme suit .

var myInstance= new Base
  {
    Invoke = () => { Time = DateTime.Now.AddDays(7); }
  };

La méthode d'invocation n'est surchargée que pour cette instance de l'élément d'information. Base classe. Cela donne plus de flexibilité et permet d'éviter les sous-classes inutiles.

Vérifiez ceci Un article génial de Patrick Steele pour les détails.