I have a series of classes that implement an interface. I want to create a 3rd class (that also implements the interface) that combines the methods of both classes into a single one, plus add some managing code.
In other words.

Let's say I have this interface:

```
public interface ITestClass
{
    string NamePlusLastName(string name);

    int AgePlus20(int age);

    DateTime YearYouWillDie(int age);
}

```

and I have these 2 classes that implement it:

```
public class TestClassPeter : ITestClass
{
    public string NamePlusLastName(string name)
    {
        return string.Concat(name, " ", "Mc.Cormick");
    }

    public int AgePlus20(int age)
    {
        return age + 40;
    }

    public DateTime YearYouWillDie(int age)
    {
        return DateTime.Now;
    }
}

public class TestClassCharles : ITestClass
{
    public string NamePlusLastName(string name)
    {
        return string.Concat(name, " ", "Gonzales");
    }

    public int AgePlus20(int age)
    {
        return age + 20;
    }

    public DateTime YearYouWillDie(int age)
    {
        return DateTime.Now ;
    }
}

```

I want to create a class that returns an object that implements ITestClass and whose methods are a combination of both classes. Such as:

```
public class TestBoth 
{
    ITestClass peter;
    ITestClass charles;
    ITestClass combinedClass;

    public TestBoth()
    {
        // instantiate classes to be combined.
        peter = new TestClassPeter();
        charles = new TestClassCharles();

        // BEG
        // Add here code that will automatically combine methods of both classes into one.
        // ......
        // END

    }

    // expose as property
    public ITestClass CombinedClass
    {
        get
        {
            return combinedClass;
        }
    }
}

```

so that in the end I can call the combined class like this:

```
TestBoth classBuilder = new TestBoth();
ITestClass combinedClass = classBuilder.combinedClass;

// call a method
string fullName = combinedClass.NamePlusLastName("William");

```

And what is going on behind the scenes is really:

```
string firstValue = peter.NamePlusLastName("William");
// some code here
string secondValue = charles.NamePlusLastName("William");
// some more code here
return finalValue;

```

I want this to happen automatically for all methods. So that way, if I change the Interface definition, and the implementation of Peter and Charles, it will automatically be modified in the classBuilder.