Comment puis-je représenter l'état de l'exécution de la méthode dans la classe de base sans affecter l'implémentation dans les classes dérivées?

Question

J'essaie de créer une classe abstraite, définissant une méthode abstraite, qui doit être dérivée d'autres classes qui implémente un comportement spécifique dans la méthode abstraite. Je veux que la classe abstraite contienne une sorte d'information d'état qui représente cependant la sortie de l'implémentation dans les classes dérivées sans erreurs, mais je veux implémenter tout le traitement d'état dans AbstractClass et non dans les classes dérivantes. Je veux que les classes dérivantes ne soient pas totalement conscientes de la fonctionnalité dans AbstractClass. Voici un exemple. J'ai fait des commentaires dans le code pour décrire ce que j'essaie d'accomplir.

public abstract class AbstractClass 
    { 
     public void Start() 
     { 
      ThreadStart ts = new ThreadStart(PerformWork); 
      Thread t = new Thread(ts); 
      t.Start(); 
      Thread.Sleep(2000); 

      // Dependent on if ReportWork exited without expcetions 
      // I want to call ReportSuccess or ReportFailure from this method. 
      // However, I dont want to implement any reporting functionallity (or 
      // as little as possible) 
      // into the deriving classes PerformWork() method. Simply put 
      // I want the deriving classes to be totally unaware of the reporting. 

     } 

     public void ReportSuccess() 
     { 
      Console.WriteLine("Success!"); 
     } 

     public void ReportFailure() 
     { 
      Console.WriteLine("Failure!"); 
     } 
     public abstract void PerformWork(); 
    } 

Une classe dérivant de AbstractClass:

class ConcreteImplementationClass:AbstractClass 
    { 
     public override void PerformWork() 
     { 
      // Implements some functionality 
      // without knowing anything about 
      // whats going on in AbstractClass.   
     } 
    } 

Ne Quelqu'un at-il des conseils pour la façon dont je pourrais obtenir cette fonctionnalité, ou comment je pourrais créer quelque chose de similaire?

Answer 1

Si je comprends bien, vous voulez appeler ReportSuccess() si le PerformWork() est réussi et ReportFailure() s'il échoue?

Pourquoi ne pas changer

public abstract void PerformWork(); 

à

public void Start() 
{ 
    bool result = false; 

    // This will enable Perform work to operate in its own thread 
    Action threadAction = new Action(() => 
     { 
      result = PerformWork(); 
     }); 

    ThreadStart ts = new ThreadStart(threadAction); 
    Thread t = new Thread(ts); 
    t.Start(); 
    Thread.Sleep(2000); 

    // Dependent on if ReportWork exited without expcetions 
    // I want to call ReportSuccess or ReportFailure from this method. 
    // However, I dont want to implement any reporting functionallity (or 
    // as little as possible) 
    // into the deriving classes PerformWork() method. Simply put 
    // I want the deriving classes to be totally unaware of the reporting. 

    if(result) 
    { 
     ReportSuccess(); 
    } 
    else 
    { 
     ReportFailure(); 
    } 
} 

Answer 2

Ne pouvez-vous pas rendre votre méthode de base virtuelle, étant donné que vous voulez exécuter du code, alors appelez base.PerformWork() dans toutes les méthodes dérivées?

Answer 3

Vous décrivez Programmation Orientée Aspect, AOP.

Vous pouvez facilement y parvenir en utilisant n'importe quel nombre de stratégies d'interception. Le plus facile serait probablement le proxy du château.

Voir this...