In c# is it possible for a function to only be called from within another function?

Question

In c# is it possible to create a function that can only be called from within another function?

eg can you do something like this?

private void a() {

b(); c(); ...do something else

private void b() { ..do something but can only be called from a() }

private void c() { ..do something but can only be called from a() }

}

The reason I want to do this is that function b() and c() split some implentation details of a() and they are just cleaner and easier to read in their own scope. However, these functions are of no use to the class as a() does some handling after they are called which must take place.

Answer 1

Not exactly but you could implement both within their own class. Mark b() as private.

Answer 2

Use an anonymous nested function maybe?

Answer 3

The short answer is no; however, you can create an anonymous delegate or lambda expression as your internal b() method.

Answer 4

You could use the internal keyword and put both those functions inside the same class, while leaving other other functions in a different class: http://msdn.microsoft.com/en-us/library/7c5ka91b.aspx

Answer 5

Using a delegate you can do:

public voidMyFunction()
{

   Func<string> myFunction=(s)=>Console.WriteLine(s);

   foreach(string str in myStringList)
   {
      myFunction(str);
   }
}

Answer 6

To gain the effect of only a() calling b(), either do as Andrew noted already, by putting a() and b() in a class and marking b() appropriately. If you're working inside of an assembly that you control totally, you could use internal instead of private if a() and b() will be in different classes, but in the same assembly. Then user code cannot call it (from outside of your assembly, that is, from their application program) and you can control via policy the writing of your assembly.

Answer 7

You can also create something like this:

internal abstract class SecretFunctionWrapper
{
    private void MySecretFunction()
    {
        ...
    }

    protected void FunctionWhichCalls()
    {
        ...
        MySecretFunction();
    }
}

public MyRealClass : SecretFunctionWrapper
{
    ...
}

This will work only for one function. You can also try nested private class like this:

public class A
{
    private static class Wrapped
    {
        private static void A()
        {
            secred code
        }

        public static void B()
        {
            A();
        }
    }

    public void UsingA()
    {
        Wrapped.B();
    }
}

Answer 8

Well you could use reflection and just get the calling method name and throw an exception if it were anything other than A.

http://www.csharp-examples.net/reflection-calling-method-name/

But if b and c are private they can only be called from within that class anyway, and if you're the only one that is writing the class, then i fail to see the problem. So it seems to me its not a coding problem but rather one of policy.

I'd just document the intent in the method headers/comments.

Similar Question Here - Note the comments on the answer

Answer 9

i dont know but maybe Code by Contracts may help but this is not supported natively

Answer 10

You could use the StackFrame class to check at runtime who's the caller of the function:

public class MyClass
{
    public static void A()
    {
       B();
    }

    public static void B()
    {
        var stackTrace = new StackTrace();

        if (stackTrace.FrameCount < 1 || stackTrace.GetFrame(1).GetMethod() != typeof(MyClass).GetMethod("A"))
              throw new InvalidOperationException("Not called from A()");
    }
}

But that is

1) Only at runtime

2) Slow

3) A really dirty hack

Answer 11

I wouldn't worry about taking explicit steps to ensure b() and c() are only called by a().

It makes sense to worry about the public methods you expose on a class, since you're providing an interface to the outside world, potentially to people who don't have access to the source code of your class (or at the very least don't want to worry about the implementation details of your class).

Inside your class, though, you should feel free to have whatever private methods you want for whatever reasons you want. Code re-use is one reason to create a new private method, but creating multiple smaller, single-use methods to break up a larger one is also a perfectly valid (and common) reason.

Beyond that, for future maintainers of your code a simple comment like:

//this method should only be called by a()
private void b()
{
    ...
}

is going to be far more understandable than most of the other solutions presented here.

Answer 12

Maybe easier to use #region in this case