/// <summary>
/// Resolve the <c>IDatabaseProvider</c> depending one the parameters.The purpose will be to get the database provider depending of the configurations
/// </summary>
/// <param name="context">The context in which a service can be accessed or a component's dependencies resolved. Disposal of a context will dispose any owned components.</param>
/// <param name="parameters"></param>
/// <returns></returns>
private IDatabaseProvider ResolveIDatabaseProvider(IComponentContext context, IEnumerable <Autofac.Core.Parameter> parameters)
{
var environmentName = parameters.Named <string>("name");
var connectionName = parameters.Named <string>("connectionName");
var conProvider = context.Resolve <IConnectionProvider>();
DatabaseProviderEnum providerEnum;
ConnectionContext connectionContext = new ConnectionContext(
connectionName
, environmentName
, conProvider.GetProviderName(environmentName, connectionName)
, conProvider.GetConnectionString(environmentName, connectionName)
);
if (string.IsNullOrWhiteSpace(connectionContext.Provider))
{
throw new NullReferenceException($"The provider for the connection {connectionName} is not provided");
}
if (System.Enum.TryParse(connectionContext.Provider, out providerEnum))
{
return(context.ResolveKeyed <IDatabaseProvider>(providerEnum,
new NamedParameter("connectionContext", connectionContext)));
}
return(context.ResolveKeyed <IDatabaseProvider>(connectionContext.Provider,
new NamedParameter("connectionContext", connectionContext)));
}
public static object ResolveEventHandlers(this IComponentContext context, Type enumerableType)
{
var serviceType = enumerableType.GetGenericArguments()[0];
var persistenceHandlers = (object[])context.ResolveKeyed(PersistenceKey, enumerableType);
var domainHandlers = (object[])context.ResolveKeyed(DomainKey, enumerableType);
var otherHandlers = (object[])context.Resolve(enumerableType);
return(EventHandlerHelper.ConcatArraysOfServices(
serviceType,
persistenceHandlers, domainHandlers, otherHandlers));
}
// GET api/values
public async Task <IEnumerable <string> > Get()
{
await _eventPublisher.PublishAsync(new OrderDeletedEventArgs()
{
OrderId = 1
});
_componentContext.ResolveKeyed <IEventTypeStrategyFinder>("1").ExecuteStrategy();
_componentContext.ResolveKeyed <IEventTypeStrategyFinder>("4").ExecuteStrategy();
return(new string[] { "value1", "value2" });
}
public async Task DispatchAsync(Command command)
{
try
{
if (command.CommandName == "help" && command.Arguments.Count == 1)
{
await HandleHelpCommand(command);
return;
}
var isCommandRegistered = _component.IsRegisteredWithKey <ICommandHandler>(command.CommandName);
if (!isCommandRegistered)
{
await _component.ResolveKeyed <ICommandHandler>("command-not-found")
.HandleAsync(command);
return;
}
var commandHandler = _component.ResolveKeyed <ICommandHandler>(command.CommandName);
if (command.Arguments.Count != commandHandler.GetAttributeCommandArgsCount())
{
await DisplayValidationResult(command.CalledFromChannel);
}
else
{
var validationResult = await commandHandler.ValidateCommandAsync(command);
if (!validationResult.IsValid)
{
await DisplayValidationResult(command.CalledFromChannel,
validationResult.ErrorMessage);
}
else
{
await commandHandler.HandleAsync(command);
}
}
}
catch (Exception ex)
{
_logger.LogError("Error during processing command: {0} \n {1}", ex.Message, ex.StackTrace);
await _component.ResolveKeyed <ICommandHandler>("internal-application-error")
.HandleAsync(command);
}
}
public async Task ProcessEventAsync(IApiContext apiContext, Event eventPayLoad)
{
try
{
Trace.CorrelationManager.ActivityId = !String.IsNullOrEmpty(apiContext.CorrelationId)
? Guid.Parse(apiContext.CorrelationId)
: Guid.NewGuid();
_logger.Info(String.Format("Got Event {0} for tenant {1}", eventPayLoad.Topic, apiContext.TenantId));
var eventType = eventPayLoad.Topic.Split('.');
var topic = eventType[0];
if (String.IsNullOrEmpty(topic))
{
throw new ArgumentException("Topic cannot be null or empty");
}
var eventCategory = (EventCategory)(Enum.Parse(typeof(EventCategory), topic, true));
var eventProcessor = _container.ResolveKeyed <IEventProcessor>(eventCategory);
await eventProcessor.ProcessAsync(_container, apiContext, eventPayLoad);
}
catch (Exception exc)
{
_emailHandler.SendErrorEmail(new ErrorInfo {
Message = "Error Processing Event : " + JsonConvert.SerializeObject(eventPayLoad), Context = apiContext, Exception = exc
});
throw exc;
}
}
private async Task ProcessPoolsAsync()
{
foreach (var pool in clusterConfig.Pools)
{
logger.Info(() => $"Processing payments for pool {pool.Id}");
try
{
// resolve payout handler
var handlerImpl = ctx.Resolve <IEnumerable <Meta <Lazy <IPayoutHandler, CoinMetadataAttribute> > > >()
.First(x => x.Value.Metadata.SupportedCoins.Contains(pool.Coin.Type)).Value;
var handler = handlerImpl.Value;
handler.Configure(clusterConfig, pool);
// resolve payout scheme
var scheme = ctx.ResolveKeyed <IPayoutScheme>(pool.PaymentProcessing.PayoutScheme);
await UpdatePoolBalancesAsync(pool, handler, scheme);
await PayoutPoolBalancesAsync(pool, handler);
}
catch (Exception ex)
{
logger.Error(ex, () => $"[{pool.Id}] Payment processing failed");
}
}
}
public IEnumerable <T> ResolveAll <T>()
{
// We're going to find each service which was registered
// with a key, and for those which match the type T we'll store the key
// and later supplement the default output with individual resolve calls to those
// keyed services
var allKeys = new List <object>();
foreach (var componentRegistration in _context.ComponentRegistry.Registrations)
{
// Get the services which match the KeyedService type
var typedServices = componentRegistration.Services.Where(x => x is KeyedService).Cast <KeyedService>();
// Add the key to our list so long as the registration is for the correct type T
allKeys.AddRange(typedServices.Where(y => y.ServiceType == typeof(T)).Select(x => x.ServiceKey));
}
// Get the default resolution output which resolves all un-keyed services
var allUnKeyedServices = new List <T>(_context.Resolve <IEnumerable <T> >());
// Add the ones which were registered with a key
allUnKeyedServices.AddRange(allKeys.Distinct().Select(key => _context.ResolveKeyed <T>(key)));
// Return the total resultset
return(allUnKeyedServices);
}
/// <summary>
/// Resolves a constructor parameter based on keyed service requirements.
/// </summary>
/// <param name="parameter">The specific parameter being resolved that is marked with this attribute.</param>
/// <param name="context">The component context under which the parameter is being resolved.</param>
/// <returns>
/// The instance of the object that should be used for the parameter value.
/// </returns>
/// <exception cref="ArgumentNullException">
/// Thrown if <paramref name="parameter" /> or <paramref name="context" /> is <see langword="null" />.
/// </exception>
public override object ResolveParameter(ParameterInfo parameter, IComponentContext context)
{
if (parameter == null)
{
throw new ArgumentNullException(nameof(parameter));
}
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (string.IsNullOrWhiteSpace(ServiceKey))
{
return(ReadOnly ? context.ResolveKeyed("_slave", parameter.ParameterType, new NamedParameter("readOnly", true)) : context.Resolve(parameter.ParameterType));
}
return(ReadOnly ? context.ResolveKeyed($"{ServiceKey}_slave", parameter.ParameterType, new NamedParameter("readOnly", true)) : context.ResolveKeyed(ServiceKey, parameter.ParameterType));
}
private async Task ProcessPoolsAsync()
{
foreach (var pool in clusterConfig.Pools.Where(x => x.Enabled && x.PaymentProcessing.Enabled))
{
logger.Info(() => $"Processing payments for pool {pool.Id}");
try
{
var family = HandleFamilyOverride(pool.Template.Family, pool);
// resolve payout handler
var handlerImpl = ctx.Resolve <IEnumerable <Meta <Lazy <IPayoutHandler, CoinFamilyAttribute> > > >()
.First(x => x.Value.Metadata.SupportedFamilies.Contains(family)).Value;
var handler = handlerImpl.Value;
await handler.ConfigureAsync(clusterConfig, pool);
// resolve payout scheme
var scheme = ctx.ResolveKeyed <IPayoutScheme>(pool.PaymentProcessing.PayoutScheme);
await UpdatePoolBalancesAsync(pool, handler, scheme);
await PayoutPoolBalancesAsync(pool, handler);
}
catch (InvalidOperationException ex)
{
logger.Error(ex.InnerException ?? ex, () => $"[{pool.Id}] Payment processing failed");
}
catch (Exception ex)
{
logger.Error(ex, () => $"[{pool.Id}] Payment processing failed");
}
}
}
public static IValueParser ResolveParser(this PropertySourceConfiguration conf, IComponentContext context)
{
var parameters =
conf.ValueParserParameter.Select(param => new NamedParameter(param.Key, param.Value));
return(context.ResolveKeyed <IValueParser>(conf.Parser.GetContainerName(), parameters));
}
public static void InjectProperties(this IComponentContext context, object instance)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (instance == null)
{
throw new ArgumentNullException(nameof(instance));
}
var type = instance.GetType();
foreach (var propertyInfo in type.GetRuntimeProperties().Where(pi => pi.CanWrite))
{
var propertyType = propertyInfo.PropertyType;
var injectAttribute = propertyInfo.GetCustomAttribute <AutoInject>();
if (injectAttribute != null &&
(!propertyType.GetTypeInfo().IsValueType || propertyType.GetTypeInfo().IsEnum) &&
(!propertyType.IsArray || !propertyType.GetElementType().GetTypeInfo().IsValueType) &&
propertyInfo.GetIndexParameters().Length == 0)
{
propertyInfo.SetValue(instance, injectAttribute.Key != null
? context.ResolveKeyed(injectAttribute.Key, propertyType)
: context.Resolve(propertyType), null);
}
}
}
public static void InjectFields(this IComponentContext context, object instance)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (instance == null)
{
throw new ArgumentNullException(nameof(instance));
}
var type = instance.GetType();
foreach (var fieldInfo in type.GetRuntimeFields())
{
var propertyType = fieldInfo.FieldType;
var injectAttribute = fieldInfo.GetCustomAttribute <AutoInject>();
if (injectAttribute != null &&
(!propertyType.GetTypeInfo().IsValueType || propertyType.GetTypeInfo().IsEnum) &&
(!propertyType.IsArray || !propertyType.GetElementType().GetTypeInfo().IsValueType))
{
fieldInfo.SetValue(instance, injectAttribute.Key != null
? context.ResolveKeyed(injectAttribute.Key, propertyType)
: context.Resolve(propertyType));
}
}
}
public virtual void Resolve(object sender, System.Reflection.FieldInfo field, IComponentContext context)
{
var fType = this.Type ?? field.FieldType;
if (fType.IsAssignableTo <ILogger>())
{
var log = context.Resolve <ILoggerFactory>().CreateLogger(this.GetType().Name);
field.SetValue(sender, log);
}
else
{
var named = this.Named;
var keyed = this.Keyed;
if (!string.IsNullOrWhiteSpace(named))
{
var pInstance = context.ResolveNamed(named, fType);
field.SetValue(sender, pInstance);
}
else if (keyed != null)
{
var pInstance = context.ResolveKeyed(keyed, fType);
field.SetValue(sender, pInstance);
}
else
{
var pInstance = context.Resolve(fType);
field.SetValue(sender, pInstance);
}
}
}
public static IValueParser ResolveParser(this ValueParser parser, IComponentContext context, IDictionary <string, object> parameter)
{
var parameters =
parameter.Select(param => new NamedParameter(param.Key, param.Value));
return(context.ResolveKeyed <IValueParser>(parser.GetContainerName(), parameters));
}
protected override void Load(ContainerBuilder builder)
{
builder.RegisterType <BluetoothDeviceManager>().As <IBluetoothDeviceManager>().SingleInstance();
builder.RegisterType <InfraredDeviceManager>().As <IInfraredDeviceManager>().SingleInstance();
builder.RegisterType <DeviceRepository>().As <IDeviceRepository>().SingleInstance();
builder.RegisterType <DeviceManager>().As <IDeviceManager>().SingleInstance();
builder.RegisterType <SBrickDevice>().Keyed <Device>(DeviceType.SBrick);
builder.RegisterType <BuWizzDevice>().Keyed <Device>(DeviceType.BuWizz);
builder.RegisterType <BuWizz2Device>().Keyed <Device>(DeviceType.BuWizz2);
builder.RegisterType <BuWizz3Device>().Keyed <Device>(DeviceType.BuWizz3);
builder.RegisterType <InfraredDevice>().Keyed <Device>(DeviceType.Infrared);
builder.RegisterType <PoweredUpDevice>().Keyed <Device>(DeviceType.PoweredUp);
builder.RegisterType <BoostDevice>().Keyed <Device>(DeviceType.Boost);
builder.RegisterType <TechnicHubDevice>().Keyed <Device>(DeviceType.TechnicHub);
builder.RegisterType <DuploTrainHubDevice>().Keyed <Device>(DeviceType.DuploTrainHub);
builder.RegisterType <CircuitCubeDevice>().Keyed <Device>(DeviceType.CircuitCubes);
builder.Register <DeviceFactory>(c =>
{
IComponentContext ctx = c.Resolve <IComponentContext>();
return((deviceType, name, address, deviceData) => ctx.ResolveKeyed <Device>(deviceType, new NamedParameter("name", name), new NamedParameter("address", address), new NamedParameter("deviceData", deviceData)));
});
}
public T Resolve <T>(object key = null) where T : class
{
if (key == null)
{
return(_componentContext.Resolve <T>());
}
return(_componentContext.ResolveKeyed <T>(key));
}
/// <summary>
/// 对于memberInfo 或者 parameterInfo 进行设值
/// </summary>
/// <param name="context"></param>
/// <param name="classType"></param>
/// <param name="memberType"></param>
/// <param name="memberInfo"></param>
/// <param name="parameterInfo"></param>
/// <param name="autoConfigurationDetail"></param>
/// <returns></returns>
private object Resolve(IComponentContext context, Type classType, Type memberType, MemberInfo memberInfo, ParameterInfo parameterInfo = null, AutoConfigurationDetail autoConfigurationDetail = null)
{
if (classType == null)
{
return(null);
}
if (string.IsNullOrEmpty(this.value))
{
return(null);
}
try
{
//先把 ${} 的 placehoder 全部替换掉
var parameterValue = ResolveEmbeddedValue(context, classType, this.value, autoConfigurationDetail);
int startIndex = parameterValue.ToString().IndexOf("#{", StringComparison.Ordinal);
if (startIndex != -1)
{
int endIndex = parameterValue.ToString().LastIndexOf(DefaultPlaceholderSuffix, StringComparison.Ordinal);
if (endIndex != -1)
{
Dictionary <string, object> vars = new Dictionary <string, object>
{
["_sprint_context_resove_"] = new SprintContextResove((type, name) =>
{
if (!string.IsNullOrEmpty(name))
{
return(context.ResolveKeyed(name, type));
}
return(context.Resolve(type));
})
};
//El表达式
int pos = startIndex + DefaultPlaceholderPrefix.Length;
string expression = parameterValue.ToString().Substring(pos, endIndex - pos);
parameterValue = ExpressionEvaluator.GetValue(null, expression, vars);
}
}
if (parameterValue == null)
{
return(null);
}
return(TypeConversionUtils.ConvertValueIfNecessary(memberType, parameterValue, null));
//var parseValue = parameterInfo == null
// ? TypeManipulation.ChangeToCompatibleType(parameterValue, memberType, memberInfo)
// : TypeManipulation.ChangeToCompatibleType(parameterValue, memberType, parameterInfo);
//return parseValue;
}
catch (Exception ex)
{
throw new DependencyResolutionException($"Value set error,can not resolve class type:{classType.FullName} =====>" +
$" {(parameterInfo == null ? memberType.Name : parameterInfo.Name)} "
+ (!string.IsNullOrEmpty(this.value) ? $",with value:[{this.value}]" : ""), ex);
}
}
private IEnumerable <KPI> ResolveInternal(string kpiName)
{
var calculator = _componentContext.ResolveKeyed <KPICalculatorBase>(kpiName);
var dependencies = CheckAndResolveKPIDependencies(calculator);
var result = calculator.Calculate(dependencies);
_kpiCache.AddKPIs(result);
return(result);
}
static void HandleWhen(IComponentContext scope, object when)
{
if (!scope.IsRegisteredWithKey <IHandle <object> >(when.GetType()))
{
NUnit.Framework.Assert.Fail(
"It appears you forgot to register a handler for the {0} message.",
when.GetType().Name);
}
scope.ResolveKeyed <IHandle <object> >(when.GetType()).Handle(when);
}
public static TService ResolveVersioned <TService>(this IComponentContext componentContext, int version)
{
var service = default(TService);
while (version > 0 && service == null)
{
service = componentContext.ResolveKeyed <TService>(version);
}
return(service);
}
private static IDataFileReaderService ResolveDataReader(IComponentContext context, ImportFormat importFormat)
{
ImportFormat baseFormat = importFormat & ~ImportFormat.Zip;
var res = context.ResolveKeyed <IDataFileReaderService>(baseFormat);
if ((importFormat & ImportFormat.Zip) == ImportFormat.Zip)
{
res = new ZipFileReaderService(res);
}
return(res);
}
/// <inheritdoc />
public override object Create(Type objectType)
{
if (objectType == null)
{
throw new ArgumentNullException(nameof(objectType));
}
return(_container.IsRegisteredWithKey(ContainerBuilderExtensions.ConfigurationRegistrationKey, objectType)
? _container.ResolveKeyed(ContainerBuilderExtensions.ConfigurationRegistrationKey, objectType)
: _container.Resolve(objectType));
}
public static DbContext ResolveDbContext <TEntity>(IComponentContext c) where TEntity : class, IEntity
{
var type = typeof(DbSet <TEntity>);
var dbName = TypeDictionary.GetOrAdd(type, t =>
{
var typeOfDatabase1 = typeof(Database1);
var entityInDatabase1 = typeOfDatabase1.GetProperties().FirstOrDefault(p => p.PropertyType == type);
return(entityInDatabase1 != null ? DbName.Db1: DbName.Db2);
});
return(c.ResolveKeyed <DbContext>(dbName));
}
decimal ITaxCalculator.Calculate(TaxCalculationContext context)
{
ITaxCalculatorStrategy calculator = null;
calculator = _componentContext.ResolveKeyed <ITaxCalculatorStrategy>(context.TaxationForm);
if (calculator == null)
{
throw new DomainException($"Tax calculator for {context.TaxationForm} not found");
}
return(calculator.Calculate(context));
}
public async Task <IResult <ParseResult> > FindOccurrences(SearchEnginesEnum searchEngine, string searchEngineSearchToken, string searchForUrl)
{
if (string.IsNullOrEmpty(searchEngineSearchToken))
{
return(new Result <ParseResult>("Please enter a search token", ErrorTypesEnum.BadRequest));
}
if (string.IsNullOrEmpty(searchForUrl))
{
return(new Result <ParseResult>("Please enter the website url", ErrorTypesEnum.BadRequest));
}
try
{
var ret = await _cacheService.GetOrSet($"{searchEngine}:{searchEngineSearchToken}:{searchForUrl}", async() =>
{
var queryBuilder = _context.ResolveKeyed <ISearchEngineQueryBuilder>(searchEngine);
var searchEngineResultParser = _context.ResolveKeyed <ISearchEngineResultParser>(searchEngine);
var url = queryBuilder.GetUrl(searchEngineSearchToken);
var response = await _httpHandler.GetAsync(url);
var content = await response.Content.ReadAsStringAsync();
var parseResult = searchEngineResultParser.Process(content, searchForUrl);
return(parseResult);
}, new CacheOptions
{
LocalTimeout = CacheOptions.Normal
});
return(new Result <ParseResult>(ret));
}
catch (Exception e)
{
_logger.LogError(e, "Couldn't impress the CEO.");
return(new Result <ParseResult>($"Sorry. An exception occurred. {e.Message}", ErrorTypesEnum.ServerError));
}
}
public static object ResolveConfigurationType([NotNull] this IComponentContext container, [NotNull] Type objectType)
{
if (container == null)
{
throw new ArgumentNullException(nameof(container));
}
if (objectType == null)
{
throw new ArgumentNullException(nameof(objectType));
}
return(container.IsRegisteredWithKey(ContainerBuilderExtensions.ConfigurationRegistrationKey, objectType)
? container.ResolveKeyed(ContainerBuilderExtensions.ConfigurationRegistrationKey, objectType)
: container.Resolve(objectType));
}
/// <summary>
/// Perform once-off startup processing.
/// </summary>
public void Start()
{
// Starting the communication layer takes quite a while
// so lets not block the current thread which is being used
// to start the application.
Task.Factory.StartNew(
() =>
{
try
{
PreStartInitialize();
// Start the communication layer so that we can actuallly use it.
var layer = m_Context.Resolve <IProtocolLayer>();
layer.SignIn();
foreach (var template in m_AllowedChannelTemplates)
{
var discovery = m_Context.ResolveKeyed <IBootstrapChannel>(template);
discovery.OpenChannel(m_AllowAutomaticChannelDiscovery);
}
// Initiate discovery of other services.
var discoverySources = m_Context.Resolve <IEnumerable <IDiscoverOtherServices> >();
foreach (var source in discoverySources)
{
source.StartDiscovery();
}
PostStartInitialize();
}
catch (Exception e)
{
m_Diagnostics.Log(
LevelToLog.Fatal,
CommunicationConstants.DefaultLogTextPrefix,
string.Format(
CultureInfo.InvariantCulture,
Resources.Log_Messages_FailedToStartCommunicationSystem_WithError,
e));
throw;
}
});
}
public INodeViewModel Create(INodeViewModel parent, string nodeType)
{
IDocumentNodeFactory factory = _container.ResolveOptionalKeyed <IDocumentNodeFactory>(nodeType);
if (factory == null)
{
factory = _container.ResolveKeyed <IDocumentNodeFactory>("default_node");
}
INodeViewModel node = factory.Create(parent, nodeType);
if (parent != null)
{
parent.Children.Add(node);
}
return(node);
}
protected override void Load(ContainerBuilder builder)
{
builder.RegisterType <BluetoothDeviceManager>().As <IBluetoothDeviceManager>().SingleInstance();
builder.RegisterType <InfraredDeviceManager>().As <IInfraredDeviceManager>().SingleInstance();
builder.RegisterType <DeviceRepository>().As <IDeviceRepository>().SingleInstance();
builder.RegisterType <DeviceManager>().As <IDeviceManager>().SingleInstance();
builder.RegisterType <SBrickDevice>().Keyed <Device>(DeviceType.SBrick);
builder.RegisterType <BuWizzDevice>().Keyed <Device>(DeviceType.BuWizz);
builder.RegisterType <BuWizz2Device>().Keyed <Device>(DeviceType.BuWizz2);
builder.RegisterType <InfraredDevice>().Keyed <Device>(DeviceType.Infrared);
builder.RegisterType <PoweredUpDevice>().Keyed <Device>(DeviceType.PoweredUp);
builder.Register <DeviceFactory>(c =>
{
IComponentContext ctx = c.Resolve <IComponentContext>();
return((deviceType, name, address) => ctx.ResolveKeyed <Device>(deviceType, new NamedParameter("name", name), new NamedParameter("address", address)));
});
}
public static Castle.DynamicProxy.IInterceptor[] GetInterceptors(this IComponentContext context, InterceptorIdentity[] ids)
{
var interceptors = new List <AbstractInterceptor>();
foreach (var interceptorsList in ids.Select(id => context.ResolveKeyed <IEnumerable <Proxy.AbstractInterceptor> >(id).ToList()))
{
if (interceptorsList.Count == 1)
{
interceptors.Add(interceptorsList[0]);
}
else if (interceptorsList.Count == 0)
{
throw new InvalidOperationException("no Interceptor registered for id ");
}
else
{
throw new InvalidOperationException(
"too many interceptors registered for id , only one intercpetor is allowed");
}
}
return(interceptors.ToArray());
}
public ResilientEntityFrameworkController(IComponentContext scope, Func<Owned<IControllerOperationLogger>> operationLoggerFactory)
: base(scope.ResolveKeyed<IMovieRepository>(EntityFrameworkModule.ResilientConnection), operationLoggerFactory)
{
}
public ResilientNHibernateController(IComponentContext scope, Func<Owned<IControllerOperationLogger>> operationLoggerFactory)
: base(scope.ResolveKeyed<IMovieRepository>(NHibernateModule.ResilientConnection), operationLoggerFactory)
{
}
static void HandleWhen(IComponentContext scope, object when)
{
if (!scope.IsRegisteredWithKey<IHandle<object>>(when.GetType()))
NUnit.Framework.Assert.Fail(
"It appears you forgot to register a handler for the {0} message.",
when.GetType().Name);
scope.ResolveKeyed<IHandle<object>>(when.GetType()).Handle(when);
}
