通用基类

Question

I am doing a customization from an existing library, which has following structure:

public class BaseClass
{
    public Method1();
    public Method2();
}
public class A : BaseClass
{
    public Method1();
    public Method2();
}
public class B : BaseClass
{
    public Method1();
    public Method2();
}
public class C : BaseClass
{
    public Method1();
    public Method2();
}

The above are code that I cannot change .

Now, I need to cumtom A, B, C. but ALL changes inside each inheritances are totally SAME. logic and code are totally same changes.

public class BaseClass1 : BaseClass
{
    public override Method1(); //some logic changed comparing to base
}
public class A1 : A
{
    public override Method1(); //Changes are totally  same with BaseClass1 
}
public class B1 : B
{
    public override Method1(); //Changes are totally  same with BaseClass1 
}
public class C1 : C
{
    public override Method1(); //Changes are totally  same with BaseClass1 
}

All code are duplicated, copy-pasted in each class.

My Question is: How can I avoid copy-pasted code??

This code doesn't work clearly:

public class BaseClass1<T> : T where T: BaseClass  //Base class cannot be T
{
    public override Method1(); 
    public override Method2(); 
}

The reason I don't want to duplicate code is that there are C,D,E,F and so on inheritances.

Answer 1

As one option you could use a variation of the decorator pattern, (the exact library signatures are unknown so I have added examples where methods are overridden or hidden) example below:

// original libary code
public class BaseClass
{
    public virtual string Method1() => "m1 of base";
    public string Method2() => "m2 of base";
}
public class A : BaseClass
{
    public override string Method1() => "m1 A";
    public string Method2() => "m2 A";
}
public class B : BaseClass
{
    public override string Method1() => "m1 B";
    public string Method2() => "m2 B";
}
public class C : BaseClass
{
    public override string Method1() => "m1 C";
    public string Method2() => "m2 C";
}


// methods to be overridden
public interface IMethodOfBase
{
    void Method1();
    void Method2();
}

// common behaviour
public class Decorator:IMethodOfBase
{
    private BaseClass b;

    public Decorator(BaseClass b)
    {
        this.b = b;
    }

    public void Method1()
    {
        Console.WriteLine($"overridden behaviour in one place {b.Method1()}");
    }

    public void Method2()
    {
        Console.WriteLine($"overridden behaviour in one place {b.Method2()}");
    }
}

// example usage
public class WorkLoad
{
    private List<Decorator> _work; 

    public WorkLoad()
    {
        _work = new List<Decorator>
        {
            new Decorator(new A()),
            new Decorator(new B()),
            new Decorator(new C()) //etc
        };
    }

    public void DoWork()
    {
        _work.ForEach( n =>
        {
            n.Method1();
            n.Method2();
        });
    }

}

and to run it

WorkLoad workLoad = new WorkLoad();
workLoad.DoWork();

and output: overridden behaviour in one place m1 A

overridden behaviour in one place m2 of base

overridden behaviour in one place m1 B

overridden behaviour in one place m2 of base

overridden behaviour in one place m1 C

overridden behaviour in one place m2 of base