Dependencies design question

[threed]

Hi guys,

Lets say we have class Form, each form consist of Elements, they consist of Filters and so on.

All of them are using single instance of Registry class.


Can you please tell me if there is proper design pattern helping the access to this registry object from the Form and its children classes.

Or i have to call setRegistry($registry) for each object.

Thanks in advance !

[TomB]

there are several patterns to deal with this.

Singleton is the simplest but there are many reasons to avoid it... just google it or search these forums.

You can make your registry static, though this isn't without its problems.

The most complete solution is Dependency Injection, but also has some limitations. See the link in my sig (i also provide another alternative).


Really it depends on the needs of your application as to which is best. In simple applications the singleton pattern allows very fast development and and easy interface, but for larger, continually developed projects it brings several issue.

[threed]

The Form is quite complex. Also they can be many instances of the Form in the same time, each with their own registry. So i guess Singleton will not be very good idea ?

I will read more Dependency Injection now. Thanks

[kyberfabrikken]

Or i have to call setRegistry($registry) for each object.

Is this a problem though? Have you tried it?

[threed]

Hi,

No is not a problem at all. I just post quite simple example and i am wondering if there is more clever solutions than passing the object everytime.

But i guess i am gonna finish like that

[PCSpectra]

This article gives a excellent overview as to what your options are: http://martinfowler.com/articles/injection.html

Personally I favour DI all the time, although I'm not sure if I would want my component coupled to the registry object, even if abstract...

Whatever variables are required by the form and it's sub-components I would pass those variables in directly, via it's API.

Cheers,
Alex

[imaginethis]

I'm not really sure why there's a need for the registry pattern. It seem some what unnecessary.

class Form
{
    protected $_elements = array();
    public function addElement(Element $element)
    {
        $this->_elements[$element->getName()] = $element;
    }
    
    public function getElement($name)
    {
        return $this->_elements[$name];
    }
    
    public function getElements()
    {
        return $this->_elements;
    }
}

class Element
{
    protected $_name = null;
    protected $_filters = array();
    public function getName()
    {
        return $this->_name;
    }
    
    public function addFilter(Filter $filter)
    {
        $this->_filter[$filter->getName()] = $filter;
    }
    
    public function getFilter($name)
    {
        return $this->_filters[$name];
    }
    
    public function getFilters()
    {
        return $this->_filters;
    }
}

class Filter
{
    protected $_name = null;
    public function getName()
    {
        return $this->_name;
    }
} 

[skinny monkey]

Can't you make a factory that creates new elements. In the factory during element creation, it assigns the newly created element to the registry? Obviously the factory would need an instance of the registry, probably passed in through it's constructor.

[Amenthes]

@threed, I'd suggest just passing arguments around "manually" until (1) you
find a pattern in there, (2) feel a need for automation or (3) see that something
isn't DRY (Don't Repeat Yourself). Later on, you may resort to other solutions,
like DI containers.