[This post is part of a series, "wish-list for future versions of VB"]
IDEA: Custom property templates. We should have an easy way for users to write boiler-plate code in their properties. This would include things like INotifyPropertyChanged, logging, validation. Here's how:
Public Event PropertyChanged(s As Object, e As PropertyChangedEventArgs) Implements INotifyPropertyChanged.PropertyChanged
Property Width As Integer From New MyProperty(0, 10, PropertyChangedEvent)
Property Height As Integer From New MyProperty(0, 5, PropertyChangedEvent)
The "Property From ..." syntax means that this property should be implemented by the specified object, in this case a new instance of a class into which we put our boilerplate:
Private notify As PropertyChangedEventHandler
Private min, max As Integer
Private _p As Integer
Sub New(min As Integer, max As Integer, notify As PropertyChangedEventHandler)
Me.min = min : Me.max = max : Me.notify = notify
Public Function [Get]() As Integer
Public Sub [Set](value As Integer)
If _p = value Then Return
Dim propName = Reflection.GetCurrentMethod().Name. Replace("set_", "").Replace("get_", "")
If value < min OrElse value > max Then Throw New ArgumentOutOfRangeException(propName)
_p = value
Log("property " & propName & " changed to " & value)
notify(Me, New PropertyChangedEventArgs(propName))
The compiler implements a simple getter which just calls into MyProperty.Get(), and a simple setter which just calls MyProperty.Set(value). The user can decide what kind of boilerplate code to put inside their custom property class, or what parameters to pass to its constructor. The "From" expression also allows you to provide any expression as the property template, e.g. a factory method, just so long as it returns a type on which the compiler can call Get() or Set(value). These Get/Set methods may even be extension methods.
SCENARIO: User has a lot of properties which all behave in pretty similar ways. It's tedious to have to write the same boilerplate code over and over again. It would be better to abstract the common behavior into a single place.
Note: This proposal lacks a handy way to specify what attributes should be placed on the property. For instance, we have to be able to say how the property should be serialized.
IDEA: Property tear-offs. We could obtain an object that represents a property, and lets you call its getter or setter explicitly:
Dim w = AddressOf x.Width
Dim i = w.Get()
IDEA: Custom event templates. The same "custom property template" idea above could be applied to "custom event templates", where there is also a lot of boiler-plate code.
These ideas are only half-baked as yet. We recognize that there is tremendous user demand for custom property templates, but we don't think we've hit upon the best solution yet. Please, write back to say whether these ideas would accomodate the kinds of properties that you want. And if you have better ideas for custom property templates, please write with them.
Unanswered questions: would custom event templates help with WPF routed events? would joins in the style of "Concurrent Basic" be expressible using custom event templates?
There's also a big question: could all of this be better handled by the IDE? Maybe we could use IDE projection-buffers, or "snippets on steroids".
Finally, note that the trick to obtain "propName" from MethodBase.GetCurrentMethod is a bit ugly: it prevents inlining and requires you to put it inside the property itself. One idea here I'll blog about later today, "Power6: __CALLER_MEMBER__". It might be better to always pass the property's name as a string to the getter/setter, or somehow to the constructor.
Provisional evaluation from VB team: There's a decent idea lurking here, worth considering against the other ideas, but only if we're confident that we can design this one right.