Question

How do I register a closed type so that instances of the generic are created using HybridHttpOrThreadLocalScoped lifecycle?

My classes:

public interface IBaseService
{
}

public interface IAccountService
{
    void Save(Account entry);
    Account GetById(string id);
    List<Account> GetList();
    void Delete(string id);
    bool Exists(string id);
}

public interface IClientService
{
    void Save(Client entry);
    Client GetById(string id);
    List<Client> GetList();
    void Delete(string id);
    bool Exists(string id);
}

public class AccountService : IBaseService, IAccountService
{
    Some code for managing accounts
}

public class ClientService : IBaseService, IClientService
{
    Some code for managing clients
}

Dependency resolver:

    public StructureMapContainer(IContainer container)
    {
        _container = container;

        _container.Configure(x => x.Scan(y =>
        {
            y.AssembliesFromApplicationBaseDirectory();
            y.WithDefaultConventions();
            y.LookForRegistries();
            y.ConnectImplementationsToTypesClosing(typeof(IService<>))
                 .OnAddedPluginTypes(t => t.HybridHttpOrThreadLocalScoped());
        }));

    }

What’s the syntax in the resolver for automatically creating instances of IBaseService? Using ConnectImplementationsToTypesClosing only works for open generics. Do I even need to use the resolver? Is there a better way to register the types?

For now, this is how I amhandling registering them:

container.Configure(x =>
        {
            x.For<IClientService>()
                .HybridHttpOrThreadLocalScoped()
                .Use(new ClientService());

            x.For<IEmailAddressService>()
                .HybridHttpOrThreadLocalScoped()
                .Use(new EmailAddressService());

            x.For<IAccountService>()
                .HybridHttpOrThreadLocalScoped()
                .Use(new AccountService());
        });

Answer 1

Something like:

    Scan(y =>
    {
        y.AssemblyContainingType<IService>();
        y.Assembly(Assembly.GetExecutingAssembly().FullName);
        y.With(new ServiceScanner());
    });

Then you need the Customscanner:

/// <summary>
/// Custom scanner to create Service types based on custom convention
/// In this case any type that implements IService and follows the 
/// naming convention of "Name"Service.
/// </summary>
public class ServiceScanner : IRegistrationConvention
{
    public void Process(Type type, StructureMap.Configuration.DSL.Registry registry)
    {
        if (type.BaseType == null) return;

        if (type.GetInterface(typeof(IService).Name) != null)
        {
            var name = type.Name;
            var newtype = type.GetInterface(string.Format("I{0}", name));

            registry
               .For<IService>()
               .AddInstances(y => y.Instance(new ConfiguredInstance(type).Named(name)))
               .HybridHttpOrThreadLocalScoped();

            registry.For(newtype)
                .HybridHttpOrThreadLocalScoped().Use(c => c.GetInstance<IService>(name));
        }
    }
}