public static void RegisterInstances(this IObjectContainer objectContainer, IContainer container)
{
objectContainer.RegisterInstance <EmployerAccountTransactionsOrchestrator>(container);
objectContainer.RegisterInstance <EmployerAccountTransactionsController>(container);
objectContainer.RegisterInstance <EmployerFinanceConfiguration>(container);
objectContainer.RegisterInstance <IContainer>(container);
objectContainer.RegisterInstance <IHashingService>(container);
objectContainer.RegisterInstance <ILog>(container);
objectContainer.RegisterInstance <IMediator>(container);
objectContainer.RegisterInstance <IMessageSession>(container);
objectContainer.RegisterInstance <ITestTransactionRepository>(container);
objectContainer.RegisterInstance <ITransactionRepository>(container);
}
/// <summary>
/// 注册类型
/// </summary>
public static void RegisterMultiple(this IObjectContainer that, IEnumerable <Type> registrationTypes, object instance)
{
foreach (var registrationType in registrationTypes)
{
that.RegisterInstance(registrationType, instance);
}
}
internal void SetDefault(Type type, string name, object instance)
{
if (!_container.IsRegistered(type, name))
{
_container.RegisterInstance(type, instance, name);
}
}
public void BeforeScenario()
{
_objectContainer.RegisterInstance <IClock>(new DummyClock());
_objectContainer.RegisterTypeAs <InvocationRecorder, InvocationRecorder>();
_objectContainer.RegisterTypeAs <SlugFactory, ISlugFactory>();
_objectContainer.RegisterTypeAs <YamlMarkdown, IYamlMarkdown>();
ServiceLocator.SetLocatorProvider(() => new SpecFlowServiceLocator(_objectContainer));
}
public static T RegisterInstance <T>(this IObjectContainer container, T instance) where T : class
{
if (container == null)
{
return(instance);
}
container.RegisterInstance(instance, instance.GetType());
return(instance);
}
private static IMessageBus BuildMessageBus(AbstractConfiguration cfg)
{
ISubscriptionService subscriptionService = MessageBusConfigurationExtensions.GetSubscriptionService(cfg);
IMessageSink messageSink = MessageBusConfigurationExtensions.GetMessageSink(cfg);
IObjectContainer container = ObjectContainerConfigurationExtensions.GetObjectContainer(cfg);
IRouteManager routeManager = container.Resolve <IRouteManager>();
Xyperico.Agres.MessageBus.Implementation.MessageBus bus = new Agres.MessageBus.Implementation.MessageBus(subscriptionService, routeManager, messageSink);
container.RegisterInstance <IMessageBus>(bus);
return(bus);
}
private void RegisterDbContext(IObjectContainer container)
{
IDbRuleContext instance = new DbRuleContext();
container.RegisterInstance <IDbRuleContext>(instance);
if (!container.IsRegistered(typeof(ISqlFormatter)))
{
container.RegisterType <ISqlFormatter, SqlServerFormatter>(new object[0]);
}
InjectionProperty property = new InjectionProperty("DbObjectOperator", new ResolvedParameter <DbObjectOperator>());
InjectionProperty property2 = new InjectionProperty("DbRuleContext", new ResolvedParameter <IDbRuleContext>());
container.RegisterType <IDbContext, DbContext>(new object[] { property, property2 });
}
private static void RegisterInstance(this IObjectContainer container, object instance, Type type)
{
if (container == null || type.IsNotSubClassOrSameAs(instance))
{
return;
}
if (container.DoesNotContains(type))
{
container.RegisterInstanceAs(instance, type);
}
container.RegisterInstance(instance, type.BaseType);
}
/// <summary>
/// No more configuration needed for message bus - now configure something else or start the bus.
/// </summary>
/// <param name="cfg"></param>
/// <returns></returns>
public static BaseConfiguration Done(this MessageBusConfiguration cfg)
{
IObjectContainer container = ObjectContainerConfigurationExtensions.GetObjectContainer(cfg);
IDocumentStoreFactory subscriptionStoreFactory = GetSubscriptionStore(cfg);
if (!container.HasComponent(typeof(IRouteManager)))
{
container.AddComponent <IRouteManager, RouteManager>();
}
IRouteManager routeManager = container.Resolve <IRouteManager>();
ISubscriptionService subscriptionService = new SubscriptionService(subscriptionStoreFactory, routeManager);
cfg.Set(SubscriptionService_SettingsKey, subscriptionService);
container.RegisterInstance <ISubscriptionService>(subscriptionService);
return(new BaseConfiguration(cfg));
}
internal void Register(IObjectContainer container)
{
if (container.IsRegistered(this.GetServiceType(), this.ContractName))
{
return;
}
if (this.Instance != null)
{
container.RegisterInstance(this.ContractType, this.Instance, this.ContractName);
return;
}
if (this.ContractType == null)
{
container.RegisterType(this.TargetType, this.ContractName, this.Lifecycle);
}
else
{
container.RegisterType(this.ContractType, this.TargetType, this.ContractName, this.Lifecycle);
}
}
/// <summary>
/// No more configuration needed for event store - now configure something else or start event store.
/// </summary>
/// <param name="cfg"></param>
/// <returns></returns>
public static BaseConfiguration Done(this EventStoreConfiguration cfg)
{
IAppendOnlyStore aStore = cfg.Get <IAppendOnlyStore>(AppendOnlyStore_SettingsKey);
ISerializer messageSerializer = cfg.Get <ISerializer>(MessageSerializer_SettingsKey);
if (aStore == null)
{
throw new InvalidOperationException("Mising storage mechanism (IAppendOnlyStore) for event store.");
}
if (messageSerializer == null)
{
throw new InvalidOperationException("Missing event serializer for event store.");
}
EventStoreDB eStore = new EventStoreDB(aStore, messageSerializer);
cfg.Set(EventStoreDB_SettingsKey, eStore);
IObjectContainer container = Xyperico.Agres.Configuration.ObjectContainerConfigurationExtensions.GetObjectContainer(cfg);
container.RegisterInstance <IEventStore>(eStore);
return(new BaseConfiguration(cfg));
}
/// <summary>Register a implementer type instance as a service implementation.
/// </summary>
/// <typeparam name="TService">The service type.</typeparam>
/// <typeparam name="TImplementer">The implementer type.</typeparam>
/// <param name="instance">The implementer type instance.</param>
public static void RegisterInstance <TService, TImplementer>(TImplementer instance)
where TService : class
where TImplementer : class, TService
{
_container.RegisterInstance <TService, TImplementer>(instance);
}
/// <summary>
/// 注册一个实例
/// </summary>
/// <typeparam name="T">注册类型</typeparam>
/// <param name="that">容器</param>
/// <param name="instance">该类型的实例</param>
/// <param name="name">注册的名称</param>
public static void RegisterInstance <T>(this IObjectContainer that, T instance, string name = null)
{
Assertions.NotNull(instance, "instance");
that.RegisterInstance(typeof(T), instance, name);
}
public static void ConfigureContainer(IObjectContainer container)
{
container.AddComponent <IApplicationBaseAddress, WebContextApplicationBaseUrl>();
container.AddComponent <INameValueContextCollection, CallContextNamedValueCollection>();
container.RegisterInstance <IObjectResolver>(Xyperico.Base.ObjectContainer.Container);
}
public static void ConfigureContainer(IObjectContainer container)
{
container.AddComponent<IApplicationBaseAddress, WebContextApplicationBaseUrl>();
container.AddComponent<INameValueContextCollection, CallContextNamedValueCollection>();
container.RegisterInstance<IObjectResolver>(Xyperico.Base.ObjectContainer.Container);
}
/// <summary>
/// 注册唯一实例
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="container">The container.</param>
/// <param name="instance">The instance.</param>
/// <param name="key">The key.</param>
public static void RegisterInstance <T>(this IObjectContainer container, T instance, string key = null)
{
container.RegisterInstance(typeof(T), instance, key);
}
void IInitializer.Initialize(IObjectContainer container, IEnumerable<System.Reflection.Assembly> assemblies)
{
container.RegisterInstance(container);
}
/// <summary>
/// 注册一个实例
/// </summary>
/// <typeparam name="T">注册类型</typeparam>
/// <param name="that">容器</param>
/// <param name="instance">该类型的实例</param>
/// <param name="name">注册的名称</param>
public static void RegisterInstance <T>(this IObjectContainer that, T instance, string name = null)
{
that.RegisterInstance(typeof(T), instance, name);
}
public object Invoke(object instance, object[] inputs, out object[] outputs)
{
object result = null;
List <OperationAttribute> operationAttributes = null;
int num;
object obj3;
try
{
OperationAttribute current;
operationAttributes = this.GetOperationAttributes();
using (List <OperationAttribute> .Enumerator enumerator = operationAttributes.GetEnumerator())
{
while (enumerator.MoveNext())
{
current = enumerator.Current;
current.BeforeInvoke(instance, inputs);
}
}
result = this.invoker.Invoke(instance, inputs, out outputs);
if (operationAttributes.Count > 0)
{
for (num = operationAttributes.Count - 1; num >= 0; num--)
{
current = operationAttributes[num];
current.AfterInvoke(instance, inputs, result);
}
}
obj3 = result;
}
catch (Exception exception)
{
this.TryLog(exception);
try
{
if ((operationAttributes != null) && (operationAttributes.Count > 0))
{
for (num = operationAttributes.Count - 1; num >= 0; num--)
{
operationAttributes[num].OnInvokeError(instance, inputs, result);
}
}
}
catch
{
}
IObjectContainer objectContainer = ObjectContainerFactory.GetObjectContainer();
IExceptionFormatter formatter = null;
if (objectContainer.IsRegistered(typeof(IExceptionFormatter)))
{
formatter = objectContainer.Resolve <IExceptionFormatter>();
}
if (formatter == null)
{
formatter = new ExceptionFormatter();
objectContainer.RegisterInstance <IExceptionFormatter>(formatter);
}
throw formatter.Format(exception);
}
finally
{
try
{
WcfContext.Current.FindAll <DbObjectOperator>().ForEach(delegate(DbObjectOperator op)
{
try
{
op.DbOperator.Close();
}
catch
{
}
});
}
catch
{
}
}
return(obj3);
}
void IInitializer.Initialize(IObjectContainer container, IEnumerable <System.Reflection.Assembly> assemblies)
{
container.RegisterInstance(container);
this.container = builder.Build();
}
