Protect value from changies using reflection?

Question

Hi,
here is the problem case i am writing a little third party library. In this library i have a class like this

public class TestClass
    {
        public int TestField { get; private set; }

        public TestClass( )
        {
            TestField = 1;
        }
    }

Then i have a varialbe form this class like this

 public TestClass test = new TestClass( );

The problem i am facing is that usnig reflection like this

PropertyInfo field = typeof( TestClass ).GetProperty( "TestField" );
            field.SetValue( test, 2, null );

programers can change internal value of this class. this will be very bad thing becouse it can crash the hole library. My question is what is the best way to protect my code form such changes.I know i can use some kind of bool flag so tha value can be changed only ones but this is not very good salution is there a better one?
Best Regards,
Iordan

Answer 1

Use ReadOnly value, if you want a constant value. or just use const.

Use Enum, in case that you have a few 'safe values' that you want to customer (programmer) to choose one of them.

Edit: Apparently, enum not safe enough. you can use readonly field with the following format:

public class SafeValue
{
    private string _value;

    public static readonly SafeValue Value1 = new SafeValue("value1");
    public static readonly SafeValue Value2 = new SafeValue("value2");

    private SafeValue(string value)
    {
        _value = value;
    }

    public override string ToString()
    {
        return _value;
    }
}

Answer 2

You can even change the private readonly field using reflection. So, your best bet may the const.

Answer 3

Please understand that I mean this with all respect:

You are wasting your time. Seriously.

Reflection is not to be considered when specifying an API or contract.

Believe this. It is not possible to stop reflection. If a consumer is bent on peeking into your code and flipping bits that have been hidden for a reason, well, the consequences are on them, not you.

Answer 4

You are trying to protect your system from something that is stronger than your code. If you don't trust certain code, run it with partial trust - then when it asks to reflect your type it will be denied.

Reflection (and related techniques like DynamicMethod) can with enough trust get virtually unrestricted access to your data (even, for example, changing the characters of a string without ever re-assigning it); thus you must reduce trust for non-trusted code.

In a similar way, anyone with debugger or admin access to your process (or the dlls it loads) can subvert your code. This is not an interesting attack, as the "hacker" must already have at least as much access than your code (probably more).