DIP6: Attributes

[Benji Smith]

Steven Schveighoffer wrote:
> Annotations have more usages than just how to serialize.  Some uses I've 
> seen in C#:
> 
> * hints to an IDE about a GUI component (what it does, what properties 
> to allow setting via the visual builder)
> * hints to the debugger about when to skip debugging certain functions 
> (to avoid stepping into mundane crap such as property getters).
> * hints to another program about which classes would be interesting when 
> dynamically loading a library

In Actionscript (and the Flex framework), one very handy use of 
annotations is to mark a public field as "bindable".

    class MyClass {

       [Bindable]
       public var MyField:int = 0;

    }

In this example, whenever the "MyField" value is updated, a 
property-change event will be send to all listeners. The XML-based Flex 
framework uses those annotations to create (unidirectional or 
bidirectional) bindings between variables.

     <Window>
         <HSlider id="mySlider"/>
         <Image
            source="..."
            width="{mySlider.value}"
            height="{mySlider.value}"
         />
     </Window>

This creates a window with two controls, a horizontal numeric slider and 
an image. Whenever the user drags the slider control, the width and 
height of the image automatically update themselves.

The reason this works is that the "value" field of the "HSlider"
object is marked with the "Bindable" annotation. The compiler silently 
converts the field into a property getter/setter pair, and the setter 
sends out property-change events whenever called.

(Good thing Actionscript properties exist, with a syntax identical to 
normal fields, or else the automatic data binding wouldn't work!)

The cool thing that makes this work is that the compiler can perform 
code transformation based on the existence of various annotations.

--benji