C#: best way to make an argument of a method unchangeable

Question

I have an existing method like below: the method body has over 1000 lines of code that I can't bring it here, just in method body if the value of argument (I mean index_param) be changed then surly I get wrong results.

public String calculateValue(int index_param) {
    //a highly complicated transactional method which returns a String
}

I want to be sure the method body is not changing index_param during operation, and prevent it from changing the parameter. what do you prefer for this scenario?

Answer 1

Unfortunately, C# doesn't have a local variable analogue of readonly.

You could use a Code Contract Assert Requires pseudo post-condition for this, although I can't see a way to avoid an additional local variable which could also, in theory, be mutated.

public String calculateValue(int index_param) {
    int __DO_NOT_MUTATE_ME = index_param;

    // a highly complicated transactional method which returns a String
    //

    Contract.Assert(index_param == __DO_NOT_MUTATE_ME, "No! Don't change the local var");
    return result;
}

Edit - Some findings
Code Contracts aren't as suited toward detecting stack variable mutation as expected.

• Contract.Ensures() must be at the top of the code block, and Ensures is only designed to reason over return values, not local vars.
• Contract.Assert is thus cleaner as it can be placed anywhere in the block. It throws if the stack variable is mutated at run time.
• If static analysis is enabled, there is SOME (post) compile time benefit as well, as per the attached images (Top shows the warnings with the bad code, bottom shows no warnings with no mutation). However, instead of flagging the bad line of code which mutates the index_param (marked with Red Arrow), it instead flags a warning with our contract as the nonsensical "Consider adding Contract.Requires(index_param + 1 == index_param);". Hmmm ...
• You can download the Code Contracts plugin for Visual Studio here - an additional tab is added to the Properties dialog.

Answer 2

The parameter is passed by value. So, original reference doesn't change anyways even if you reassign the variable to a new value in the method body.

In case, you don't want method body to even reassign the variable to a new value, something like final int index_param in java or const int index_param in c++, there is no equivalent in c#.

Answer 3

If you're really paranoid, you can wrap your value in a helper class that ensures your value does not change

public static class ReadOnly
{
    public static ReadOnly<T> Create<T>(T val) where T : struct
    {
        return new ReadOnly<T>(val);
    }
}

public class ReadOnly<T> where T : struct
{
    private readonly T _value;

    public ReadOnly(T val)
    {
        this._value = val;
    }

    public T Value { get { return this._value; } }
}

public String calculateValue(int index_param) {
    //a highly complicated transactional method which returns a String
    var read_only_index_param = ReadOnly.Create(index_param);
    Console.WriteLine(read_only_index_param.Value);
}

Answer 4

Based on the comments, if it is an argument, it can be modified.

The only way to prevent the original value from being modified is to create a constant value INSIDE of the method rather than allow it to be injected into the method as an argument.

public String calculateValue() {
    const int index_param = 2;
}

A second option would be to add a readonly private field and move your index_param argument passing to the enclosing class' constructor. This way the field could not be changed by your calculateValue() method, although this would require a refactor.

public class ContainingClass
{
    private readonly int _index_param;

    public ContainingClass(int index_param)
    {
        _index_param = index_param;
    }
}

This would allow you to use your private field inside of calculateValue and it could not be changed, which would be a compile-time check.

Please note that this private field could still be changed via reflection. That said, if you have anyone that desperate to sabotage your codebase, you have larger issues on your hands.

Answer 5

Code contracts and/or unit tests are the best solutions but an alternative would be to simply assign the parameter to a local variable and verify that the parameter hasn't changed before returning a value from the method. If it does, you'll have to throw an exception since your code is potentially wrong.