Quali sono i vantaggi dell'utilizzo dell'inizializzazione pigra quando si chiama l'EntityManager di Doctrine?

TL; DR: ho notato che alcuni tutorial stanno utilizzando una chiamata di metodo in più per recuperare una variabile, nel mio caso EntityManager di Doctrine. È generalmente una buona idea usare tale chiamata di metodo extra, quando sembra aggiungere un sovraccarico, anche se questo overhead è "solo un po '" di overhead? Nel mio caso sto parlando del codice che usa $this->getEntityManager() e non usa $this->entityManager direttamente

L'istanziazione di EntityManager in Doctrine è una procedura costosa. Ci sono alcune (rare) volte in cui non ho bisogno di un EntityManager per fare qualcosa anche se la maggior parte delle volte che faccio.

Ho notato che molti tutorial utilizzano un metodo "extra" per recuperare EntityManager , in questo modo (vedi getEntityManager ):

class GenericRepository
{

    /**
     *
     * @var EntityManager
     */
    protected $em;

    /**
     *
     * @return EntityManager
     */
    final public function getEntityManager()
    {
        if ($this->em === null)
            $this->em = DoctrineConnector::getEntityManager();

        return $this->em;
    }
}

e più avanti nel mio codice ho qualcosa del genere:

class CustomRepository extends GenericRepository
{

    /**
     * Looks up Category Entity by its string name
     *
     * @param string $name
     * @return Product
     */
    function getProduct($partNumber)
    {
        $product = $this->getEntityManager() //<--calling entity Manager indirectly
        ->getRepository(ProductEntity::class)
        ->findOneBy(array(
            'model' => $partNumber
        ));

        return $product;
    }
}

Domanda

Posso sostituire getEntityManager() chiamata sopra con em , se nella mia classe GenericRepository I inizializzo il repository immediatamente durante la costruzione. Posso quindi accorciare il mio codice come mostrato di seguito ed evitare una chiamata al metodo getEntityManager() in più, in questo modo:

        $product = $this->em  //<-- this is different, using em directly
        ->getRepository(ProductEntity::class)
        ->findOneBy(array(
            'model' => $partNumber
        ));

em sarà garantito che non sia nullo in quel caso se lo inizializzo in fase di costruzione.

Perché non consultare invece $em direttamente e rimuovere l'inizializzazione pigra?

Quali sarebbero alcuni motivi per mantenere getEntityManager() nel mio codice e continuare a utilizzare l'inizializzazione pigra a spese del sovraccarico di una chiamata di metodo in più?