Hello,

I'd like to be able to allow instanciation of a class (class Class_A) only
from another class method (class Class_B). And I'd like to write the
necessary code to enforce this behavior even inside the same assembly where
class Class_A and Class_B are defined.
I've written the code that does this BUT I'd like to understand if this is
the most correct way to obtain such a result.

This is my simplified code:

// abstract class
public abstract class Class_C
{
   public abstract void Method_1();
}

public class Class_B
{
   // method that returns instances of class Class_A
   public Class_A  Method_2()
   {
       return new Class_A();
   }

   // nested private class - implements the abstract class Class_C
   private class Class_A : Class_C
   {
       public override void Method_1
       {
           // implementation code
       }
   }
}

The above implentation allows the writing of the following "client" code:

Class_B b = new Class_B();
Class_C c = b.Method_2();  // creating an instance of class Class_A
c.Method_1();  // calling Method_1() of class Class_A

This code works well, the only thing I don't like is that Class_A is
completely unknown by code outside class Class_B.
Instead of an abstract class I could have used an interface but, since I
won't need to implement that interface more than once, I thought using an
abstract class to hold a reference to an instance of class Class_A to be
more correct.

Can anyone review this approach and tell me if there is any better solution?

Bob Rock