Class accessor level - how to make this possible?

Question

I have this situation: I need class2(string) constructor to only be accessible from within the class1 methods and not from external classes:

public class class1 
{
    public void access() 
    { 
        //want to make class2(string) be accessible only from here
    }


    public class class2 
    {
        public class2() 
        { 
        }

        private class2(string p) 
        {   
        }
    }
}

I'm trying to validate a user, the class2() create an empty instance of the user class while the class2(...) login the user. now I have class1 login method access that can be called from my pages, and i dont want that any of my pages directly calls my class2(...) login but must all pass from class1.access() that returns the class2 with user informations.

edit: the purpose of this is to create a safe login procedure, I do not want to expose my login and make it accessible directly from my pages, I want that my pages pass from the logic of class1.access() which will make considerations on how/if to login a user and return and empty class2 if the login fail with also class2.valid=false; or will return a class2 with all the informations from the user. I need to access and create and empty class2 from my pages since I pass it as out param in my class1.access(login_credentials credentials, out class2 user_data)

Answer 1

As far as I know, there's no direct mechanism to restrict access to a nested class's constructor to its wrapping class only. There are a couple of code redesign workarounds though that you could consider. If you're willing, you can make the constructor internal:

public class class1 
{
    public void access() 
    { 
        var c = new class2("asdf");
    }

    public class class2 
    {
        public class2() 
        { 
        }

        internal class2(string p) 
        {   
        }
    }
}

This will restrict access to that constructor to the assembly that class2 resides. If all you want to do is restrict access for third parties consuming your libraries, then that might be a viable solution.

Another option is you can take advantage of the fact that the nested class2 can access private members of class1. In this way you can promote a factory method to "expose" the constructor:

public class class1 
{
    private static Func<string, class2> CreateNewClass2;

    static class1()
    {
        //this just forces the static constructor on `class2` to run.
        System.Runtime.CompilerServices.RuntimeHelpers.RunClassConstructor(typeof(class2).TypeHandle);
    }

    public void access() 
    { 
        class2 c = CreateNewClass2("asdf");
    }

    public class class2 
    {
        static class2()
        {
            //this is where we create a delegate exposing/promoting our private constructor
            class1.CreateNewClass2 = p => new class2(p);
        }

        public class2() 
        { 
        }

        private class2(string p) 
        {   
        }
    }
}

Honestly, this is a bit obtuse, but it will enforce the rules ultimately making it so that class1 and class2 are the only types that can ever access the class2(string p) constructor. I think your best bet though is to consider a possible change of your code design.

Answer 2

You can't do it with normal constructs (use of access modifiers), but one way you can do it is with reflection:

public class Outer
{
    public Inner GetInstanceOfInner(string s)
    {
        var innerInstance = 
            typeof(Inner).GetConstructor(
                 System.Reflection.BindingFlags.NonPublic,  //Search for private/protected
                 null,   //Use the default binder
                 new[] { typeof(string) },  //Parameter types in the ctor
                 null)   //Default binder ignores this parameter
                 .Invoke(new[] { s }) as Inner; //Create and cast

        return innerInstance;
    }

    public class Inner
    {
        public Inner() { }
        private Inner(string s) { }
    }
}

With reflection, you could invoke private or protected constructors using the BindingFlags.NonPublic to find the appropriate constructor. After that you .Invoke it to obtain a reference to the object and cast it for strong typing.

Answer 3

I would use an interface in this instance. After all an interface is exactly what you are describing.

DotNetFiddle.net Example

using System;

public class Program
{
    // Properties you want others to have access too
    public interface ICredentialsValidator
    {
        bool IsTest(string userName);
    }

    public static void Main()
    {
        var b = new PublicClass().GetCredentialsValidator();

        Console.WriteLine(b.IsTest("test"));
        Console.WriteLine(b.IsTest("blah"));
    }

    public class PublicClass
    {
        public ICredentialsValidator GetCredentialsValidator()
        {
            return new PrivateClass();
        }

        private class PrivateClass : ICredentialsValidator
        {
            public bool IsTest (string userName)
            {
                return userName == "test";
            }
        }
    }
}

results:

True

False

You can pass your ICredentialsValidator around but nobody can create an ICredentialsValidator nor a class2. Simple OOP.

Although I find this to be very convoluted and overly complex. I would just use the singleton pattern and an interface for Liskov's Substitution Principle:

public interface ISecurity
{
  bool IsTest(string userName);
}

public sealed class Security : ISecurity
{
  private static readonly Lazy<Security> lazy =
    new Lazy<Security>(() => new Security());
 
  public static ISecurity Security Instance { get { return lazy.Value; } }

  private Singleton()
  {
  }

  public bool IsTest(string userName)
  {
    
  }
} 

Then anyone would just

Security.Instance.IsTest("test");