Question

What are the advantages-disadvantages of declaring a Delegate type within a class scope over declaring it directly within the namespace scope? I mean the following two –

namespace MyNamespace
{
    public delegate string NamespaceScopeDelegate(int x, int y);

    public class ClassX
    {
        //class members
    }
}  

and,

namespace YourNamespace
{
    public class ClassA
    {
        public delegate string ClassScopeDelegate(int x, int y);

        //...
        //other class members
    }
}  

What sort of practical scenario would make me use the later one? I mean where exactly is it appropriate?

EDIT :

For the first case whenever I need to instantiate the delegate type, I can do that as –

var delegateInstance = new NamespaceScopeDelegate(MethodToPoint);  

But for the second case, I must use the enclosing type name as –

var delegateInstance = new ClassA.ClassScopeDelegate(MethodToPoint);  

Why would I want to do that? Does the second case provide any sort of encapsulation that I’m no aware of yet? Is there any special scenario that requires this sort of accessibility?

Answer 1

In your current examples, the only difference is that the second one doesn’t clutter your namespace, you need to reference the class it is declared in first. You can use it to make clear that the delegate has a close relationship with the class and it is mostly used by it alone.

The following is also possible (either internal or private):

namespace YourNamespace
{
    public class ClassA
    {
        internal/private delegate string ClassScopeDelegate(int x, int y);

        //...
        //other class members
    }
}

By making it internal, only the same assembly can access it, and it doesn’t clutter your namespace, by making it private, only the class itself may access the delegate declaration.