Dependency Injection with dynamic constructor values

Question

Is there a way to pass constructor arguments for dependencies when using the automatically generated factory classes?

I have an object structure that I would instantiate like this without the object manager:

new A(
  new AA(
    new AAA(
      'xyz'         <-- value determined at runtime
    )
  ),
  new AB(
    new ABA(),
    new ABB()
    [1,2,3]         <-- value determined at runtime
  ),
  new AC(
    ...
  )
);

Now I could replace this with a mix of factories and constructor injected arguments¹, but I'm wondering if there is another way, something like this:

$aFactory->create(
  [
    AAA::class => ['param1' => 'xyz'],
    AB::class => ['param3' =>  [1,2,3]],
  ]
);

Alternatively it would also be useful if I could define a constructor argument to be fetched from a certain method with the type definition in di.xml.

Is there anything like this?

---

^{1) like this}

$aFactory->create(
  [
    'aa' => $aaFactory->create(
      [
        'aaa' => $aaaFactor->create(
          [
            'param1' => 'xyz'
          ]
        )
      ]
    ),
    'ab' => $abFactory->create(
      [
        'param3' => [1,2,3]
      ]
    )
  ]
);

But what I'm trying to avoid is having to depend on all these factories

Answer 1

I'm not entirely sure about what you're trying to achieve but I think you could do something like this:

$aFactory->create(['param1' => 'xyz', 'param3' => [1,2,3]]);

Then in the constructor of $aFactory you can do:

$this->_aa = $aaaFactory->create($data['param1']);
$this->_ab = $abFactory->create($data['param3']);

Answer 2

Since what I tried is not possible, I ended up with a mix of preference definitions, generated factories and custom factories and decided case by case what makes sense.

1. I replaced the outermost instantiation with a factory. AFactory is the autogenerated factory for A (autogeneration of factories works for external libraries just as well as for classes of the module)

   $this->aFactory->create([
       ...
   ]);
   

2. For all constructor parameters of A without runtime configuration (ex. AC) I defined preferences in di.xml to pass the right objects.

3. For object structures that I want to be able to replace as a whole, I created custom factories, with an interface and defined them as preference. Ex. AA:

   interface AAInterrfaceFactory
   {
       /** @return AAInterface */
       public function create();
   }
   
   class AAFactory implements AAFactory
   {
       public function create()
       {
           return new AA(
               new AAA(
                 'xyz'         <-- value determined at runtime
               )
          );
       }
   }
   

4. For objects from the library that could not be replaced anyways (ex. AB), I stick with "new". If possible, parameters are injected into the class where the whole creation happens.

So in the end the instantiation can look like this:

return $this->aFactory->create(
    [
        'aa' => $this->aaFactory->create(),
        'ab' => new AB(
            $this->aba,
            $this->abb,
            [1, 2, 3]
        )
    ]
);