Limiting access to a public setter to specific objects (C#)

Question

I\'m trying to create a class (in C#) that serves as an environment for my application.

I\'m trying to make the class dynamic, and send it as a parameter to entities

Answer 1

You could try using Friend assemblies. That will allow only the assemblies you specify to have access to your privates (snicker).

Answer 2

How about

class Callee
{
    public void SetX(TypeOfCaller caller, int value)
    {
    }
}
class TypeOfCaller
{
    public void Do()
    {
        Callee instance;
        //..
        instance.SetX(this, 5);
    }
}

Doing so; you can also use Visual Studio' Find References feature! In case you want multiple types of caller; you can either opt for class hierarchy or can simply have required overloads

Answer 3

Isn't "internal" sufficient for what you need?

And you could move the setters into an interface as explicit implementation. Then they are hidden from the public interface and only accessible if you cast to the interface.

And if you want to make really sure that nobody else can call it you can add some parameter to these functions where you expect a certain token object which you only give to trusted classes.

void SetX(int value, object token)
{
    if(token!=correctToken)
        throw new ArgumentException("wrong token");
    x=value;
}

Answer 4

Maybe i understood something not quite well, but i think Jon had a quite similar problem which he described here. Maybe this can help you.

Answer 5

You could create a proxy, and send that proxy to your entity classes.

class MyClass
{
    public int MyProperty { get; set; }
}

class MyProxyClass
{
    public MyProxyClass(MyClass myClass)
    {
        _myClass = myClass;
    }

    private MyClass _myClass;

    public int MyProperty
    {
        get { return _myClass.MyProperty; }
    }
}

Answer 6

Why not return clones of your protected objects instead of the actual objects? Solves the problem without adding any more complexity.

public class MyService
{
    private List<MyObject> _protectedObjects = new List<MyObject>();

    public MyObject GetItem(int id)
    {
        return (MyObject)_protectedObjects.First(i => i.Id == id).Clone();
    }
}

public class MyObject : ICloneable
{
     //[...]
     public object Clone()
     {
         return MemberwiseClone();
     }
}