How to Inject Data into plain c# Entry Points

[Kevdome3000]

Hey there,

I'm new to DI and struggling to understand how to inject a data collection (List, Dictionary<T, T>) into LifeScope when retrieving the data relies on asynchronous methods.

`

 class Foo : IFoo
 {
     DataCollection Items {get; set;}

     [Inject]
     public Foo(DataCollection Items)
    {
        this.Items = Items;
    }
  }

 class DataCollection
 {
      Dictionary<string, Bar> DataContainers{get; set;}
 }



In LifeTimeScope, I've tried something like this:

builder.Register<DataCollection>(container =>
{
   var serviceA = container.Resolve<ServiceA>();
   return await serviceA.ProvideDataCollection();
}, Lifetime.Scoped)

 OR

builder.Register<DataCollection>(container =>
{
   var serviceA = container.Resolve<ServiceA>();
   Datacollection collection;
   UniTask.Run(async() =>  collection = await ServiceA.ProvideDatacollection());
   return collection;
}, Lifetime.Scoped);

`

and many other combinations, but haven't been successful.

Can you provide a simple example of how I can achieve this?

Thanks!

[hadashiA]

Hmm. From looking at the sample code, your problem is not with the collection, but with the usage of async/await.

return await serviceA.ProvideDataCollection();

This line is probably a compilation error.
Register(...) It is not designed to execute asynchronous methods internally within.

UniTask.Run(async() => collection = await ServiceA.ProvideDatacollection());

This line will go to the next line without waiting for ProvideDatacollection().

DI constructs should be resolved statically. If you need to retrieve data dynamically at runtime, it is better to DI only that function.
Typically, I prefer a style like DDD.

(e.g:

class FooRepository
{
    public DataCollection Collection { get; } = new DataCollection();

    public async UniTask FetchAsync()
    {
        // Get the data asynchronously!
    }
}

public FooService
{
    public FooService(FooRepository repository)
    {
        this.repository = repository;
    }

    // ...
}

In addition, retrieving data asynchronously requires complex controls, such as displaying screens while waiting, displaying errors, reloading, and retrying.
It is not desirable to describe this only in DI settings.

[Kevdome3000]

Yes, after a few weeks of experiments, your suggested approach now makes sense. Thanks!

[JesseTG]

What does "DDD" stand for? Also, in your example, when and where would FooRepository.FetchAsync() be called?