Reflective programming is a very common, powerful, yet expensive software development practice. In most modern programming languages reflection can not be utilized to modify private members of an object, which is to be expected. However in certain circumstances, such as when developing very high level frameworks and automation APIs it may be beneficial at times to be have the ability to access private members of an object from outside of the public API of the class.
For instance, consider the following class definition:
// User class does not define setter functions for
// the private members _username and _password
package com.ericfeminella.example
{
public class User
{
private var _username:String;
private var _password:String;
public function User(username:String, password:String)
{
this._username = username;
this._password = password;
}
public function get username() : String
{
return this._username;
}
public function get password() : String
{
return this._username;
}
}
}
The above class defines two private members: _username and _password. The public API of this class exposes these properties via the read-only accessors get username and get password. Per design assignments to these properties can only be made via the instance constructor.
So how can these values be modified once the object has been instantiated? More importantly, should this be allowed as the properties have not been publicly exposed? Theoretically they can not, philosophically they shouldn’t. All of this is debatable; however as a dynamic programming language ActionScript can easily accomplish accessing and modifying private members of an object which have not been exposed.
To do so is simple: define a method which provides an interface into the private members of the class instance, as in the following example:
// static method which provides a mechanism allowing
// private properties to be modified
public static function modifyMember(instance:User,
property:String,
value:*) : void
{
try {
instance[property] = value;
}
catch(error:ReferenceError)
{
throw new ArgumentError(property+not defined by+User);
}
}
The above example is pretty straightforward. It is simply a static method which requires 3 arguments. The first being the instance of the class, the second is the property in which to assign a new value, and the third is the value to assign to the property. This static method can be defined in any class and will work fine - you only need to change the type of the instance argument and error message to match the type of the class in which the method is defined. All methods in a class definition have access to any member of the class therefore assignments can be made to an instance of the class via a static method. This is possible in most object oriented languages such as C# and Java, however ActionScript takes this approach into the dynamic realm thus making it much more robust as the actual properties which are to be modified can be specified at runtime.
This approach can just as easily be accomplished on the instance level as well via an instance method, as in the following:
// instance method which provides a mechanism allowing
// private properties to be modified
public function modifyMember(property:String, value:*) : void
{
try {
this[property] = value;
}
catch(error:ReferenceError)
{
throw new ArgumentError(property + not defined by+this);
}
}
A client implementation for each would be as follows:
var vo:User = new User("foo", "bar");
trace( vo.username ); // foo
trace( vo.password ); // bar
// static implementation
User.modifyMember( vo, "_username ", "efeminella" );
trace( vo.username ); // efeminella
// instance implementation
vo.modifyMember( "_username ", "admin" );
trace( vo.username ); // admin
This approach is best suited for assigning values to simple types, or for pointing reference types to other object instances. This does not allow nested properties of a member to be accessed or modified (although it could easily be refactored to do so). Most importantly, (as you may be thinking) this breaks encapsulation and violates information hiding; therefore I do not recommend utilizing this approach for general use, however it is a convenient and efficient way to modify objects when developing complex APIs which use reflection and also for implementing Unit Tests directly against private members.
Initially I was introduced to the static implementation of this technique by a .Net developer on my team, and admittedly I was somewhat skeptical at first, however given the dynamic nature of ActionScript I realized this could open up some interesting possibilities under unique circumstances, similar to how mixins open up many possibilities - when used with discretion in a good design they both provide powerful advantages over other languages.
Food for thought. Enjoy.