O>>public class Foo
O>>{
O>>    Foo( Func<MyClass> myClassFactory )
O>>    {
O>>       MyClass instance = myClassFactory();
O>>    }
O>>}

O>>

public class RootClass
{
    public RootClass( Foo foo )
    {
       ...
    }
}

void CreateContainer()
{

    container.Register<Func<MyClass>>( () => container.Resolve<MyClass>());

     Root = container.Resolve<RootClass>(); 
}

public class MyFabric : IMyFabric 
{
    public MyFabric (IFoo foo, IBar bar) { … }

    public ISomething CreateSomething (int i)
    {
         return new Something (i, foo, bar);
         // или например
         // return new Something (foo(i), bar);
    }
}

public class A 
{
    private IMyFactory _myFactory;
    
    public A (IMyFactory myFactory)
    {
        _myFactory = myFactory;
    }


    public IEnumerable<IMyClass> CalculateSomething()
    {
        return Enumerable.Range(1,100).Select( i => _myFactory.CreateSomething(i));
    }
}

void RegisterTypesInContainer()
{

    ...
    container.Register<Func<MyClass>>( ()=> container.Resolve<MyClass>() );

    ...
}

public class Foo
{
    Foo( Func<MyClass> myClassFactory )
    {
       MyClass instance = myClassFactory();
    }
}

class A
{
   IContainer container;

   A( IContainer container )
   {
      this.container = container;
   }

   IEnumerable<B> CalculateSomething()
   {
      return Enumerable.Range(1,100).Select( i => container.Resolve<B>(new TypedParameter(type(int), i));
   }
}

Doc>public class A 
Doc>{
Doc>    private IMyFactory _myFactory;
    
Doc>    public A (IMyFactory myFactory)
Doc>    {
Doc>        _myFactory = myFactory;
Doc>    }


Doc>    public IEnumerable<IMyClass> CalculateSomething()
Doc>    {
Doc>        return Enumerable.Range(1,100).Select( i => _myFactory.CreateSomething(i));
Doc>    }
Doc>}
Doc>

public class MyFactory : IMyFactory
{
    IContainer container;

    public MyFactory(IContainer container)
    {
    this.container = container;
    }
     
    IMyClass CreateSomething(int i)
    {
       return container.Resolve<IMyClass>(new TypedParameter(type(int), i);
    }
}

    class A
    {
        Func<int, B> bFactory;

        A(Func<int, B> bFactory)
        {
            this.bFactory = bFactory;
        }

        IEnumerable<B> CalculateSomething()
        {
            return Enumerable.Range(1, 100).Select(i => bFactory(i));
        }
    }
    
    //////////////////////////////////
    
    var b = new A(i => container.Resolve<B>(new TypedParameter(typeof(int), i)))

B( int I, IFoo foo, IBar bar )
{
}

Factory
{
  B CreateB( int I )
  {
    return new B(i, new Foo( new X(), new Y() ), new Bar( new Z(), new X() );
  }
}

@Bean
public FactoryType factoryType(Dependency1 dep1, Dependency2 dep2) {
  return new FactoryType(dep1, dep2);
}

O>>void CreateContainer()
O>>{

O>>    container.Register<Func<MyClass>>( () => container.Resolve<MyClass>());

O>>     Root = container.Resolve<RootClass>(); 
O>>}

O>>

public class RootClass
{


   RootClass( Foo foo)
   {

   }
}

public class MyClass
{
   public MyClass( RootClass root)   
   {
   }
}


public class Foo
{
    Foo( Func<MyClass> myClassFactory)
    {
    var myClass = myClassFactory();
    }
}

class a
{
    private Func<B> _getB;

    public A(Func<B> getB)
    {
    }

    IEnumerable<B> CalculateSomething()
    {
        return Enumerable.Range(1,100).Select( i => _getB());
    }
}