Question

I have an interface IFoo for which I want to provide a default implementation Foo.
Foo can be used as a contained class/component by other classes that implement IFoo.

IFoo is used by several classes that mostly implement it by forwarding calls to Foo, but for some methods they may provide their own implementation.

Foo needs access to (private) members of the calling class.

Passing these members as arguments in method calls is not possible because they are not (and should not be) part of the IFoo interface.

Providing public properties to these members only for this purpose is unwanted because it would make the interfaces of the calling classes overly complex.

The question is: what is good design to give Foo access to these members or how is this normally achieved? Are there any known design patterns for this?

EDIT: inheritance is not an option because the classes that implement IFoo can’t inherit from the same class.

Answer 1

No inheritance you say? So basically your Foo class doesn’t need to implement IFoo, it just needs to make implementing IFoo easy. Why can’t you add some parameters to the methods, then? Something like this:

OK, let’s see. Let me make up some methods to make sure I got this right:

interface IFoo
{
    void DisplayTime();
}

And your FooImplHelper (made static just for the purpose of this example, I don’t know if it makes sense in your case or not)

public static FooImplHelper
{
    public static void DisplayTime(int UTFOffiset)
    {
        Console.WriteLine(DateTime.UtcNow + TimeSpan.FromHours(UTFOffset));
    }
}

and the IFoo implementation

public class MyClock: BaseClock, IFoo
{
     public void DisplayTime()
     {
         FooImplHelper.DisplayTime(2);
     }
}

Does that make sense? If not, you’re going to have to give some more information.

Itay,