Question

I have a class

public class Foo{
    public Foo{...}

    private void someFunction(){...}
    ...
    private Acessor{
        new Acessor
    }
}

with some private functionality (someFunction). However, sometimes, I want to allow another class to call Foo.SomeFunction, so I have an inner class access Foo and pass out that:

public class Foo{
    public Foo{...}

    private void someFunction(){...}
    ...
    public Acessor{
        Foo _myFoo;
        new Acessor(Foo foo){_myFoo = foo;}
        public void someFunction(){
            _myFoo.someFunction();
        }
    }
}

With this code, if I want a Foo to give someone else pemission to call someFunction, Foo can pass out a new Foo.Accessor(this).

Unfortunately, this code allows anyone to create a Foo.Accessor initiated with a Foo, and they can access someFunction! We don’t want that. However, if we make Foo.Accessor private, then we can’t pass it out of Foo.

My solution right now is to make Acessor a private class and let it implement a public interface IFooAccessor; then, I pass out the Foo.Accessor as an IFooAccessor. This works, but it means that I have to declaration every method that Foo.Accessor uses an extra time in IFooAccessor. Therefore, if I want to refactor the signature of this method (for example, by having someFunction take a parameter), I would need to introduce changes in three places. I’ve had to do this several times, and it is starting to really bother me. Is there a better way?

Answer 1

It’s difficult to answer this question, since it’s not clear (to me at least) what exactly you want to achieve. (You write make it difficult for someone to inadverdantly use this code in a comment).

Maybe, if the method is to be used in a special context only, then explicitly implementing an interface might be what you want:

public interface ISomeContract {
    void someFunction();
}

public class Foo : ISomeContract {
    public Foo() {...}

    void ISomeContract.someFunction() {...}
}

This would mean, that a client of that class would have to cast it to ISomeContract to call someFunction():

var foo = new Foo();
var x = foo as ISomeContract;
x.someFunction();