Question

I have Unity 2.0 working well within the App.xaml.cs to register and resolve within that class.

The question I have is regarding a best practice.

I have a number of User Controls and other classes that also need to resolve some of the same and new Interface <-> implementations. The problem is theres no way to access the Unity container I created in the App.xaml.cs.

I cannot use constructor or property injection to pass on the container reference.

1. Just too many (its a large project)
2. The user controls are added via xaml
3. There are several very loosely
   related “modules” in the project
   that can share the same container
   config.

I would rather not re-create the container from a config file in each object that needs access to the container.

Any best practice suggestions when the same container is needed as a service in various “modules” of the same assembly?

Thanks.

Answer 1

I believe bringing together Controls and IoC is pain in the … in the code at least. Probably somebody will argue but IMO the best practice to avoid this pain is MVVM. You will have viewModels which you can freely construct using Unity and inject everything you need into them. You will have views with bindings to viewModels with no reason to know anything abound inversion of control.

UPDATE: Based on comment:

App.xaml.cs:

    private void HandleStartup(object sender, StartupEventArgs e)
    {
        var container = CreateContainer(); // create IoC container
       var mainViewModel = container.Resolve<MainViewModel>();
        var shell = new Shell { DataContext = mainViewModel }; // main View
        MainWindow = shell;
        shell.Show();
    }

Shell XAML example:

<UserControl>
     <StackPanel>
          <ContentPresenter Content="{Binding ViewModel1}" />
          <ContentPresenter Content="{Binding ViewModel2}" />
          <ContentPresenter Content="{Binding ViewModel3}" />
     </StackPanel>
</UserControl>

MainViewModel:

public class MainViewModel
{
     public ViewModel1 ViewModel1 { get; private set; }
     public ViewModel2 ViewModel2 { get; private set; }
     public ViewModel3 ViewModel3 { get; private set; }

     // this will be handled by IoC container
     public MainViewModel(ViewModel1 viewModel1, ViewModel2 viewModel2, ViewModel3 viewModel3)
    {
        ViewModel1 = viewModel1;
        ViewModel2 = viewModel2;
        ViewModel3 = viewModel3;
    }

In this way your views will be unaware of IoC and everything you want in viewModels will be successfully injected.

UPDATE2 DataTemplating which brings Views and ViewModels together:

App.xaml

<Application.Resources>
    <DataTemplate DataType="{x:Type local:ViewModel1}">
        <View1 />
    </DataTemplate>
</Application.Resources>