CODEWITHSUNDEEP
c#encapsulationinner-classesnested-class
Dan Stevens
Dan Stevens

Reputation: 6830

Allow access to but prevent instantiation of a nested class by external classes

I'm looking to define a nested class that is accessible to the container class and external classes, but I want to control instantiation of the nested class, such that only instances of the container class can create new instances of the nested class.

The proceeding code should hopefully demonstrate this:

public class Container
{
    public class Nested
    {
        public Nested() { }
    }

    public Nested CreateNested()
    {
        return new Nested();  // Allow
    }
}

class External
{
    static void Main(string[] args)
    {
        Container containerObj = new Container();
        Container.Nested nestedObj;

        nestedObj = new Container.Nested();       // Prevent
        nestedObj = containerObj.CreateNested();  // Allow

    }
}

Nested must be public in order for it to be accessible by External. I tried making the constructor for Nested protected, however that prevents Container from creating instances, as Container isn't a base class of Nested. I could set the constructor for Nested to internal, but I'm looking to prevent access to the constructor by all external classes, including those in the same assembly. Is there a way to do this?

If this cannot be achieved through access modifiers, I wonder if I could throw an exception within Nested(). However, I don't know how to test for the context within which new Nested() is called.

Upvotes: 16

Views: 1935

Answers (2)

Rafal
Rafal

Reputation: 12629

It is impossible to declare class in such way. I think that the best way for you would be to declare class as private and expose it through public interface:

class Program
{
    static void Main(string[] args)
    {
       // new S.N(); does not work
        var n = new S().Create();
    }
}

class S
{
    public interface IN
    {
        int MyProperty { get; set; }
    }
    class N : IN
    {
        public int MyProperty { get; set; }
        public N()
        {

        }
    }

    public IN Create()
    {
        return new N();
    }
}

Upvotes: 3

Marc Gravell
Marc Gravell

Reputation: 1063704

How about abstraction via an interface?

public class Container
{
    public interface INested
    {
        /* members here */
    }
    private class Nested : INested
    {
        public Nested() { }
    }

    public INested CreateNested()
    {
        return new Nested();  // Allow
    }
}

class External
{
    static void Main(string[] args)
    {
        Container containerObj = new Container();
        Container.INested nestedObj;

        nestedObj = new Container.Nested();       // Prevent
        nestedObj = containerObj.CreateNested();  // Allow

    }
}

You can also do the same thing with an abstract base-class:

public class Container
{
    public abstract class Nested { }
    private class NestedImpl : Nested { }
    public Nested CreateNested()
    {
        return new NestedImpl();  // Allow
    }
}

class External
{
    static void Main(string[] args)
    {
        Container containerObj = new Container();
        Container.Nested nestedObj;

        nestedObj = new Container.Nested();       // Prevent
        nestedObj = containerObj.CreateNested();  // Allow

    }
}

Upvotes: 13

Related Questions