Hello Tarjei.

If you just add a parameter of type IContentRepository to your controller constructor it should be handled by StructureMap automatically.

The most flexiblle way to configure your rules is to implement IConfigurableModule:

    [InitializableModule]
    [ModuleDependency(typeof(EPiServer.Shell.ShellInitialization))] // You can provide dependencies by specifying other initialization modules types
    public sealed class MyInitialization : IConfigurableModule
    {
        public void ConfigureContainer(ServiceConfigurationContext context)
        {
            context.Container.Configure(ce =>
            {
                ce.For<IAwesomeness>().Use<AwesomenessImplementation>();
            });
        }
    }

Other way to configure it is to use ServiceConfigurationAttribute:

[ServiceConfiguration(ServiceType = typeof(IAwesomeness), Lifecycle = ServiceInstanceScope.HttpContext)]
    public class AwesomenessImplementation: IAwesomeness

public class StructureMapDependencyResolver : IDependencyResolver
    {
        private readonly IContainer _container;
 
        public StructureMapDependencyResolver(IContainer container)
        {
            _container = container;
        }
 
        public object GetService(Type serviceType)
        {
            if (serviceType.IsInterface || serviceType.IsAbstract)
            {
                return GetInterfaceService(serviceType);
            }
            else
            {
                return GetConcreteService(serviceType);
            }
        }
 
        private object GetConcreteService(Type serviceType)
        {
            return _container.GetInstance(serviceType);
        }
 
        private object GetInterfaceService(Type serviceType)
        {
            return _container.TryGetInstance(serviceType);
        }
 
        public IEnumerable<object> GetServices(Type serviceType)
        {
            return _container.GetAllInstances(serviceType).Cast<object>();
        }
    }

 [ModuleDependency(typeof(ServiceContainerInitialization))]
    [InitializableModule]
    public class MvcTemplatesInitializer : IInitializableModule
    {
 
        public void Initialize(InitializationEngine context) {
           DependencyResolver.SetResolver(new StructureMapDependencyResolver(context.Container)); }
}

@Sergii Vorushylo - my first issues is that simply adding a parameter of type IContentRepository to my controller constructor results in an error at runtime: "No parameterless constructor defined for this object.". I agree that it should be handled by StructureMap automatically via some sort of initialization by EPi, but that is not the case.

@Jonas Bergqvist - The initialization module contains som code that will not compile because the Container property is marked as internal on the EPiServer.Framework.Initialization.InitializationEngine class:

DependencyResolver.SetResolver(new StructureMapDependencyResolver(context.Container));

Is there some other way to set the dependency resolver?

Thanks to both of you for helping out so far!

-- 
Regards,
Tarjei Olsen

I got it now.

I made a StructureMapDependencyResolver, identical to the one in the post from Jonas Bergqvist. Then I changed the IInitializableModule to an IConfigurableModule based on the post from Sergii Vorushylo.

The resolver:

public class StructureMapDependencyResolver : IDependencyResolver
{
    private readonly IContainer container;

    public StructureMapDependencyResolver(IContainer container)
    {
        this.container = container;
    }

    public object GetService(Type serviceType)
    {
        if (serviceType.IsInterface || serviceType.IsAbstract)
            return GetInterfaceService(serviceType);
            
        return GetConcreteService(serviceType);
    }

    private object GetConcreteService(Type serviceType)
    {
        return container.GetInstance(serviceType);
    }

    private object GetInterfaceService(Type serviceType)
    {
        return container.TryGetInstance(serviceType);
    }

    public IEnumerable<object> GetServices(Type serviceType)
    {
        return container.GetAllInstances(serviceType).Cast<object>();
    }
}

The configurable module:

[ModuleDependency(typeof(ServiceContainerInitialization))]
[InitializableModule]
public class MvcTemplatesInitializer : IConfigurableModule
{
    public void ConfigureContainer(ServiceConfigurationContext context)
    {
        context.Container.Configure(x =>
        {
            x.For<IProvideAwesomeness>().Use<AwesomeStuff>();
        });

        DependencyResolver.SetResolver(new StructureMapDependencyResolver(context.Container)); 
    }

    public void Initialize(InitializationEngine context) { }
    public void Uninitialize(InitializationEngine context) { }
    public void Preload(string[] parameters) { }
}

And finally, my controller class:

public class StartController : PageController<StartPage>
{
    private IContentRepository dataFactory;
    private IProvideAwesomeness awesomeStuff;


    public StartController(IContentRepository dataFactory, IProvideAwesomeness awesomeStuff)
    {
        this.dataFactory = dataFactory;
        this.awesomeStuff = awesomeStuff;
    }

    // ...
}

Is this the right way to do it? It seems to me I now can have dependency injection in my controllers, and mix & match interfaces from EPi, like the IContentRepository, and my own contracts and classes.

-- 
Regards,
Tarjei Olsen