Question

Is it possible to have a variable which is an instance variable within a class but can only be accessed by a specific property?

I quite often create “self-creating” properties like so …

private IWGSLocation _location;
public IWGSLocation Location
{
    get
    {
        _location = _location ?? new WGSLocation();
        _location.Latitude = Latitude.GetValueOrDefault(0);
        _location.Longitude = Longitude.GetValueOrDefault(0);
        return _location;
    }
}

which means that I don’t go re-creating a new WGSLocation (or whatever other kind of object I need, which may be expensive to create, or may only need to be created once) every time I access the property. The downside is that my class can access the _location variable. But I don’t really want it to, so if there any way of having an instance variable which can only be used within the property itself?

I’m thinking something along these lines …

public IWGSLocation Location
{
    get
    {
        WGSLocation _location = _location ?? new WGSLocation();
        _location.Latitude = Latitude.GetValueOrDefault(0);
        _location.Longitude = Longitude.GetValueOrDefault(0);
        return _location;
    }
}

Answer 1

I agree it would be a nice language feature to have persistent locals — that is, variables whose lifetimes are based on the lifetime of the instance but whose scopes (the region of program text in which it is legal to access the variable by name) are local. It would be nice to have “static” locals as well, as some languages do.

Sadly, this is not a feature of C# and we have no plans to add it. It’s nice to have, but nice to have is not good enough to justify the expense, or to postpone or cancel a “nicer to have” feature.

It’s only “nice to have” because of course if you have a private field, it already is a private implementation detail of the class. If you don’t want it used outside the property, then don’t write code that uses it outside the property. If one of your coworkers tries to do so, put the smack down on ’em in code review.

I thought I might add: be very careful when writing property getters that mutate state. By default property getters are evaluated while looking at an object in the debugger, and it can be very confusing to be debugging something and have the debugger changing the values of fields just because you are examining an object.