ActiveSharp Wiki & Documentation Rss Feed

Updated Wiki: Using ActiveSharp from VB

johnrusk — Wed, 24 Dec 2008 04:28:51 GMT

This is a VB.NET translation of using ActiveSharp's PropertyChangeHelper from VB.NET. It was kindly sent in by Andrew Backer.

    Private _propertyChangeHelper As New PropertyChangeHelper
    Public Custom Event PropertyChanged As PropertyChangedEventHandler _
        Implements INotifyPropertyChanged.PropertyChanged
        AddHandler(ByVal value As PropertyChangedEventHandler)
            _propertyChangeHelper.Add(value)
        End AddHandler
        RemoveHandler(ByVal value As PropertyChangedEventHandler)
            _propertyChangeHelper.Remove(value)
        End RemoveHandler
        RaiseEvent(ByVal sender As Object, ByVal e As PropertyChangedEventArgs)
             '-- empty! (this is the key to doing it VB - you must write RaiseEvent, but since the helper raises
             ' the event, you don't have to do anything here yourself)
        End RaiseEvent
    End Event
    Public Sub SetValue(Of t)(ByRef field As t, ByVal value As t)
        _propertyChangeHelper.SetValue(Me, field, value)
    End Sub

Updated Wiki: Using ActiveSharp from VB

johnrusk — Tue, 23 Dec 2008 07:37:35 GMT

This is a VB.NET translation of using ActiveSharp's PropertyChangeHelper from VB.NET. It was kindly sent in by an ActiveSharp user.

    Private _propertyChangeHelper As New PropertyChangeHelper
    Public Custom Event PropertyChanged As PropertyChangedEventHandler _
        Implements INotifyPropertyChanged.PropertyChanged
        AddHandler(ByVal value As PropertyChangedEventHandler)
            _propertyChangeHelper.Add(value)
        End AddHandler
        RemoveHandler(ByVal value As PropertyChangedEventHandler)
            _propertyChangeHelper.Remove(value)
        End RemoveHandler
        RaiseEvent(ByVal sender As Object, ByVal e As PropertyChangedEventArgs)
             '-- empty! (this is the key to doing it VB - you must write RaiseEvent, but since the helper raises
             ' the event, you don't have to do anything here yourself)
        End RaiseEvent
    End Event
    Public Sub SetValue(Of t)(ByRef field As t, ByVal value As t)
        _propertyChangeHelper.SetValue(Me, field, value)
    End Sub

Updated Wiki: Home

johnrusk — Tue, 23 Dec 2008 07:35:33 GMT

Project Description
Send property change notifications without specifying property name as a string. Instead, write properties like this

public int Foo
{
get { return _foo; }
set { SetValue(ref _foo, value); } <-- no property name here
}

Note that there is no need to include the name of the property as a string. ActiveSharp reliably and correctly figures that out for itself. You can easily use it to automate the implementation of INotifyPropertyChanged.

Also useful in OR Mapping and other frameworks where you need to reliably detect changes in property values for other reasons. It does so without resorting to runtime-sublassing or other traditional AOP techniques.

Effectively ActiveSharp amounts to a brand-new technique for interception/AOP (for properties only).

It works by one-off runtime inspection of the MSIL in property setter methods, and a special routine to identify a field simply by passing it as a 'by ref' parameter.

(This apporach is much faster and more reliable than inspecting call stacks, which is a commonly-quoted, but flawed, alternative).

It is implemented as a number of independent classes which you can mix and match for your own purposes (e.g. you could use the MSIL inspection engine for your own purposes, quite separately from the property change stuff. Or you could detect property changes for your own purposes, without necessarily raising change notification events).

Requires .NET 2.0 or later.

Implementing INotifyPropertyChanged

Option 1: The easiest way is to use ActiveSharp's PropertyChangeHelper:

Add this code to your class or (preferrably) to a base class:

    readonly PropertyChangeHelper _propertyChangeHelper = new PropertyChangeHelper();
    public event PropertyChangedEventHandler PropertyChanged
    {
        add { _propertyChangeHelper.Add(value); }
        remove { _propertyChangeHelper.Remove(value); }
    }
            
    protected void SetValue<T>(ref T field, T value)
    {
        _propertyChangeHelper.SetValue(this, ref field, value);
    }

Also, add INotifyPropertyChanged to your base class' list of ancestors. Now, you have a base class that provides all the support for derived classes to sent property changed notifications really easily.

In your derived classes, simply implement your properties like this:

    public int Foo
    {
        get { return _foo; }
        set { SetValue(ref _foo, value); }   // assigns value and does prop change notification, all in one line

    }

Note: a reader kindly wrote in with this translation of the code to VB.NET.

Option 2:

If you want more control, you can write your own SetValue method, instead of delegating to the helper class. Someting like this:

    protected void SetValue<T>(ref T field, T value)
    {
        ...
        field = value;   //Actually assign the new value

        PropertyInfo changedProperty = 
               ActiveSharp.PropertyMapping.PropertyMap.GetProperty(this, ref field);
        // do whatever you like, now that you know which prop was changed

        ...
    }

As you can see, all the "magic" is in ActiveSharp.PropertyMapping.PropertyMap.GetProperty. Given an object, and a field in that object, passed "by ref", the routine finds the property that sets the field. It returns a standard .NET PropertyInfo object. Just read its Name property if all you want is the property name.

For more details see:

A page on: How it works

Dicsussion thread here for discussion of other things you can do with ActiveSharp, and how it compares with the alternatives.

Blog posts here and here (including the comments)

Updated Wiki: Using ActiveSharp from VB

johnrusk — Tue, 23 Dec 2008 07:34:22 GMT

    Private _propertyChangeHelper As New PropertyChangeHelper
    Public Custom Event PropertyChanged As PropertyChangedEventHandler _
        Implements INotifyPropertyChanged.PropertyChanged
        AddHandler(ByVal value As PropertyChangedEventHandler)
            _propertyChangeHelper.Add(value)
        End AddHandler
        RemoveHandler(ByVal value As PropertyChangedEventHandler)
            _propertyChangeHelper.Remove(value)
        End RemoveHandler
        RaiseEvent(ByVal sender As Object, ByVal e As PropertyChangedEventArgs)
             '-- empty! (this is the key to doing it VB - you must write RaiseEvent, but since the helper raises
             ' the event, you don't have to do anything here yourself)
        End RaiseEvent
    End Event
    Public Sub SetValue(Of t)(ByRef field As t, ByVal value As t)
        _propertyChangeHelper.SetValue(Me, field, value)
    End Sub

Updated Wiki: Home

johnrusk — Tue, 23 Dec 2008 07:31:05 GMT

    readonly PropertyChangeHelper _propertyChangeHelper = new PropertyChangeHelper();
 
    public event PropertyChangedEventHandler PropertyChanged
    {
        add { _propertyChangeHelper.Add(value); }
        remove { _propertyChangeHelper.Remove(value); }
    }
            
    protected void SetValue<T>(ref T field, T value)
    {
        _propertyChangeHelper.SetValue(this, ref field, value);
    }

    public int Foo
    {
        get { return _foo; }
        set { SetValue(ref _foo, value); }   // assigns value and does prop change notification, all in one line
    }

    protected void SetValue<T>(ref T field, T value)
    {
        ...
        field = value;   //Actually assign the new value
        PropertyInfo changedProperty = 
               ActiveSharp.PropertyMapping.PropertyMap.GetProperty(this, ref field);
        // do whatever you like, now that you know which prop was changed
        ...
    }

UPDATED WIKI: How it works

johnrusk — Sat, 24 May 2008 21:55:05 GMT

I've been meaning to write the page for a while, but haven't found time. So, at last, here's a very quick summary of how ActiveSharp works.

When you set a property value

Property setter method calls the SetValue method which you defined (typically on your base class). By the way, it doesn't have to be called SetValue, you can call it anything.
SetValue passes "this" and the field being set (by ref) to ActiveSharp.PropertyMapping.PropertyMap.GetProperty.
GetProperty calls a special routine which computes the difference between the memory locations of the "this" pointer and the field, like so:

Briefly pin the object in memory, so the garbage collector won't move it while we are working
Cast the "this" pointer to an untyped pointer (i.e. a raw memory address)
Cast the field's location to an untyped pointer (again, a raw memory address). We can do this only because we recieved the field "by ref"
Subtract one raw memory address from the other, to give an "offset value" - i.e. the field's unique position within it's containing object
Unpin the object (total duration of the pinning is very short)

Use the offset value to look up the field name. We do this lookup in a hashtable that we prepared earlier (see below).
Use the field name to look up the property. Again, we do this in a hashtable that we prepared earlier (see below)
Now we have the property. DONE

(Note: the two hashtable lookups at the end may be optimized away in a future code change)

One-off setup

ActiveSharp automatically initializes itself at runtime. There are three things to initialize:

1. The offset calculation routine

If you were thinking that its difficult to cast things to raw memory addresses in C#, you'd be right. In fact, it's impossible. My first version of this code used C++ / CLI instead, but even that couldn't cast a "this" pointer (it could only do fields). The older "Managed Extensions" for C++ can cast the this pointer.

However, to save messing around with assemblies written in other languages, what ActiveSharp actually does is it generates the necessary routine at runtime, by creating the raw MSIL with Reflection.Emit. That lets us use a pure C# solution to do something that actually can't be done in C# ;-)

We make this routine once, the first time that ActiveSharp is used, and then we hold onto it for all future use.

2. The hash table that maps offsets to fields

We need one hash table for each class in which ActiveSharp is used (i.e. each different class which SetValue passes as the "this" pointer). ActiveSharp intializes the hash table lazily, building the table for a given type the first time it is needed. (By the way, writing the lazy initialization support was interesting, due to threadsafety issues. I wrote the classes LazyDictionary and LazyDictionaryOfTypes, and made them re-usable for other cases that need lazy initialization e.g. you can use them outside ActiveSharp).

We build it by passing every field in the object to our offset finder method and seeing what offset number it returns. The returned number becomes the key in the hash table and the field name becomes the value.

How do we pass every field, especially of they are private fields? We use Lightweight Code Gen since, unlike standard Reflection Emil, LGC can access private fields (given appropriate reflection permissions).

3. The hash table that maps fields to properties

For this, we inspect the MSIL of the property setter methods, to see which field is set by each one. We can do this because, as of .NET 2.0, we can get method bodies at runtime in MSIL form. We scan the MSIL instructions, with a very basic parsing algorithm, to find out what we need to know.

----
Any questions - leave a comment or email me

UPDATED WIKI: How it works

johnrusk — Sat, 24 May 2008 21:52:36 GMT

I've been meaning to write the page for a while, but haven't found time. So, at last, here's a very quick summary of how ActiveSharp works.

When you set a property value

Property setter method calls the SetValue method which you defined (typically on your base class). By the way, it doesn't have to be called SetValue, you can call it anything.
SetValue passes "this" and the field being set (by ref) to ActiveSharp.PropertyMapping.PropertyMap.GetProperty.
GetProperty calls a special routine which computes the difference between the memory locations of the "this" pointer and the field, like so:

Briefly pin the object in memory, so the garbage collector won't move it while we are working
Cast the "this" pointer to an untyped pointer (i.e. a raw memory address)
Cast the field's location to an untyped pointer (again, a raw memory address). We can do this only because we recieved the field "by ref"
Subtract one raw memory address from the other, to give an "offset value" - i.e. the field's unique position within it's containing object
Unpin the object (total duration of the pinning is very short)

Use the offset value to look up the field name. We do this lookup in a hashtable that we prepared earlier (see below).
Use the field name to look up the property. Again, we do this in a hashtable that we prepared earlier (see below)
Now we have the property. DONE

(Note: the two hashtable lookups at the end may be optimized away in a future code change)

One-off setup

ActiveSharp automatically initializes itself at runtime. There are three things to initialize:

The offset calculation routine

The hash table that maps offsets to fields

The hash table that maps fields to properties

UPDATED WIKI: Home

johnrusk — Sat, 24 May 2008 04:05:25 GMT

Project Description
Send property change notifications without specifying property name as a string. Instead, write properties like this

public int Foo
{
get { return _foo; }
set { SetValue(ref _foo, value); } <-- no property name here
}

Note that there is no need to include the name of the property as a string. ActiveSharp reliably and correctly figures that out for itself. You can easily use it to automate the implementation of INotifyPropertyChanged.

Also useful in OR Mapping and other frameworks where you need to reliably detect changes in property values (without resorting to runtime-sublassing or other traditional AOP techniques).

Effectively ActiveSharp amounts to a brand-new technique for interception/AOP (for properties only).

It works by one-off runtime inspection of the MSIL in property setter methods, and a special routine to identify a field simply by passing it as a 'by ref' parameter.

(This apporach is much faster and more reliable than inspecting call stacks, which is a commonly-quoted, but flawed, alternative).

It is implemented as a number of independent classes which you can mix and match for your own purposes (e.g. you could use the MSIL inspection engine for your own purposes, quite separately from the property change stuff. Or you could detect property changes for your own purposes, without necessarily raising change notification events).

Requires .NET 2.0 or later.

Implementing INotifyPropertyChanged

Option 1: The easiest way is to use ActiveSharp's PropertyChangeHelper:

Add this code to your class or (preferrably) to a base class:

    readonly PropertyChangeHelper _propertyChangeHelper = new PropertyChangeHelper();
 
    public event PropertyChangedEventHandler PropertyChanged
    {
        add { _propertyChangeHelper.Add(value); }
        remove { _propertyChangeHelper.Remove(value); }
    }
            
    protected void SetValue<T>(ref T field, T value)
    {
        _propertyChangeHelper.SetValue(this, ref field, value);
    }

    public int Foo
    {
        get { return _foo; }
        set { SetValue(ref _foo, value); }   // assigns value and does prop change notification, all in one line
    }

Option 2:

If you want more control, you can write your own SetValue method, instead of delegating to the helper class. Someting like this:

    protected void SetValue<T>(ref T field, T value)
    {
        ...
        field = value;   //Actually assign the new value
        PropertyInfo changedProperty = 
               ActiveSharp.PropertyMapping.PropertyMap.GetProperty(this, ref field);
        // do whatever you like, now that you know which prop was changed
        ...
    }

UPDATED WIKI: How it works

johnrusk — Sat, 24 May 2008 04:04:30 GMT

I've been meaning to write the page for a while, but haven't found time. So, at last, here's a very quick summary of how ActiveSharp works.

When you set a property value

Property setter method calls the SetValue method which you defined (typically on your base class). By the way, it doesn't have to be called SetValue, you can call it anything.
SetValue passes "this" and the field being set (by ref) to ActiveSharp.PropertyMapping.PropertyMap.GetProperty.
GetProperty calls a special routine which computes the difference between the memory locations of the "this" pointer and the field, like so:

Briefly pin the object in memory, so the garbage collector won't move it while we are working
Cast the "this" pointer to an untyped pointer (i.e. a raw memory address)
Cast the field's location to an untyped pointer (again, a raw memory address). We can do this only because we recieved the field "by ref"
Subtract one raw memory address from the other, to give an "offset value" - i.e. the field's unique position within it's containing object
Unpin the object (total duration of the pinning is very short)

Use the offset value to look up the field name. We do this lookup in a hashtable that we prepared earlier (see below).
Use the field name to look up the property. Again, we do this in a hashtable that we prepared earlier (see below)
Now we have the property. DONE

One-off setup

ActiveSharp automatically initializes itself at runtime. There are three things to initialize:

The offset calculation routine

The hash table that maps offsets to fields

The hash table that maps fields to properties

UPDATED WIKI: How it works

johnrusk — Sat, 24 May 2008 04:03:48 GMT

I've been meaning to write the page for a while, but haven't found time. So, at last, here's a very quick summary of how ActiveSharp works.

When you set a property value

Property setter method calls the SetValue method which you defined (typically on your base class). By the way, it doesn't have to be called SetValue, you can call it anything.
SetValue passes "this" and the field being set (by ref) to ActiveSharp.PropertyMapping.PropertyMap.GetProperty.
GetProperty calls a special routine which computes the difference between the memory locations of the "this" pointer and the field, like so:

Briefly pin the object in memory, so the garbage collector won't move it while we are working
Cast the "this" pointer to an untyped pointer (i.e. a raw memory address)
Cast the field's location to an untyped pointer (again, a raw memory address). We can do this only because we recieved the field "by ref"
Subtract one raw memory address from the other, to give an "offset value" - i.e. the field's unique position within it's containing object
Unpin the object (total duration of the pinning is very short)

Use the offset value to look up the field name. We do this lookup in a hashtable that we prepared earlier (see below).
Use the field name to look up the property. Again, we do this in a hashtable that we prepared earlier (see below)
Now we have the property. DONE

One-off setup

ActiveSharp automatically initializes itself at runtime. There are three things to initialize:

The offset calculation routine

The hash table that maps offsets to fields

The hash table that maps fields to properties

UPDATED WIKI: How it works

johnrusk — Sat, 24 May 2008 03:59:21 GMT

I've been meaning to write the page for a while, but haven't found time. So, at last, here's a very quick summary of how ActiveSharp works.

When you set a property value

Property setter method calls the SetValue method which you defined (typically on your base class). By the way, it doesn't have to be called SetValue, you can call it anything.
SetValue passes "this" and the field being set (by ref) to ActiveSharp.PropertyMapping.PropertyMap.GetProperty.
GetProperty calls a special routine which computes the difference between the memory locations of the "this" pointer and the field, like so:

Briefly pin the object in memory, so the garbage collector won't move it while we are working
Cast the "this" pointer to an untyped pointer (i.e. a raw memory address)
Cast the field's location to an untyped pointer (again, a raw memory address). We can do this only because we recieved the field "by ref"
Subtract one raw memory address from the other, to give an "offset value" - i.e. the field's unique position within it's containing object
Unpin the object (total duration of the pinning is very short)

Use the offset value to look up the field name. We do this lookup in a hashtable that we prepared earlier (see below).
Use the field name to look up the property. Again, we do this in a hashtable that we prepared earlier (see below)
Now we have the property. DONE

One-off setup

ActiveSharp automatically initializes itself at runtime. There are three things to initialize:

The offset calculation routine

The hash table that maps offsets to fields

We need one hash table for each class in which ActiveSharp is used (i.e. each different class which SetValue passes as the "this" pointer). ActiveSharp intializes the hash table lazily, building the table for a given type the first time it is needed.

We build it by passing every field in the object to our offset finder method and seeing what offset number it returns. The returned number becomes the key in the hash table and the field name becomes the value.

How do we pass every field, especially of they are private fields? We use Lightweight Code Gen since, unlike standard Reflection Emil, LGC can access private fields (given appropriate reflection permissions).

The hash table that maps fields to properties

For this, we inspect the MSIL of the property setter methods, so see which field is set by each one. We can do this because, as of .NET 2.0, we can get method bodies at runtime in MSIL form. We scan the MSIL instructions, with a very basic parsing algorithm, to find out what we need to know.

----
Any questions - leave me a note on the Discussions tab, or email me

UPDATED WIKI: How it works

johnrusk — Sat, 24 May 2008 03:58:43 GMT

I've been meaning to write the page for a while, but haven't found time. So, at last, here's a very quick summary of how ActiveSharp works.

When you set a property value

Property setter method calls the SetValue method which you defined (typically on your base class). By the way, it doesn't have to be called SetValue, you can call it anything.
SetValue passes "this" and the field being set (by ref) to ActiveSharp.PropertyMapping.PropertyMap.GetProperty.
GetProperty calls a special routine which computes the difference between the memory locations of the "this" pointer and the field, like so:

Briefly pin the object in memory, so the garbage collector won't move it while we are working
Cast the "this" pointer to an untyped pointer (i.e. a raw memory address)
Cast the field's location to an untyped pointer (again, a raw memory address). We can do this only because we recieved the field "by ref"
Subtract one raw memory address from the other, to give an "offset value" - i.e. the field's unique position within it's containing object
Unpin the object (total duration of the pinning is very short)

Use the offset value to look up the field name. We do this lookup in a hashtable that we prepared earlier (see below).
Use the field name to look up the property. Again, we do this in a hashtable that we prepared earlier (see below)
Now we have the property. DONE

One-off setup

ActiveSharp automatically initializes itself at runtime. There are three things to initialize:

The offset calculation routine

If you were thinking that its difficult to cast things to raw memory addresses in C#, you'd be right. In fact, it's impossible. My first version of this code used C+/CLI instead, but even that couldn't cast a "this" pointer (it could only do fields). The older "Managed Extensions" for C+ can cast the this pointer.

However, to save messing around with assemblies written in other languages, what ActiveSharp actually does is it generates the necessary routine at runtime, by creating the raw MSIL with Reflection.Emit. That lets us use a pure C# solution to do something that actually can't be done in C# ;-)

We make this routine once, the first time that ActiveSharp is used, and then we hold onto it for all future use.

The hash table that maps offsets to fields

We need one hash table for each class in which ActiveSharp is used (i.e. each different class which SetValue passes as the "this" pointer). ActiveSharp intializes the hash table lazily, building the table for a given type the first time it is needed.

We build it by passing every field in the object to our offset finder method and seeing what offset number it returns. The returned number becomes the key in the hash table and the field name becomes the value.

How do we pass every field, especially of they are private fields? We use Lightweight Code Gen since, unlike standard Reflection Emil, LGC can access private fields (given appropriate reflection permissions).

The hash table that maps fields to properties

UPDATED WIKI: How it works

johnrusk — Sat, 24 May 2008 03:56:49 GMT

I've been meaning to write the page for a while, but haven't found time. So, at last, here's a very quick summary of how ActiveSharp works.

When you set a property value

Property setter method calls the SetValue method which you defined (typically on your base class). By the way, it doesn't have to be called SetValue, you can call it anything.
SetValue passes "this" and the field being set (by ref) to ActiveSharp.PropertyMapping.PropertyMap.GetProperty.
GetProperty calls a special routine which computes the difference between the memory locations of the "this" pointer and the field, like so:

Briefly pin the object in memory, so the garbage collector won't move it while we are working
Cast the "this" pointer to an untyped pointer (i.e. a raw memory address)
Cast the field's location to an untyped pointer (again, a raw memory address). We can do this only because we recieved the field "by ref"
Subtract one raw memory address from the other, to give an "offset value" - i.e. the field's unique position within it's containing object
Unpin the object (total duration of the pinning is very short)

Use the offset value to look up the field name. We do this lookup in a hashtable that we prepared earlier (see below).
Use the field name to look up the property. Again, we do this in a hashtable that we prepared earlier (see below)
Now we have the property. DONE

One-off setup

ActiveSharp automatically initializes itself at runtime. There are three things to initialize:

The offset calculation routine

The hash table that maps offsets to fields

We need one hash table for each class in which ActiveSharp is used (i.e. each different class which SetValue passes as the "this" pointer). ActiveSharp intializes the hash table lazily, building the table for a given type the first time it is needed.

We build it by passing every field in the object to our offset finder method and seeing what offset number it returns. The returned number becomes the key in the hash table and the field name becomes the value.

How do we pass every field, especially of they are private fields? We use Lightweight Code Gen since, unlike standard Reflection Emil, LGC can access private fields (given appropriate reflection permissions).

The hash table that maps fields to properties

UPDATED WIKI: How it works

johnrusk — Sat, 24 May 2008 03:55:49 GMT

I've been meaning to write the page for a while, but haven't found time. So, here's a very quick summary of how ActiveSharp works.

When you set a property value

Property setter method calls the SetValue method which you defined (typically on your base class). By the way, it doesn't have to be called SetValue, you can call it anything.
SetValue passes "this" and the field being set (by ref) to ActiveSharp.PropertyMapping.PropertyMap.GetProperty.
GetProperty calls a special routine which computes the difference between the memory locations of the "this" pointer and the field, like so:

Briefly pin the object in memory, so the garbage collector won't move it while we are working
Cast the "this" pointer to an untyped pointer (i.e. a raw memory address)
Cast the field's location to an untyped pointer (again, a raw memory address). We can do this only because we recieved the field "by ref"
Subtract one raw memory address from the other, to give an "offset value" - i.e. the field's unique position within it's containing object
Unpin the object (total duration of the pinning is very short)

Use the offset value to look up the field name. We do this lookup in a hashtable that we prepared earlier (see below).
Use the field name to look up the property. Again, we do this in a hashtable that we prepared earlier (see below)
Now we have the property. DONE

One-off setup

ActiveSharp automatically initializes itself at runtime. There are three things to initialize:

The offset calculation routine

If you were thinking that its difficult to cast things to raw memory addresses in C#, you'd be right. In fact, it's impossible. url=My first version of this code used C++ / CLI instead, but even that couldn't cast a "this" pointer (it could only do fields). The older "Managed Extensions" for C++ can cast the this pointer.

However, to save messing around with assemblies written in other languages, what ActiveSharp actually does is it generates the necessary routine at runtime, by creating the raw MSIL with Reflection.Emit. That lets us use a pure C# solution to do something that actually can't be done in C# ;-)

We make this routine once, the first time that ActiveSharp is used, and then we hold onto it for all future use.

The hash table that maps offsets to fields

We need one hash table for each class in which ActiveSharp is used (i.e. each different class which SetValue passes as the "this" pointer). ActiveSharp intializes the hash table lazily, building the table for a given type the first time it is needed.

We build it by passing every field in the object to our offset finder method and seeing what offset number it returns. The returned number becomes the key in the hash table and the field name becomes the value.

How do we pass every field, especially of they are private fields? We use url=Lightweight Code Gen since, unlike standard Reflection Emil, LGC can access private fields (given appropriate reflection permissions).

The hash table that maps fields to properties

UPDATED WIKI: How it works

johnrusk — Sat, 24 May 2008 03:53:46 GMT

I've been meaning to write the page for a while, but haven't found time. So, here's a very quick summary of how ActiveSharp works.

When you set a property value

Property setter method calls the SetValue method which you defined (typically on your base class). By the way, it doesn't have to be called SetValue, you can call it anything.
SetValue passes "this" and the field being set (by ref) to ActiveSharp.PropertyMapping.PropertyMap.GetProperty.
GetProperty calls a special routine which computes the difference between the memory locations of the "this" pointer and the field, like so:

Briefly pin the object in memory, so the garbage collector won't move it while we are working
Cast the "this" pointer to an untyped pointer (i.e. a raw memory address)
Cast the field's location to an untyped pointer (again, a raw memory address). We can do this only because we recieved the field "by ref"
Subtract one raw memory address from the other, to give an "offset value" - i.e. the field's unique position within it's containing object
Unpin the object (total duration of the pinning is very short)

Use the offset value to look up the field name. We do this lookup in a hashtable that we prepared earlier (see below).
Use the field name to look up the property. Again, we do this in a hashtable that we prepared earlier (see below)
Now we have the property. DONE

!One-off setup

ActiveSharp automatically initializes itself at runtime. There are three things to initialize:

The offset calculation routine

The hash table that maps offsets to fields

We need one hash table for each class in which ActiveSharp is used (i.e. each different class which SetValue passes as the "this" pointer). ActiveSharp intializes the hash table lazily, building the table for a given type the first time it is needed.

We build it by passing every field in the object to our offset finder method and seeing what offset number it returns. The returned number becomes the key in the hash table and the field name becomes the value.

How do we pass every field, especially of they are private fields? We use Lightweight Code Gen since, unlike standard Reflection Emil, LGC can access private fields (given appropriate reflection permissions).

The hash table that maps fields to properties

For this, we inspect the MSIL of the property setter methods, so see which field is set by each one. We can do this because, as of .NET 2.0, we can get method bodies at runtime in MSIL form. We scan the MSIL instructions, with a very basic parsing algorithm, to find out what we need to know.

Any questions - leave me a note on the Discussions tab, or email me

UPDATED WIKI: How it works

johnrusk — Sat, 24 May 2008 03:51:06 GMT

I've been meaning to write the page for a while, but haven't found time. So, here's a very quick summary of how ActiveSharp works.

When you set a property value

Property setter method calls the SetValue method which you defined (typically on your base class). By the way, it doesn't have to be called SetValue, you can call it anything.
SetValue passes "this" and the field being set (by ref) to ActiveSharp.PropertyMapping.PropertyMap.GetProperty.
GetProperty calls a special routine which computes the difference between the memory locations of the "this" pointer and the field, like so:

Briefly pin the object in memory, so the garbage collector won't move it while we are working
Cast the "this" pointer to an untyped pointer (i.e. a raw memory address)
Cast the field's location to an untyped pointer (again, a raw memory address). We can do this only because we recieved the field "by ref"
Subtract one raw memory address from the other, to give an "offset value" - i.e. the field's unique position within it's containing object
Unpin the object (total duration of the pinning is very short)

Use the offset value to look up the field name. We do this lookup in a hashtable that we prepared earlier (see below).
Use the field name to look up the property. Again, we do this in a hashtable that we prepared earlier (see below)
Now we have the property. DONE

!One-off setup

ActiveSharp automatically initializes itself at runtime. There are three things to initialize:

The offset calculation routine

The hash table that maps offsets to fields

We need one hash table for each class in which ActiveSharp is used (i.e. each different class which SetValue passes as the "this" pointer). ActiveSharp intializes the hash table lazily, building the table for a given type the first time it is needed.

We build it by passing every field in the object to our offset finder method and seeing what offset number it returns. The returned number becomes the key in the hash table and the field name becomes the value.

How do we pass every field, especially of they are private fields? We use Lightweight Code Gen since, unlike standard Reflection Emil, LGC can access private fields (given approprate reflection permissions).

The hash table that maps fields to properties

For this, we inspect the MSIL of the property setter methods, so see which field is set by each one. We can do this because, as of .NET 2.0, we can get method bodies at runtime in MSIL form. We scan the MSIL instructions, with a very basic parsing algorithm, to find out what we need to know.

Any questions - leave me a note on the Discussions tab, or email me.

UPDATED WIKI: How it works

johnrusk — Sat, 24 May 2008 03:37:43 GMT

I've been meaning to write the page for a while, but haven't found time. So, here's a very quick summary of how ActiveSharp works.

When you set a property value

Property setter method calls the SetValue method which you defined (typically on your base class). By the way, it doesn't have to be called SetValue, you can call it anything.
SetValue passes "this" and the field being set (by ref) to ActiveSharp.PropertyMapping.PropertyMap.GetProperty.
GetProperty calls a special routine which computes the difference between the memory locations of the "this" pointer and the field, like so:

Briefly pin the object in memory, so the garbage collector won't move it while we are working
Cast the "this" pointer to an untyped pointer (i.e. a raw memory address)
Cast the field's location to an untyped pointer (again, a raw memory address). We can do this only because we recieved the field "by ref"
Subtract one raw memory address from the other, to give an "offset value" - i.e. the field's unique position within it's containing object
Unpin the object (total duration of the pinning is very short)

Use the offset value to look up the field name. We do this lookup in a hashtable that we prepared earlier (see below).
Use the field name to look up the property. Again, we do this in a hashtable that we prepared earlier (see below)
DONE

UPDATED WIKI: Home

johnrusk — Sat, 24 May 2008 03:30:00 GMT

Project Description
Send property change notifications without specifying property name as a string. Instead, write properties like this

public int Foo
{
get { return _foo; }
set { SetValue(ref _foo, value); } <-- no property name here
}

Note that there is no need to include the name of the property as a string. ActiveSharp reliably and correctly figures that out for itself. You can easily use it to automate the implementation of INotifyPropertyChanged.

Also useful in OR Mapping and other frameworks where you need to reliably detect changes in property values (without resorting to runtime-sublassing or other traditional AOP techniques).

Effectively ActiveSharp amounts to a brand-new technique for interception/AOP (for properties only).

It works by one-off runtime inspection of the MSIL in property setter methods, and a special routine to identify a field simply by passing it as a 'by ref' parameter.

(This apporach is much faster and more reliable than inspecting call stacks, which is a commonly-quoted, but flawed, alternative).

It is implemented as a number of independent classes which you can mix and match for your own purposes (e.g. you could use the MSIL inspection engine for your own purposes, quite separately from the property change stuff. Or you could detect property changes for your own purposes, without necessarily raising change notification events).

Requires .NET 2.0 or later.

Implementing INotifyPropertyChanged

Option 1: The easiest way is to use ActiveSharp's PropertyChangeHelper:

Add this code to your class or (preferrably) to a base class:

    readonly PropertyChangeHelper _propertyChangeHelper = new PropertyChangeHelper();
 
    public event PropertyChangedEventHandler PropertyChanged
    {
        add { _propertyChangeHelper.Add(value); }
        remove { _propertyChangeHelper.Remove(value); }
    }
            
    protected void SetValue<T>(ref T field, T value)
    {
        _propertyChangeHelper.SetValue(this, ref field, value);
    }

    public int Foo
    {
        get { return _foo; }
        set { SetValue(ref _foo, value); }   // assigns value and does prop change notification, all in one line
    }

Option 2:

If you want more control, you can write your own SetValue method, instead of delegating to the helper class. Someting like this:

    protected void SetValue<T>(ref T field, T value)
    {
        ...
        field = value;   //Actually assign the new value
        PropertyInfo changedProperty = 
               ActiveSharp.PropertyMapping.PropertyMap.GetProperty(this, ref field);
        // do whatever you like, now that you know which prop was changed
        ...
    }

As you can see, all the "magic" is in ActiveSharp.PropertyMapping.PropertyMap.GetProperty. Given an object, and a field in that object, passed "by ref", the routine finds the property that sets the field. It returns a standard .NET PropertyInfo object. Just read its Name property if all you want is the property name.

For more details see:

How it works

Dicsussion thread here for discussion of other things you can do with ActiveSharp, and how it compares with the alternatives.

Blog posts here and here (including the comments)

UPDATED WIKI: Home

johnrusk — Sat, 24 May 2008 03:26:28 GMT

Project Description
Send property change notifications without specifying property name as a string. Instead, write properties like this

public int Foo
{
get { return _foo; }
set { SetValue(ref _foo, value); } <-- no property name here
}

Note that there is no need to include the name of the property as a string. ActiveSharp reliably and correctly figures that out for itself. You can easily use it to automate the implementation of INotifyPropertyChanged.

Also useful in OR Mapping and other frameworks where you need to reliably detect changes in property values (without resorting to runtime-sublassing or other traditional AOP techniques).

Effectively ActiveSharp amounts to a brand-new technique for interception/AOP (for properties only).

It works by one-off runtime inspection of the MSIL in property setter methods, and a special routine to identify a field simply by passing it as a 'by ref' parameter.

(This apporach is much faster and more reliable than inspecting call stacks, which is a commonly-quoted, but flawed, alternative).

It is implemented as a number of independent classes which you can mix and match for your own purposes (e.g. you could use the MSIL inspection engine for your own purposes, quite separately from the property change stuff. Or you could detect property changes for your own purposes, without necessarily raising change notification events).

Requires .NET 2.0 or later.

Implementing INotifyPropertyChanged

Option 1: The easiest way is to use ActiveSharp's PropertyChangeHelper:

Add this code to your class or (preferrably) to a base class:

    readonly PropertyChangeHelper _propertyChangeHelper = new PropertyChangeHelper();
 
    public event PropertyChangedEventHandler PropertyChanged
    {
        add { _propertyChangeHelper.Add(value); }
        remove { _propertyChangeHelper.Remove(value); }
    }
            
    protected void SetValue<T>(ref T field, T value)
    {
        _propertyChangeHelper.SetValue(this, ref field, value);
    }

    public int Foo
    {
        get { return _foo; }
        set { SetValue(ref _foo, value); }   // assigns value and does prop change notification, all in one line
    }

Option 2:

If you want more control, you can write your own SetValue method, instead of delegating to the helper class. Someting like this:

    protected void SetValue<T>(ref T field, T value)
    {
        ...
        field = value;   //Actually assign the new value
        PropertyInfo changedProperty = 
               ActiveSharp.PropertyMapping.PropertyMap.GetProperty(this, ref field);
        // do whatever you like, now that you know which prop was changed
        ...
    }

As you can see, all the "magic" is in ActiveSharp.PropertyMapping.PropertyMap.GetProperty. Given an object, and a field in that object, passed "by ref", the routine finds the property that sets the field.

For more details see:

How it works

Dicsussion thread here for discussion of other things you can do with ActiveSharp, and how it compares with the alternatives.

Blog posts here and here (including the comments)

UPDATED WIKI: Home

johnrusk — Fri, 11 Apr 2008 21:35:32 GMT

Project Description
Send property change notifications without specifying property name as a string. Instead, write properties like this

public int Foo
{
get { return _foo; }
set { SetValue(ref _foo, value); } <-- no property name here
}

Note that there is no need to include the name of the property as a string. ActiveSharp reliably and correctly figures that out for itself. You can easily use it to automate the implementation of INotifyPropertyChanged.

Also useful in OR Mapping and other frameworks where you need to reliably detect changes in property values (without resorting to runtime-sublassing or other traditional AOP techniques).

Effectively ActiveSharp amounts to a brand-new technique for interception/AOP (for properties only).

It works by one-off runtime inspection of the MSIL in property setter methods, and a special routine to identify a field simply by passing it as a 'by ref' parameter.

(This apporach is much faster and more reliable than inspecting call stacks, which is a commonly-quoted, but flawed, alternative).

It is implemented as a number of independent classes which you can mix and match for your own purposes (e.g. you could use the MSIL inspection engine for your own purposes, quite separately from the property change stuff. Or you could detect property changes for your own purposes, without necessarily raising change notification events).

Requires .NET 2.0 or later.

Implementing INotifyPropertyChanged

Option 1: The easiest way is to use ActiveSharp's PropertyChangeHelper:

Add this code to your class or (preferrably) to a base class:

    readonly PropertyChangeHelper _propertyChangeHelper = new PropertyChangeHelper();
 
    public event PropertyChangedEventHandler PropertyChanged
    {
        add { _propertyChangeHelper.Add(value); }
        remove { _propertyChangeHelper.Remove(value); }
    }
            
    protected void SetValue<T>(ref T field, T value)
    {
        _propertyChangeHelper.SetValue(this, ref field, value);
    }

    public int Foo
    {
        get { return _foo; }
        set { SetValue(ref _foo, value); }   // assigns value and does prop change notification, all in one line
    }

Option 2:

If you want more control, you can write your own SetValue method, instead of delegating to the helper class. Someting like this:

    protected void SetValue<T>(ref T field, T value)
    {
        ...
        field = value;   //Actually assign the new value
        PropertyInfo changedProperty = 
               ActiveSharp.PropertyMapping.PropertyMap.GetProperty(this, ref field);
        // do whatever you like, now that you know which prop was changed
        ...
    }

For more details see:

Dicsussion thread here for discussion of other things you can do with ActiveSharp, and how it compares with the alternatives.

Blog posts here and here (including the comments)