How To Auto Generate Properties Dynamically For All Your Classes Using Magic Methods & Reflection

What I Want To Achieve

• When coding a project, at times (or most of it?) some classes might have more than 3 fields (for whatever reason it suits you)
• So instead of each time writing and repeating setters and getters (accessor methods), I would like to have a piece of reusable code for all my classes without me ever writing a single line of code for accessors. (‘ever’ as in ‘very very rarely’)
• Now, we also have to take into consideration that some fields might be only get-able or  only set-able – (our re-usable piece of code should cater for this)

So how to achieve this?

1. Using PHP’s magic methods __get() and __set() coupled with Reflection. This will somehow imitate a Property as used in the context of Csharp or JAVA.
2. Design-wise, I will provide TWO approaches using either Trait or Inheritance

First thing first, let’s understand some concepts..

What are Field and Property in the context of PHP

From PHP online doc, it defines a property as:

Class member variables are called “properties”. You may also see them referred to using other terms such as “attributes” or “fields”

Let’s take a simple example:

class Person
{
....private $name;

....public function setName($name_provided) //setter method
....{
........$this->name = $name_provided;
....}

....public function getName() //getter method
....{
........return $this->name;
....}
}//end class

In the code example above, in PHP:

• the class variable $name is called a field or a property
• the class methods setName() and getName() are called accessor methods which otherwise are known as setter and getter methods respectively

To use this class, I would do:

$obj = new Person();
$obj->setName(“Wasseem”);
echo ‘My name is: ‘. $obj->getName(); //will print: My name is Wasseem

What are Field and Property in a C# (csharp) context

If you do C# (or even JAVA), these two terminologies are different. Let me explain..
Let’s try to translate PHP code into C# code:

class Person
{
....private String name;

....public String Name
....{
........get
........{
............return this.name;
........}
........set
........{
............this.name = value;
........}
....}//end Name
}//end class

In this C# example:

1. the class variable name (with the small letter ‘n’) is called a field
2. the class method Name (with a Capital letter ‘N’) is known as a Property and it acts as a single call to handle both accessor methods setter/getter

So in C#, you define a field. Then to provide it’s corresponding accessor methods in a simple and elegant way is to define a single method known and called as Property which will have the same naming as the field BUT with the starting letter being in Capital letter.

To use this class, I would do something like:

Person obj = new Person();
obj.name = “Wasseem”;
Console.WriteLine( ‘My name is: ‘ + obj.name ); //will print: My name is Wasseem

What I Want To Point Out..

What I want to point out is that if in C# we can quickly set and get a field by just using a one way call in the form ObjectInstance.fieldName, so why not in PHP we do something similar like $ObjectInstance->field_name?
Is it possible?

YES it is and I’m going to show you how! + I am going a step further in making a re-usable component to handle/generate your dynamically generated PHP properties!

SOLN 1 – Generate Accessor Methods Dynamically in PHP using Inheritance

Let’s see the whole re-usable code:

class ParentClass
{
....public function __get($property)
....{
........$method = 'get' . ucfirst($property); //camelCase() method name
........if( method_exists( $this, $method ) )
........{
............$reflection = new ReflectionMethod($this, $method);
............if (!$reflection->isPublic())
................throw new RuntimeException("The called method is not public.");
........}

........if (property_exists($this, $property))
........{
............$reflectedProperty = new ReflectionProperty($this, $property);
............$reflectedProperty->setAccessible(true);
............return $reflectedProperty->getValue($this);
........}
....}

....public function __set($property, $value)
....{
........$method = 'set' . ucfirst($property); //camelCase() method name
........if( method_exists( $this, $method ) )
........{
............$reflection = new ReflectionMethod($this, $method);
............if (!$reflection->isPublic())
................throw new RuntimeException("The called method is not public.");
........}

........if (property_exists($this, $property))
........{
............$reflectedProperty = new ReflectionProperty($this, $property);
............$reflectedProperty->setAccessible(true);
............return $reflectedProperty->setValue($this, $value);
........}
....}
}//end class

And to use it in any of your classes, you would do something like:

class MyName extends ParentClass
{
....private $name;

....public function sayName()
....{
........echo 'Hello my name is: ' . $this->name;
....}
}//end class MyName

class MyAddress extends ParentClass
{
....private $address;

....public function sayAddress()
....{
........echo 'Hello my address is: ' . $this->address;
....}
}//end class MyAddress

And then you would call it somewhat like:

$obj = new MyName();
$obj->name = "Wasseem";
$obj->sayName();
echo 'yes indeed his name is: '. $obj->name;

$obj2 = new MyAddress();
$obj2->address = "Moka";
$obj2->sayAddress();
echo 'yes indeed his address is: '. $obj2->address;

The OUTPUT will be:

Hello my name is: Wasseem
yes indeed his name is: Wasseem

Hello my address is: Moka
yes indeed his address is: Moka

Note:

• I used the check !$reflection->isPublic() so that if at anytime you want a property’s setter or getter method to not be accessible, you could just include the definition private function getName() {} in your child class and hence you will not be able to do get $obj->name;

QUESTION: Why did I use a 2nd Reflection call to access the Fields of the Child Class from the Parent Class?

You could argue that the parent class should be able to access the child class property, by doing it like:

public function __get($property)
{
....$method = 'get' . ucfirst($property); //camelCase() method name
....if( method_exists( $this, $method ) )
....{
........$reflection = new ReflectionMethod($this, $method);
........if (!$reflection->isPublic())
............throw new RuntimeException("The called method is not public.");
....}

....if (property_exists($this, $property))
....{
........return $this->{$property};
....}
}

It turns out that the answer is NO. If you do it that way, you will get the exception below.

THOUGHT: Is this a downcasting that is being done?

Notice: Undefined property: MyName::$name in class file MyName.php line

This is why you should use Reflection.

SOLN 2 – Generate Accessor Methods Dynamically in PHP using Trait

Let’s see the whole re-usable code for the Trait approach:

trait PropGeneratorTrait
{
....public function __get($property)
....{
........$method = 'get' . ucfirst($property); //camelCase() method name
........if( method_exists( $this, $method ) )
........{
............$reflection = new ReflectionMethod($this, $method);
............if (!$reflection->isPublic())
................throw new RuntimeException("The called method is not public.");
....}

........if (property_exists($this, $property))
............return $this->{$property};
....}

....public function __set($property, $value)
....{
........$method = 'set' . ucfirst($property); //camelCase() method name
........if( method_exists( $this, $method ) )
........{
............$reflection = new ReflectionMethod($this, $method);
............if (!$reflection->isPublic())
................throw new RuntimeException("The called method is not public.");
........}

........if (property_exists($this, $property))
............$this->$property = $value;
....}

}

And to use it in any of your classes, you would do something like:

class MyName
{
....use PropGeneratorTrait;
....private $name;

....public function sayName()
....{
........echo 'Hello my name is: ' . $this->name;
....}
}

And then you would call it somewhat like:

$obj = new MyName();
$obj->name = “Wasseem”;
$obj->sayName();
echo ‘yes indeed his name is: ‘. $obj->name;

When should you use Trait or Inheritance?

1. This will depend entirely on your project needs. For example if you are going to encounter the possibility of going multiple inheritance (which is not allowed in PHP), you should opt for the Trait solution. Otherwise, you could choose Inheritance.
2. Also note that the implementation for the Trait approach uses one less Reflection class and hence results in fewer lines of code than the Inheritance one

A Disadvantage Of Using Auto Dynamically Properties This Way

=> When using a full-blown IDE like PHPStorm, you will NOT see those class fields in auto-completion.

Conclusion

We have seen that we can use two reusable approaches, Trait & Inheritance, in minimising our time to write complete setter/getter methods by making use of PHP’s magic methods and its powerful Reflection classes. And that you should use the Trait approach if you judge that you are going to have a multiple inheritance scenario, since multiple inheritance is not possible in PHP.

Over To You – Give Me Your Feedback & Opinion

Are you inline with how I did it? Do you see any downside or may be you have a better/different approach? Please do let me know using the comment form below..Thanks!