StrongInject and preserving module level encapsulation

[ekalchev]

Hello,

I am not sure how or is it possible to be able to register classes in the executing assembly container of different modules/assemblies without the need to make the types public.

Example:

Assembly A contains those types

public interface IMyInterface {}
internal class MyInterfaceImpl : IMyInterface { ... }

Executing Assembly need to register the dependency this way

[Register(typeof(Application))]
[Register(typeof(MyInterfaceImpl), typeof(IMyInterface))]
public partial class Container : IContainer<Application> { }

but it can't because MyInterfaceImpl is internal clas

Is it possible to avoid making MyInterfaceImpl public and still be able to register the dependency?

We currently use Unity container and we do this by exposing extension method in Assembly A which register the dependencies on the container instance. The Executing assembly calls this method. This way we have encapsulation on module level but still be able to register dependencies.

[jnm2]

The code you have here does work because it doesn't involve modules. If Container was used as a module for a different container in a separate assembly, then here's the question: How could assembly B obtain an instance of IMyInterface while MyInterfaceImpl is internal to assembly A?

// Assembly A:
public interface IMyInterface { }
internal class MyInterfaceImpl : IMyInterface { }

[Register(typeof(MyInterfaceImpl), typeof(IMyInterface))]
public static class Module { }

// Assembly B:
[Register(typeof(Application))]
[RegisterModule(typeof(Module))]
public partial class Container : IContainer<Application>
{
    // In the generated partial part of this class, what does the codegen look like to obtain an IMyInterface?
}

public class Application
{
    public Application(IMyInterface myInterface) { }
}

[ekalchev]

Thank you very much!

[ekalchev]

I tried your example with module but it doesn't work if MyInterfaceImpl class is internal

internal class MyInterfaceImpl : IMyInterface { }

it works with public. Is that means internal registrations to a module are not supported or I am doing something wrong?

Here my test project where I am trying to do what I asked

[jnm2]

Correct, and I'm asking: how could they work, even in principle? What sort of generated code would that take?

[ekalchev]

I guess it is not possible. I checked other compile time containers and it seems like unsolvable issue. I am just looking for a solution to replace reflection based DI without making every existing internal class in my code base public.

[jnm2]

The only way I can imagine would be, instead of modules, to chain two containers together and have everything inside the inner container resolvable as Owned<IXyz> for the sake of the outer container.

Whoever it is that creates the internal class needs to know what the internal class's constructor is so that whoever creates it can also release its dependencies properly.