Symfony2: optimize collection of forms - forms

Question

In a controller of a Symfony2 application, I use collection of elements. The more elements there are, the more time it takes. It sounds logical but it seems that there are repeated traitments:
I create a form from MyCollectionType
in the buildForm method, I add the ElementType that has its own buildForm method.
Then when the form is built by Symfony2 with the list of elements I pass, the buildForm method of the ElementType is called one time for each element
=> is this not possible that the first ELementType is built, then other are cloned?
I don't see why there would be any different there between these subforms, the only difference will appear setting the data and not building the form.
Then I notice the same for the buildView method: there are a lot of repeated processing for each element, where only the data (possibly processing of listeners) may vary.
For example, in my application, with a ElementType having 6 fields, and a collection of 700 elements, it takes up to 30s to render the form.
Is it due to the way that forms are handled, or can be be optimized ?

Answer 1

I add the same problem for one of my application, what I did is that I reimplemented a basic form class prototype, the method names are almost the same that the Symfony2 ones and reimplemented in the most simple way, It looks like this:
class SimpleForm
{
/**
* #var ContainerInterface $container Main application DIC
*/
protected $container;
/**
* #var array $options Options of the form
*/
protected $options = array();
/**
* #var array $options Raw datas for the form.
*/
protected $data = array();
/**
* #var array $options Data of the form against user input.
*/
protected $boundData = array();
/**
* #var array $errors List of errors after form valisation
*/
protected $errors = array();
/**
* #var array $options Tells if the datas were bound to the form.
*/
protected $isBound = false;
/**
* #var array $options Tells if the form validation is ok
*/
protected $isValid = false;
/**
* Main constructor.
*
* #param ContainerInterface $container The main DIC
* #param array $options Options of the form
*/
public function __construct(ContainerInterface $container, $options = array())
{
$this->container = $container;
$this->options = $options;
$this->buildForm();
}
/**
* Add widgets to the form.
*/
public function buildForm()
{
$this->widgets['keywordType'] = self::$keywordTypes;
}
/**
* #return array
*/
public function getOptions()
{
return $this->options;
}
/**
* #param array $options
*/
public function setOptions($options)
{
$this->options = $options;
}
/**
* #return string
*/
public function getEnctype()
{
return isset($this->options['enctype']) ? $this->options['enctype'] : '';
}
/**
* If the form is bound it return the bound datas, it returns the raws datas otherwise.
*
* #return array
*/
public function getData()
{
return $this->isBound ? $this->boundData : $this->data;
}
/**
* #throws \LogicException
*
* #return array
*/
public function getErrors()
{
if ($this->isBound == false) {
throw new \LogicException('The form must be bound before the errors can be retrieved');
}
return $this->errors;
}
/**
* #throws \LogicException
*
* #return array
*/
public function hasErrors()
{
if ($this->isBound == false) {
throw new \LogicException('The form must be bound before the errors can be checked');
}
return !empty($this->errors);
}
/**
* #throws \LogicException
*
* #return array
*/
public function getBoundData()
{
if ($this->isBound == false) {
throw new \LogicException('The form must be bound before getting the form final datas');
}
return $this->boundData;
}
/**
* #param array $data
*
* #return SimpleForm
*/
public function setData($data)
{
$this->data = $data;
return $this;
}
/**
* Bind the submitted values to the form.
*
* #param array $values The values to bind
*
* #return SimpleForm
*/
public function bind($values)
{
$values = $this->clean($values);
$this->boundData = Tools::arrayDeepMerge($this->data, $values);
$this->isBound = true;
$this->validate();
return $this;
}
/**
* Clean raw form values before the validation.
*
* #param array $values The raw values submitted by the user.
*
* #return array
*/
protected function clean($values)
{
// ...
return $values;
}
/**
* Run the validation against the form.
*
* #return boolean
*/
protected function validate()
{
$this->errors = array();
// ...
$this->isValid = empty($this->errors);
return $this->isValid;
}
/**
* Return the validation state of the form.
*
* #throws \LogicException
*
* #return boolean
*/
public function isValid()
{
if ($this->isBound == false) {
throw new \LogicException('The form must be bound before getting the validation status');
}
return $this->isValid;
}
/**
* Returns the datas that will be necesary for the view.
*
* #return array
*/
public function createView()
{
return array(
'widgets' => $this->widgets,
'options' => $this->options,
'data' => $this->boundData, // Don't forget to escape values against XSS
'enctype' => $this->getEnctype(),
'errors' => $this->errors,
'name' => $this->getName(),
);
}
/**
* #return string The name of the form
*/
public function getName()
{
return 'search';
}
}
In the Twig templates, I just iterate the data to create the form fields, repopulate values and to display the errors. The form is the same but is generated in 100ms instead of 30 seconds... For all the other forms I kept on using the Symfony2 ones.

Answer 2

The answer is simple: You should optimize yours programming skills instead of symfony forms. This is yours next question (of many) about the same issue.
You want to render over 4200 fields with fieldsets and/or divs around each input, so I suspect that 30 second it's the time in which it renders in the browser.