How to distinguish registration by property name in autofac aggregate service? - state

Question

interface IState {
}
class GoodState: IState {}
class BadState: IState {}
class MoreState: IState {}
// I stuck at here... :(
interface StateAggregateService {
IState GoodState {get;}
IState BadState {get;}
IState MoreState {get;}
}
Basically, I want to implement the State Machine pattern. I want to use the autofac aggregate service extension to create a factory class for me automatically. But all the concrete state classes inherit from the IState interface, the aggregate service extension cannot distinguish them.
One walkaround is to define some dummy interface like IGoodState which inherits from IState. The problem is that as the number of state classes increase, so do the number of dummy interfaces, and I feel it is really a dumb idea.
Is there's a way to associate registration with the property name, or something like that?

Answer 1

One way would be to use Named registration for your IState implementation and use property injection for the class implementing IStateAggregateService. So for aggregate service you would have:
interface IStateAggregateService
{
IState GoodState { get; }
IState BadState { get; }
IState MoreState { get; }
}
class StateAggregateService : IStateAggregateService
{
public IState GoodState { get; set; }
public IState BadState { get; set; }
public IState MoreState { get; set; }
}
and the registration would look like the following:
builder.RegisterType<GoodState>().Named<IState>("GoodState");
builder.RegisterType<BadState>().Named<IState>("BadState");
builder.RegisterType<MoreState>().Named<IState>("MoreState");
builder.Register(c => new StateAggregateService
{
GoodState = c.ResolveNamed<IState>("GoodState"),
BadState = c.ResolveNamed<IState>("BadState"),
MoreState = c.ResolveNamed<IState>("MoreState")
}).As<IStateAggregateService>();
Keep in mind this approach would return the same object every time you call a property from aggregate service.
If you want fresh instance every time you call a property, you could use different approach with keyed registration and IIndex<TKey, TService> interface; the registration would look like this:
builder.RegisterType<GoodState>().Keyed<IState>("GoodState");
builder.RegisterType<BadState>().Keyed<IState>("BadState");
builder.RegisterType<MoreState>().Keyed<IState>("MoreState");
builder.RegisterType<StateAggregateService>().As<IStateAggregateService>();
and implementation of the service
class StateAggregateService : IStateAggregateService
{
private readonly IIndex<string, IState> _states;
public IState GoodState => _states["GoodState"];
public IState BadState => _states["BadState"];
public IState MoreState => _states["MoreState"];
public StateAggregateService(IIndex<string, IState> states)
{
_states = states;
}
}
To make this approach cleaner, you might want to use some enum as a key for your IState implementations instead of string.
Also, you could just get rid of StateAggregateService and use IIndex<TKey, TService> as a factory wherever you need.
Updated:
As stated in comment, it's true, the solution you need is not possible to be achieved with Aggregated Service. But it's possible to do something similar with some manual registration and reflection. For the following interface and aggregator class:
interface IStateAggregateService
{
IState GoodState { get; }
IState BadState { get; }
IState MoreState { get; }
}
class StateAggregateService : IStateAggregateService
{
public IState GoodState { get; set; }
public IState BadState { get; set; }
public IState MoreState { get; set; }
}
you could use the following registration:
builder.RegisterType<GoodState>().Keyed<IState>("GoodState");
builder.RegisterType<BadState>().Keyed<IState>("BadState");
builder.RegisterType<MoreState>().Keyed<IState>("MoreState");
builder.Register(c =>
{
var serviceProps = typeof(StateAggregateService).GetProperties();
var service = new StateAggregateService();
foreach (var property in serviceProps)
{
property.SetValue(service, c.ResolveKeyed<IState>(property.Name));
}
return service;
}).As<IStateAggregateService>();
The difference is you need to create a class implementing your aggregation interface. This solution uses properties names so you need to keep their names the same as types, or prepare your own logic to assign proper implementation to aggregator properties.