How to forbid the use of fields instead of properties?

Question

I have a property in my class that has a lot of logic in set accessor:

private String text;

public String Text
{
   get { return text; }
   private set
   {
      // some actions with a value
      value = value.Replace('a', 'b');

      text = value;
   }
}

How can I prevent other developers (or even me) from changing field instead of property inside of this class ?

If somebody writes something like this:

public Test(String text)
{
   this.text = text;
}

it will break the logic of my class !

Answer 1

Normally, classes should be small enough that this shouldn't be an issue. Since the field is private, only code inside the same type will have access to the field. However, if you need to highlight the importance, you could do:

[Obsolete("Use the Text property, or I break your legs; fair warning")]
private string text;

public string Text
{
#pragma warning disable 0618
    get { return text; }
    private set
    {
        // some actions with a value
        value = value.Replace('a', 'b');

        text = value;
    }
#pragma warning restore 0618
}

This doesn't stop them, but it may help prevent accidental usage of the field.

Answer 2

There is a correct way to do this. Consider the old adage "All problems in computer science can be solved by another level of indirection".

What you do is create a class that knows how to set the value of the text field properly.

class TextSetter
{
    private string text;
    public TextSetter(string text)
    {
        Text = text;
    }
    public string Text
    {
        get{ return text;}
        set{ text = value.Replace('a', 'b');}
    }
}

Then in your first class instead of private string text; you have private TextSetter text; now there is never any chance that someone will accidentally set the value directly.

you could even generalise this, if it's a common problem

class FieldSetter<T>
{
    private T field;
    private Func<T, T> setter;
    public FieldSetter(Func<T, T> setter, T field)
    {
        this.setter = setter
        Value = field;
    }
    public T Value
    {
        get{ return field;}
        set{ field = setter(value);}
    }
}

Feel free to rename as you see fit.

Answer 3

As an alternative approach, building on the discussion with Binary Worrier (comments), you could do something like:

internal struct SanitizedText {
    private readonly string value;
    private SanitizedText(string value) {
        this.value = value;
    }
    public static implicit operator string (SanitizedText value) {
        return value.value;
    }
    public static implicit operator SanitizedText(string value) {
        if (value != null) value = value.Replace('a', 'b');
        return new SanitizedText(value);
    }
}

and then simply:

private SanitizedText text;
public string Text {
    get { return text; }
    set { text = value; }
}

This does all the same validation, but it is impossible to abuse: you cannot create a SanitizedText value that bypasses the validation; equally, it takes no more space (the size of the struct is the size of the contents: 1 reference), and requires no allocations. It even defaults to a null string in the same way.

Answer 4

What you did already by setting the modifier to private for the field is as far as you can go. Within the class you should generally know what you do with its fields, where the logic happens.

Answer 5

You could use collections (one per type) as "backing storage":

private static readonly Dictionary<string, int> __intFields = new Dictionary<string, int>();
private static readonly Dictionary<string, string> __stringFields = new Dictionary<string, string>();

public static string StringProp
{
    get
    { 
        var fieldValue = default(string);
        __stringFields .TryGetValue("StringProp", out fieldValue);
        return fieldValue;
    }
    set
    {
        var manipulatedValue = applyOtherCode(value); // the rest of the code
        __stringFields ["StringProp"] = manipulatedValue
    }
}

public static int IntProp
{
    get
    { 
        var fieldValue = default(int);
        __intFields .TryGetValue("IntProp", out fieldValue);
        return fieldValue;
    }
    set
    {
        var manipulatedValue = applyOtherCode(value); // the rest of the code
        __intFields ["IntProp"] = manipulatedValue
    }
}
// There is no field for anyone to mistakenly access!

Ugly, verbose, un-refactorable, ... but it gets the job done. If performance is the last of your concerns (if it even is one), you could grab the property name via Reflection and avoid magic strings.

I originally had a single <string, object> collection ... but I hated it. One per type avoids casting data all the time