Qfyilyi

Say I have a generic class Foo, that has a variable that is protected

public class Foo<T> 

{ 

    protected bool knowsFu; 

}

I also have 2 sub-classes: Bar and Pipe

public class Bar : Foo<Bar> {}



public class Pipe : Foo<Pipe> {}

It is actually possible for me to access the knowsFu in Pipe FROM Bar, e.g.:

public class Bar : Foo<Bar> 

{

    void UpdateFuInOtherClass(Pipe p)

    {

        p.knowsFu = false;

    }

}

Is this intended behaviour? (If so, what would be the usecase?)

Is there a way for me to prevent other Foo-Subclasses from modifying/reaching the protected variable inside of my current subclass?

More specifically: I'm using a generic class to implement the Singleton-Pattern:
https://en.wikipedia.org/wiki/Singleton_pattern

However, I'm currently able to access any singleton's protected instance-variable, as long as I am inside of another Singleton. Is there a way to prevent this?

EDIT: It might be relevant to note that the protected variable (knowsFu) is actually STATIC as well.

EDIT2: Ok, maybe the example was abit too generic.. here's how I'm actually currently implementing it:

why use Singleton? A:The platform I'm working on is Unity3D, in which the pattern is used frequently

I have a generically typed abstract class SingletonBehaviour

public abstract class SingletonBehaviour<T> where T : MonoBehaviour

{

    public static T Instance { get { return instance; } }



    protected static T instance { get; private set; } }



    // Loading is done through Unitys Awake-Method

}

One of the Singleton-Objects that I'm using is the APIManager

public class APIManager : SingletonBehaviour<APIManager>

{

    // Methods like SendHTTPPost(), HTTPGet(), etc.

}

However, since most of my projects need some better API-implementation than that, what I'm currently doing is:

public class ProjectAAPIManager : APIManager 

{

    // Overriding Instance so my return value is not APIManager but instead ProjectAAPIManager

    public static new ProjectAAPIMamager Instance { get { return (ProjectAAPIManager)instance; } }

}

This ^ is the reason my (inner) instance-variable is protected, and not private.

However, because of this, any other SingletonBehaviour in my project can now access the (inner) instance-variable on my ProjectAAPIManager

public class GameController : SingletonBehaviour<GameController> 

{

    private void AMethod()

    {

         // Accessing inner variable instead of public one

         ProjectAAPIManager.instance.DoSomething();

    }

}

As it's only the getter, this currently does not really matter. But what if I'd need access to the setter in my subclass as well?

Also: would it be worth it to generically type my APIManager as well?

Your question is nothing short of bewildering. How can you make a protected member not be accesible from a derived class? Well, a good start is not making it protected.

protected is by definition exactly what you don't want, so don't use it! Use private instead.

If what you are asking is how to make it a readonly member when accessed from derived types, you have two options:

1. Declare it as readonly in the base class if possible.


2. Use a protected property instead with a private setter.

Many novice coders seems to think protected members aren't part of the public surface of the type but they really are, as long as the class can be extended. As such, the rules of public members apply: never expose public fields unless they are readonly or constants, use properties instead.

You should not have classes that implement your generic singleton class.
Otherwise, by default, your protected fields will be accessible by the subclasses (it's what "protected" keyword does)

Instead, you should do something like this:

class Program

{

    static void Main(string args)

    {

        var barInstance = Foo<Bar>.GetInstance();

    }

}



public class Foo<T> where T : new()

{

    protected bool knowsFu;



    private static T _instance;



    public static T GetInstance()

    {

        if (_instance == null)

            _instance = new T();



        return _instance;

    }

}



public class Bar

{

    public Bar()

    {

    }

}

Edit 1:

To use a singleton, you should not make another class implement the singleton behavior (This is not how the singleton pattern works).
To use the same classes as your second example, you should do something like this.

public class SingletonBehaviour<T> where T : new()

{    

    public static T Instance 

    { 

        get 

        {

            if(instance == null)

                instance = new T()

            return instance; 

        } 

    } 

    private static T instance { get; set; } 

}



public class APIManager // This class should not inherit from the SingletonBehavior class

{

    // Methods like SendHTTPPost(), HTTPGet(), etc.

}



public class ProjectAAPIManager : APIManager 

{

    public ProjectAAPIManager GetInstance() => SingletonBehavior<ProjectAAPIManager>.Instance();

}