Simulate “out” Parameters for Properties

A short article showing out-like syntax for property setters.

Anybody who has used c# long enough is familiar with the error message, A property or indexer may not be passed as an out or ref parameter. This is not valid in c#:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class WillNotCompile
{
    string MyProperty { get; set; }

    void Main()
    {
        Concat("abc", "xyz", out MyProperty); // error
    }

    void Concat(string first, string second, out string data)
    {
        data = first + second;
    }
}

Every c# developer should understand the problem here: a property setter is really a method, not a variable. Even so, I run into this every few months. Not because I don’t know the rule, and not because I don’t understand the reason it isn’t allowed, but because it feels like syntax that ought to work. Typically you end up using a temporary variable. In fact, a temporary variable for out is such a common pattern that Microsoft added inline variable declaration for out in c# 7.0:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class UglyButItWorks
{
    string MyProperty { get; set; }

    void Main()
    {
        Concat("abc", "xyz", out string temp); // inline temp var
        MyProperty = temp; // temp = "abcxyz"
    }

    void Concat(string first, string second, out string data)
    {
        data = first + second;
    }
}

In fact, VB.NET does allow out properties, and this is exactly what the VB compiler does under the hood. One of the guiding principles of c# language design is “no surprises,” whereas the VB.NET philosophy is “just make it work”… sometimes with not-necessarily-clear tradeoffs (in this case, a bit of performance and memory overhead that was much more important in the early 2000s, and could still be an issue in high-frequency call scenarios).

While adding .NET Core 2.0 configuration support to the Serilog.Sinks.MSSqlServer library, I found myself having to call a utility function to conditionally apply changes to more than 20 properties, and c# 7.0 was not an option. That meant three lines of code just to work around this little issue. There had to be a better way.

A Better Way

The idea is to use a delegate to set the property. This is pretty similar to out in that you’re passing a reference. (This could be simplified to eliminate the generic <T> and the conversion code if all of the properties in question are of the same type, but the conversion syntax is also useful to demonstrate.)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class OutPropertyViaDelegate
{
    string MyProperty { get; set; }

    delegate void PropertySetter<T>(T value);

    void Main()
    {
        Concat("abc", "xyz", (outval) => { MyProperty = outval; }); // outval = "abcxyz";
    }

    static void Concat<T>(string first, string second, PropertySetter<T> setter)
    {
        var data = first + second;
        setter((T)Convert.ChangeType(data, typeof(T)));
    }
}

Conclusion

This isn’t a new idea. A quick search turns up discussions about similar approaches dating back at least 13 years. However, I see people asking about it even now, and the accidental use of out with a property is common enough in my own day-to-day routine that I thought it was worth writing down. Obviously for just one or two properties the extra code isn’t worth it – just use a temporary variable. But when the property count starts to grow, this is a handy technique to have in your toolbox.

Updated:

Comments