Question

I have 3 classes:

class First {
    public void SetA(){ ... }
    public void SetB(){ ... }
    public void SetC(){ ... }
    public void SetD(){ ... }
    public void SetZ(){ ... }
}

class Second {
    public void SetC(){ ... }
    public void SetD(){ ... }
    public void SetE(){ ... }
    public void SetF(){ ... }
    public void SetX(){ ... }
}

class Third{
    public void SetA(){ ... }
    public void SetB(){ ... }
    public void SetE(){ ... }
    public void SetF(){ ... }
    public void SetY(){ ... }
}

As you can see, I duplicate code in the same methods.
Yesterday I realized that sometimes I would like to add another commend inside each method.
So I am looking for a way to solve both those problems. One solution I thought about is:

1. Create Interface:

   interface IAllMethods {
           void SetA();
           void SetB();
           void SetC();
           void SetD();
           void SetE();
           void SetF();
           void SetX();
           void SetY();
           void SetZ();
   }
   

2. Create default implementation:

   class DefaultAllMethods {
           public void SetA(){ ... }
           public void SetB(){ ... }
           public void SetC(){ ... }
           public void SetD(){ ... }
           public void SetE(){ ... }
           public void SetF(){ ... }
           public void SetX(){ ... }
           public void SetY(){ ... }
           public void SetZ(){ ... }
   }
   

3. Create another implementation using decorator pattern in order to add the extra command:

   class ExtraAllMethods {
           private IAllMethods _allMethods;
           public ExtraAllMethods (IAllMethods allMethods) {
               _allMethods=allMethods;
           }
           public void SetA(){ 
               _allMethods.SetA();
               extraMethod();
           }
           public void SetB(){ 
               _allMethods.SetB();
               extraMethod();
           }
           public void SetC(){ 
               _allMethods.SetC();
               extraMethod();
           }
           ..
           ..
           ..
   }
   

4. Use the desire implementation inside classes First, Second and Third. For example:

   class Third{
       private IAllMethods  _allMethods;
       public Third(IAllMethods allMethods) {
           _allMethods=allMethods;
       }
       public void SetA(){ _allMethods.SetA(); }
       public void SetB(){ _allMethods.SetB(); }
       ..
       ..
       ..
   }
   

What do you think about this solution? Is there any better design to this need?

UPDATE
People ask for the real business, so here is it:
I have 3 types of transmission: TransmissionA, TransmissionB, TransmissionC
Each transmissions has many parameters (members or properties). For example, TransmissionA has WorkerId, CustomerId, MessageName and so on. TransmissionB has WorkerId and MessageName but no CustomerId. TransmissionC has WorkerId, CustomerId but no MessageName. These are example only – in my situation I have many more properties for each transmission. Each property has Set method.
Now there is a new need. Somewhere on the system there is an option called “Update Task”. If the option is ON then I need to update relevant task in each Set method. This is why I thought on decorator pattern.

Answer 1

this will work but instead of introducing all-knowing interface and base implementation classes containing all methods (and thus having knowledge of the entirety of your collection of methods) you could also go for a more granular approach and just make a single interface and base implementation for each method. That would be more extensible and you could attach those just as easy in a plugin-like fashion if you set it up properly.