/// <summary>
/// Additionally configures unity container with classes in Database access project
/// </summary>
/// <param name="container">Unity container instance</param>
public static void RegisterDependencies(IUnityContainer container)
{
container.RegisterType<IServiceBehavior, UmaConnNHibernateBehavior>("nHibernate");
container.RegisterInstance<ISessionFactory>(UmaConnNhibernateFactory.Instance, new ContainerControlledLifetimeManager());
container.RegisterType<ISession>(
new HierarchicalLifetimeManager(),
new InjectionFactory(c => container.Resolve<ISessionFactory>().OpenSession()));
container.RegisterType<IUmaMasterDataService, UmaMasterDataService>();
container.RegisterType<ICallHandler, UmaConnTransactionHandler>("TransactionHandler");
container.AddNewExtension<Interception>();
container.Configure<Interception>().SetInterceptorFor<UmaMasterDataService>(new TransparentProxyInterceptor());
// These extensions will handle cases where
// ILog is resolved as Property with [Dependency] attribute.
// Will create Logger with name of resolving Type.
// http://blog.baltrinic.com/software-development/dotnet/log4net-integration-with-unity-ioc-container
container
.AddNewExtension<BuildTracking>()
.AddNewExtension<LogCreation>();
// DO NOT DELETE THIS CODE UNLESS WE NO LONGER REQUIRE ASSEMBLY NLOG.EXTENDED!!!
var dummyCall = typeof(NLog.Web.NLogHttpModule);
var ok = dummyCall.Assembly.CodeBase;
}
public void Register(IUnityContainer unityContainer)
{
// this tracks the build-order for each resolve call
unityContainer.AddNewExtension<BuildTrackingExtension>();
// this creates the logger instance, depending on the resolve-callee over the BuildTracking
unityContainer.AddNewExtension<LogCreationExtension>();
// register the ILog type
unityContainer.RegisterType<ILog>(new TransientLifetimeManager());
}
public void Init()
{
Container = new UnityContainer();
Container.AddNewExtension<EnterpriseLibraryCoreExtension>();
Container.RegisterType<ILogHandler, LogHandler>();
Container.RegisterType<IConsoleRepository, ConsoleRepository>();
var mockCurrentHttpContext = new Mock<ICurrentHttpContext>();
var user = @"talbotdev\MurrayE";
user = user.Replace(@"\\", @"\");
mockCurrentHttpContext.Setup(h => h.CurrentUser).Returns(new GenericPrincipal(new GenericIdentity(user), null));
mockCurrentHttpContext.Setup(h => h.Context).Returns(MvcMockHelpers.FakeHttpContextWithSession());
var currentHttpContext = mockCurrentHttpContext.Object;
var mockSubscribeService = new Mock<IPolicyService>();
IPolicyService subscribeService = mockSubscribeService.Object;
IPolicyData policyData = Container.Resolve<PolicyData>(new ParameterOverride("currentHttpContext", currentHttpContext));
IWebSiteModuleManager webSiteModuleManager = Container.Resolve<WebSiteModuleManager>(new ParameterOverride("currentHttpContext", currentHttpContext));
PolicyBusinessModule = Container.Resolve<PolicyBusinessModule>(
new ParameterOverride("policyData", policyData),
new ParameterOverride("subscribeService", subscribeService),
new ParameterOverride("webSiteModuleManager", webSiteModuleManager));
}
public static void Init(TestContext context)
{
GetMockSubscribeService();
GetMockCurrentHttpContext();
CreateBasicSubmission();
CreateComplexSubmission();
CreateBasicEnergySubmission();
CreateComplexEnergySubmission();
CreateBasicCargoSubmission();
CreateComplexCargoSubmission();
CreateBasicHullSubmission();
CreateComplexHullSubmission();
CreateBasicMarineSubmission();
CreateComplexMarineSubmission();
_container = new UnityContainer();
_container.AddNewExtension<EnterpriseLibraryCoreExtension>();
_container.RegisterType<ILogHandler, LogHandler>();
_container.RegisterType<IConsoleRepository, ConsoleRepository>();
_container.RegisterType<IWebSiteModuleManager, WebSiteModuleManager>();
var mockPolicyData = new Mock<IPolicyData>();
//_container.RegisterType<IPolicyData, PolicyData>();
_container.RegisterInstance(typeof(IPolicyData), mockPolicyData.Object);
var consoleRepository = _container.Resolve<IConsoleRepository>();
SaveTestSubmission(consoleRepository);
_submissionModule =
_container.Resolve<SubmissionModule>(new ParameterOverride("currentHttpContext", _currentHttpContext),
new ParameterOverride("subscribeService", _mockSubscribeService));
}
public static void RegisterTypes(IUnityContainer container)
{
string[] assemblyNameParts = Assembly.GetExecutingAssembly().GetName().Name.Split('.');
string assemblyPrefix = string.Join(".", assemblyNameParts, 0, 1);
container.AddNewExtension<Interception>();
Predicate<Type> intercept = (t) =>
{
var interceptionConfiguration = container.Configure<Interception>();
if (t.IsConcrete() && !t.IsSealed && hasAttribute(t, typeof(LogAttribute)))
{
interceptionConfiguration.SetDefaultInterceptorFor(t, new VirtualMethodInterceptor());
}
return true;
};
Predicate<Assembly> includeAssembly = (a) =>
{
var assemblyName = a.GetName().Name;
return assemblyName.StartsWith(assemblyPrefix) && (assemblyName.Contains("Business") || assemblyName.Contains("Data"));
};
container.Configure(c =>
{
c.Scan(scan =>
{
scan.AssembliesInBaseDirectory(a => includeAssembly(a));
scan.Include(t => intercept(t));
scan.WithNamingConvention();
});
c.Configure<IDatabaseControlContext>().Using<HttpContextLifetimeManager<IDatabaseControlContext>>();
});
}
public static void SetupContainer()
{
// Create User
var user = new CurrentUser() { Username = "******", LabCode = "EUHAWE3" };
// Create Logger
var logger = new LoggerConfiguration()
.Enrich.FromLogContext()
.MinimumLevel.Warning() // Set MinimumLevel of Warning
.WriteTo.Seq("http://localhost:5341")
.CreateLogger();
unityContainer = new UnityContainer();
// Register User
unityContainer.RegisterInstance<ICurrentUser>(user);
// Add Interception Extension
unityContainer.AddNewExtension<Microsoft.Practices.Unity.InterceptionExtension.Interception>();
//Register Logger Instance
unityContainer.RegisterInstance<ILogger>(logger);
unityContainer.RegisterType<ISamRepository, SamRepository>()
.Configure<Microsoft.Practices.Unity.InterceptionExtension.Interception>()
.SetInterceptorFor<ISamRepository>(
new InterfaceInterceptor());
}
public void RegisterTypes(IUnityContainer container)
{
container.AddNewExtension<Interception>();
container.RegisterType<ITypeAdapter, AutoMapperTypeAdapter>()
.RegisterType<ICacheProvider, EntLibCacheProvider>(new ContainerControlledLifetimeManager())
//异常记录器
.RegisterType<ILogger, Log4netLogger>(LoggerName.ExceptionLogger.ToString(), new InjectionConstructor(LoggerName.ExceptionLogger.ToString()))
//日志记录器
.RegisterType<ILogger, Log4netLogger>(LoggerName.Logger.ToString(), new InjectionConstructor(LoggerName.Logger.ToString()))
.RegisterType<IRepositoryContext, EntityFrameworkRepositoryContext>()
.RegisterType<IRepository<IAggregateRoot>, EntityFrameworkRepository<IAggregateRoot>>();
////测试异常日志AOP专用
//var repo = new MockRepository();
//var stub = repo.Stub<ITermRepository>();
//stub.Expect(t => t.GetAll())
// .Throw(new ArgumentNullException("测试抛出的异常"));
//repo.ReplayAll();
//container.RegisterInstance<ITermRepository>(stub);
//执行异常日志测试时，注释该语句
container.RegisterType<ITermRepository, TermRepository>();
container.RegisterType<ITermAppl, TermAppl>(
//new Interceptor<InterfaceInterceptor>(),
//new InterceptionBehavior<CacheBehavior>(),
//new InterceptionBehavior<ExceptionLoggerBehavior>()
);
}
public static void RegisterContainer(IUnityContainer uc)
{
Log.Information("Begin Unity registration", CallerInfo.Create(), "");
uc.AddNewExtension<SimpleEventBrokerExtension>();
uc.RegisterType<FrmCertificate>();
uc.RegisterType<SendPOCController>();
uc.RegisterType<SendPOCViewmodel>();
uc.RegisterType<CertificateController>();
uc.RegisterType<CertificateViewModel>();
uc.RegisterType<IAddressBookModel, AddressBookModel>();
uc.RegisterType<eZustellServiceBase>(new ContainerControlledLifetimeManager());
uc.RegisterType<IeZustellService, eZustellService>(new ContainerControlledLifetimeManager());
uc.RegisterType<IRegistrationService, RegistrationService>(new ContainerControlledLifetimeManager());
uc.RegisterType<ICertificateService, CertificateService>(new ContainerControlledLifetimeManager());
uc.RegisterType<FrmLoadSaveCertificate>();
uc.RegisterType<LoadCertificateController>();
uc.RegisterType<LoadCertificateViewModel>();
uc.RegisterType<LoadSaveCertificateController>();
uc.RegisterType<LoadSaveCertificateViewModel>();
uc.RegisterType<SavePkcs12Controller>();
uc.RegisterType<SavePkcs12ViewModel>();
uc.RegisterType<SaveCertificateViewModel>();
uc.RegisterType<SaveCertificateController>();
uc.RegisterType<FrmAboutView>();
uc.RegisterType<AboutViewController>();
uc.RegisterType<AboutViewModel>();
}
public UnityCacheEnabledTests()
{
_container = new UnityContainer();
//Register interception
_container.AddNewExtension<Interception>();
//Register xCache
_container.RegisterType<ICache, MemoryCache>(new ContainerControlledLifetimeManager());
_container.RegisterType<ICache, MemoryCache>("One", new ContainerControlledLifetimeManager());
_container.RegisterType<ICache, MemoryCache>("Two", new ContainerControlledLifetimeManager());
_container.RegisterType<ICache, DictionaryCache>("DictionaryCache", new ContainerControlledLifetimeManager());
_container.RegisterType<ICacheKeyGenerator,JsonCacheKeyGenerator>(new ContainerControlledLifetimeManager());
_container.RegisterType<IDurableCacheQueue, TimedDurableCacheQueue>(
new ContainerControlledLifetimeManager(),
new InjectionFactory((c) => new TimedDurableCacheQueue(c.Resolve<IDurableCacheRefreshHandler>(), new TimeSpan(0,0,30))));
_container.RegisterType<IDurableCacheRefreshHandler, UnityDurableCacheRefreshHandler>(new ContainerControlledLifetimeManager());
//Register test class with interception
_container.RegisterType<ICacheEnableObject, UnityCacheEnabledObject>(
new InterceptionBehavior<PolicyInjectionBehavior>(),
new Interceptor<InterfaceInterceptor>());
_cached = _container.Resolve<ICacheEnableObject>();
}
/// <summary>WebARMters the type mappings with the Unity container.</summary>
/// <param name="container">The unity container to configure.</param>
/// <remarks>There is no need to WebARMter concrete types such as controllers or API controllers (unless you want to
/// change the defaults), as Unity allows resolving a concrete type even if it was not previously WebARMtered.</remarks>
public static void RegisterTypes(IUnityContainer container)
{
// NOTE: To load from web.config uncomment the line below. Make sure to add a Microsoft.Practices.Unity.Configuration to the using statements.
// container.LoadConfiguration();
// TODO: WebARMter your types here
container.RegisterType<IBaseRepository, BaseRepository>();
container.RegisterType<IGeneralSettingsRepository, GeneralSettingsRepository>();
container.RegisterType<IInfoChangeFileRepository, InfoChangeFileRepository>();
container.RegisterType<ILocalService, LocalService>();
container.RegisterType<IUserServiceProxy, UserServiceProxy>();
container.RegisterType<IUserCommitServiceProxy, UserCommitServiceProxy>();
container.RegisterType<IMainRepositoryServiceProxy, MainRepositoryServiceProxy>();
container.RegisterType<CreateCommand>();
container.RegisterType<UseCommand>();
container.RegisterType<ShowCommand>();
container.RegisterType<CommitCommand>();
container.RegisterType<IVCSmyServerService>("base", new InjectionFactory(c => WCFCannelFactory.Create()));
container.AddNewExtension<Interception>();
container.RegisterType<IVCSmyServerService>(
new InjectionFactory(c => container.Resolve<IVCSmyServerService>("base")),
new Interceptor<InterfaceInterceptor>(),
new InterceptionBehavior<WCFProxyInterceptor>());
container.RegisterType<IServer, Server>();
}
private void InitializeContainer()
{
container = new UnityContainer();
container.AddNewExtension<Interception>();
container.RegisterType<BusinessLogic.BankAccount>(
new InterceptionBehavior<PolicyInjectionBehavior>(),
new Interceptor<TransparentProxyInterceptor>());
container.Configure<Interception>()
.AddPolicy("policy-updates")
.AddMatchingRule<TypeMatchingRule>(
new InjectionConstructor(
new InjectionParameter(typeof(BusinessLogic.BankAccount))))
.AddMatchingRule<MemberNameMatchingRule>(
new InjectionConstructor(
new InjectionParameter(new string[] { "Deposit", "Withdraw" })))
.AddCallHandler<TraceCallHandler>(
new ContainerControlledLifetimeManager(),
new InjectionConstructor(
new TraceSource("interception-updates")))
.Interception
.AddPolicy("policy-query")
.AddMatchingRule<TypeMatchingRule>(
new InjectionConstructor(
new InjectionParameter(typeof(BusinessLogic.BankAccount))))
.AddMatchingRule<MemberNameMatchingRule>(
new InjectionConstructor("GetCurrentBalance"))
.AddCallHandler<TraceCallHandler>(
new ContainerControlledLifetimeManager(),
new InjectionConstructor(
new TraceSource("interception-queries")));
}
static ViewModelLocator()
{
BudgetMonitoringContainer = new UnityContainer();
BudgetMonitoringContainer.AddNewExtension<Interception>();
BudgetMonitoringContainer.RegisterType<BudgetMonitoringViewModel>().Configure<Interception>().SetInterceptorFor<BudgetMonitoringViewModel>(new VirtualMethodInterceptor());
BankAccountContainer = new UnityContainer();
BankAccountContainer.AddNewExtension<Interception>();
BankAccountContainer.RegisterType<BankAccountViewModel>().Configure<Interception>().SetInterceptorFor<BankAccountViewModel>(new VirtualMethodInterceptor());
CategoryContainer = new UnityContainer();
CategoryContainer.AddNewExtension<Interception>();
CategoryContainer.RegisterType<CategoryViewModel>().Configure<Interception>().SetInterceptorFor<CategoryViewModel>(new VirtualMethodInterceptor());
TransferContainer = new UnityContainer();
TransferContainer.AddNewExtension<Interception>();
TransferContainer.RegisterType<TransferViewModel>().Configure<Interception>().SetInterceptorFor<TransferViewModel>(new VirtualMethodInterceptor());
RegistrationContainer = new UnityContainer();
RegistrationContainer.AddNewExtension<Interception>();
RegistrationContainer.RegisterType<RegistrationViewModel>().Configure<Interception>().SetInterceptorFor<RegistrationViewModel>(new VirtualMethodInterceptor());
MainContainer = new UnityContainer();
MainContainer.AddNewExtension<Interception>();
MainContainer.RegisterType<MainViewModel>(new ContainerControlledLifetimeManager()).Configure<Interception>().SetInterceptorFor<MainViewModel>(new VirtualMethodInterceptor());
}
private void InitializeContainer()
{
container = new UnityContainer();
container.AddNewExtension<Interception>();
container.RegisterType<BusinessLogic.BankAccount>(
new Interceptor<VirtualMethodInterceptor>(),
new InterceptionBehavior(new TraceBehavior(new TraceSource("interception"))));
}
private void InitializeContainer()
{
container = new UnityContainer();
container.AddNewExtension<Interception>();
container.RegisterType<BusinessLogic.BankAccount>(
new InterceptionBehavior<PolicyInjectionBehavior>(),
new Interceptor<TransparentProxyInterceptor>());
}
/// <summary>Registers the type mappings with the Unity container.</summary>
/// <param name="container">The unity container to configure.</param>
/// <remarks>There is no need to register concrete types such as controllers or API controllers (unless you want to
/// change the defaults), as Unity allows resolving a concrete type even if it was not previously registered.</remarks>
public static void RegisterTypes(IUnityContainer container)
{
// NOTE: To load from web.config uncomment the line below. Make sure to add a Microsoft.Practices.Unity.Configuration to the using statements.
// container.LoadConfiguration();
// TODO: Register your types here
// container.RegisterType<IProductRepository, ProductRepository>();
container.AddNewExtension<DataContainerExtension>();
}
public void Init()
{
_container = new UnityContainer();
_container.AddNewExtension<EnterpriseLibraryCoreExtension>();
_logHandler = _container.Resolve<LogHandler>();
// Note: this path is also set in "Rolling Flat File Trace Listener" section
_logFileLocation = ConfigurationManager.AppSettings["logFileLocation"].ToString();
}
public void Setup()
{
_unityContainer = new UnityContainer();
_unityContainer.AddNewExtension<LoggingExtension>();
_logger = Substitute.For<ILogger>();
_unityContainer.RegisterType<MarkedVirtualMethod>();
_unityContainer.RegisterType<MarkedClassWithVirtualMethod>();
_unityContainer.RegisterInstance(_logger);
}
public void Setup()
{
container = new UnityContainer();
container.RegisterType<ICallHandler, MyCallHandler>("MyHandler", new ContainerControlledLifetimeManager());
container.AddNewExtension<Interception>();
container.Configure<Interception>()
.AddPolicy("My Policy")
.AddMatchingRule(new AlwaysMatchingRule())
.AddCallHandler("MyHandler");
}
public void SetUp()
{
container = new UnityContainer();
container
.AddNewExtension<Interception>()
.AddNewExtension<LogAllMethodCalls>()
.RegisterInstance<ILogger>(new InMemoryLogger(), new ContainerControlledLifetimeManager())
.RegisterAndIntercept(new TestLoggingClass());
obj = container.Resolve<TestLoggingClass>();
}
/// <summary>
/// Initializes the container.
/// </summary>
private static void InitializeContainer()
{
Container = new UnityContainer();
Container.AddNewExtension<Interception>();
Container.RegisterType<IEvalActions, EvalActions>().Configure<Interception>().SetInterceptorFor<IEvalActions>(new InterfaceInterceptor());
Container.RegisterType<IHuntActions, HuntActions>().Configure<Interception>().SetInterceptorFor<IHuntActions>(new InterfaceInterceptor());
Container.RegisterType<IKillActions, KillActions>().Configure<Interception>().SetInterceptorFor<IKillActions>(new InterfaceInterceptor());
Container.RegisterType<IParamActions, ParamActions>().Configure<Interception>().SetInterceptorFor<IParamActions>(new InterfaceInterceptor());
Container.RegisterType<IPlayerActions, PlayerActions>().Configure<Interception>().SetInterceptorFor<IPlayerActions>(new InterfaceInterceptor());
Container.RegisterType<ISystemActions, SystemActions>().Configure<Interception>().SetInterceptorFor<ISystemActions>(new InterfaceInterceptor());
}
public void Setup()
{
_unityContainer = new UnityContainer();
_unityContainer.AddNewExtension<LoggingExtension>();
_logger = Substitute.For<ILogger>();
_unityContainer.RegisterType<IMarkedClass, MarkedClassInstance>();
_unityContainer.RegisterType<IMarkedClassMethod, MarkedClassMethodInstance>();
_unityContainer.RegisterType<IMarkedInterface, MarkedInterfaceInstance>();
_unityContainer.RegisterType<IMarkedInterfaceMethod, MarkedInterfaceMethodInstance>();
_unityContainer.RegisterInstance(_logger);
}
public static void RegisterTypes(IUnityContainer container)
{
container.AddNewExtension<Interception>();
container.RegisterType<IServicesPurchases<Purchase>, ServicesPurchases>(new HierarchicalLifetimeManager());
container.RegisterType<IServicesProducts<Products>, ServicesProducts>(new HierarchicalLifetimeManager());
container.RegisterType<IServicesBuyers<Buyers>, ServicesBuyers>(new HierarchicalLifetimeManager());
container.RegisterType<IServicesVendors<Vendors>, ServicesVendors>(new HierarchicalLifetimeManager());
container.RegisterType<IOtherServices, OtherServices>(new HierarchicalLifetimeManager());
container.RegisterType<IUnitOfWork, UnitOfWork>(new PerResolveLifetimeManager());
container.RegisterType<ISearchClass, SearchClass>(new HierarchicalLifetimeManager());
container.RegisterType<ILogging, Logging>(new HierarchicalLifetimeManager(),
new InjectionConstructor(LogManager.GetLogger(typeof (Logging))));
}
/// <summary>Registers the type mappings with the Unity Container.</summary>
/// <param name="container">The unity Container to configure.</param>
/// <remarks>There is no need to register concrete types such as controllers or API controllers (unless you want to
/// change the defaults), as Unity allows resolving a concrete type even if it was not previously registered.</remarks>
public static void RegisterTypes(IUnityContainer container)
{
// NOTE: To load from web.config uncomment the line below. Make sure to add a Microsoft.Practices.Unity.Configuration to the using statements.
// Container.LoadConfiguration();
// Register services
container.AddNewExtension<Log4NetExtension>();
container.RegisterType(typeof (IApi<>), typeof (Api<>))
.RegisterType<ICache, WebCache>()
.RegisterType<IRatingKeyRepository,RatingKeyRepository>()
.RegisterType<IEstablishmentRepository, EstablishmentRepository>()
.RegisterType<IAuthorityRepository, AuthorityRepository>();
}
public static void RegisterDependencies(IUnityContainer container)
{
// These extensions will handle cases where
// ILog is resolved as Property with [Dependency] attribute.
// Will create Logger with name of resolving Type.
// http://blog.baltrinic.com/software-development/dotnet/log4net-integration-with-unity-ioc-container
container
.AddNewExtension<BuildTracking>()
.AddNewExtension<LogCreation>();
// DO NOT DELETE THIS CODE UNLESS WE NO LONGER REQUIRE ASSEMBLY NLOG.EXTENDED!!!
var dummyCall = typeof(NLog.Web.NLogHttpModule);
var ok = dummyCall.Assembly.CodeBase;
}
protected void Setup()
{
StatsdMock = new Mock<IVeStatsDClient>();
Container = new UnityContainer();
Container.RegisterInstance(StatsdMock.Object);
Container.AddNewExtension<Interception>();
Container.RegisterType<IOverloadedMethodsClass, OverloadedMethodsClass>(
new Interceptor<InterfaceInterceptor>(),
new InterceptionBehavior<StatsDClient.Unity.StatsDTimingInterceptor>()
);
Service = Container.Resolve<IOverloadedMethodsClass>();
}
public static void Configure(IUnityContainer container)
{
container
.AddNewExtension<EnterpriseLibraryCoreExtension>()
.RegisterType<IProfileStore, SimulatedLdapProfileStore>(new ContainerControlledLifetimeManager())
.RegisterType<IUserRepository, UserRepository>(new ContainerControlledLifetimeManager())
.RegisterType<AExpense.Model.User>(new Interceptor<VirtualMethodInterceptor>(),
new InterceptionBehavior<TracingBehavior>())
.RegisterType<IExpenseRepository, ExpenseRepository>(new ContainerControlledLifetimeManager(),
new Interceptor<VirtualMethodInterceptor>(),
new InterceptionBehavior<PolicyInjectionBehavior>());
// Set default locator so we can use it from
UnityServiceLocator locator = new UnityServiceLocator(container);
ServiceLocator.SetLocatorProvider(() => locator);
}
public static void Init(TestContext context)
{
GetMockSubscribeService();
GetMockCurrentHttpContext();
CreateBasicSubmission();
CreateComplexSubmission();
_container = new UnityContainer();
_container.AddNewExtension<EnterpriseLibraryCoreExtension>();
_logHandler = _container.Resolve<LogHandler>();
_consoleRepository = _container.Resolve<ConsoleRepository>();
var mockCurrentHttpContext = new Mock<CurrentHttpContext>();
var user = @"talbotdev\MurrayE";
user = user.Replace(@"\\", @"\");
mockCurrentHttpContext.Setup(h => h.CurrentUser).Returns(new GenericPrincipal(new GenericIdentity(user), null));
mockCurrentHttpContext.Setup(h => h.Context).Returns(MvcMockHelpers.FakeHttpContextWithSession());
}
static void Main(string[] args)
{
Container = new UnityContainer();
Container.AddNewExtension<Interception>();
Container.RegisterType<IPrescription, Prescription>();
Container.RegisterType<IPrescriptionService, PrescriptionService>(
new Interceptor<InterfaceInterceptor>(),
new InterceptionBehavior<AuditingInterceptionBehavior>());
IPrescriptionService service = Container.Resolve<IPrescriptionService>();
IPrescription prescription = service.GetPrescriptionByID(1);
Console.WriteLine("Retrieved: {0}", prescription);
Console.ReadKey();
}
public static void Configure(IUnityContainer container)
{
// Get Entlib config source (Current is in Web.EnterpriseLibrary.config)
IConfigurationSource source = ConfigurationSourceFactory.Create();
// Config container from Policy injection config settings
var policyInjectionSettings = (PolicyInjectionSettings)source.GetSection(PolicyInjectionSettings.SectionName);
policyInjectionSettings.ConfigureContainer(container);
// Config retry policy
var retryPolicySettings = RetryPolicyConfigurationSettings.GetRetryPolicySettings(source);
// turn off throwIfSet for unit testing
RetryPolicyFactory.SetRetryManager(retryPolicySettings.BuildRetryManager(), throwIfSet: false);
// get factories from config
var policyFactory = new ExceptionPolicyFactory(source);
var dbFactory = new DatabaseProviderFactory(source);
var validationFactory = ConfigurationValidatorFactory.FromConfigurationSource(source);
// Set default locator
UnityServiceLocator locator = new UnityServiceLocator(container);
ServiceLocator.SetLocatorProvider(() => locator);
container
.AddNewExtension<Interception>()
// register Entlib types with appropiate factory
.RegisterType<ExceptionManager>(new InjectionFactory(c => policyFactory.CreateManager()))
.RegisterType<Database>(new InjectionFactory(c => dbFactory.CreateDefault()))
.RegisterInstance<ValidatorFactory>(validationFactory)
// use registration by convention extension for registering app types; IProfileStore, IUserRepository
.RegisterTypes(AllClasses.FromAssemblies(Assembly.GetExecutingAssembly()),
WithMappings.FromAllInterfacesInSameAssembly,
WithName.Default,
WithLifetime.ContainerControlled)
// register types with interception
.RegisterType<AExpense.Model.User>(new Interceptor<VirtualMethodInterceptor>(),
new InterceptionBehavior<TracingBehavior>())
.RegisterType<IExpenseRepository, ExpenseRepository>(new Interceptor<VirtualMethodInterceptor>(),
new InterceptionBehavior<PolicyInjectionBehavior>());
}
/// <summary>Registers the type mappings with the Unity container.</summary>
/// <param name="container">The unity container to configure.</param>
/// <remarks>There is no need to register concrete types such as controllers or API controllers (unless you want to
/// change the defaults), as Unity allows resolving a concrete type even if it was not previously registered.</remarks>
public static void RegisterTypes(IUnityContainer container)
{
//container.RegisterTypes(
// AllClasses.FromAssembliesInBasePath(),
// WithMappings.FromMatchingInterface,
// WithName.Default,
// WithLifetime.ContainerControlled);
container.AddNewExtension<Interception>();
container.RegisterType<IMapper<Domain.Entities.Template, DistributedServices.Entities.TemplateDto>, TemplateMapper>();
container.RegisterType<ICache<TemplateDto>, MemoryCache<TemplateDto>>(new Interceptor<InterfaceInterceptor>(), new InterceptionBehavior<LoggingInterceptBehavior>());
container.RegisterType<ICacheConfiguration, CacheConfiguration>(new Interceptor<InterfaceInterceptor>(), new InterceptionBehavior<LoggingInterceptBehavior>());
container.RegisterType<ILoggingConfiguration, LoggingConfiguration>();
container.RegisterType<IAuthorizationConfiguration, AuthorizationConfiguration>();
container.RegisterType<IAppLogger, AppLogger>();
container.RegisterType<ITemplateService, TemplateService>(new Interceptor<InterfaceInterceptor>(), new InterceptionBehavior<LoggingInterceptBehavior>());
container.RegisterType<ITemplateRepository, MockTemplateRepository>();
}
/// <summary>
/// Registers the type mappings with the Unity container.
/// </summary>
/// <param name="container">The unity container to configure.</param>
/// <remarks>
/// There is no need to register concrete types such as controllers or
/// API controllers (unless you want to change the defaults), as Unity
/// allows resolving a concrete type even if it was not previously
/// registered.
/// </remarks>
public static void RegisterTypes(IUnityContainer container)
{
// NOTE: To load from web.config uncomment the line below.
// Make sure to add a Unity.Configuration to the using statements.
// container.LoadConfiguration();
// TODO: Register your type's mappings here.
// container.RegisterType<IProductRepository, ProductRepository>();
container.RegisterType <IUsuariosService <Usuarios>, UsuariosService <Usuarios> >();
container.RegisterType <IPreguntasService <Preguntas>, PreguntasService <Preguntas> >();
container.RegisterType <ITecnologiasService <Tecnologias>, TecnologiasService <Tecnologias> >();
container.RegisterType <INivelesService <Niveles>, NivelesService <Niveles> >();
container.AddNewExtension <DependencyInjectionExtension>();
var config = new MapperConfiguration(c =>
{
c.AddProfile <MappingProfile>();
});
var mapper = config.CreateMapper();
container.RegisterInstance <IMapper>(mapper);
}
public IUnityContainer Configure(IUnityContainer container)
{
var childBootstrappers = new IContainerBootstrapper[]
{
new Gdcame.NotifyConsumer.ContainerBootstrapper()
};
Array.ForEach(childBootstrappers, _ => _.Configure(container));
container.AddNewExtension <Interception>();
GlobalHost.DependencyResolver = new SignalRDependencyResolver(container);
container.RegisterType <ILogger>(new InjectionFactory(
_ => new Logger(new NLoggerAdapter((new NLogLogExFactory()).GetLogger("logger")))));
container.RegisterType <INotifyConsumerService, NotifyConsumerService>(new InjectionConstructor(
new ResolvedParameter <ILogger>(),
new ResolvedParameter <IMapper <GameData, GameDataModel> >(),
new ResolvedParameter <IHubContextAccessor>(),
new ResolvedParameter <IConnections>()
)
, new Interceptor <InterfaceInterceptor>()
, new InterceptionBehavior <LoggerInterceptor>()
);
if (!Environment.UserInteractive)
{
container.RegisterType <IServiceInfoHelper, ServiceInfoHelperLogger>();
}
else
{
container.RegisterType <IServiceInfoHelper, ServiceInfoHelperConsole>();
}
return(container);
}
public static void Configure(IUnityContainer container)
{
container.AddNewExtension <Interception>();
container.RegisterType <Game>(
new InjectionProperty("Rules", new[]
{
RuleBuilder <Game> .Instance()
.Given(State <Game> .IsAny())
.Then(g => g.ScoreRule = (frames) => frames.Sum(frame => frame.Score)).Build(),
RuleBuilder <Game> .Instance()
.Given(State <Game> .IsAny())
.Then(g => g.TooManyPins = (frame, pins) => (!frame.IsStrikeOrSpare && frame.Rolls.FirstOrDefault() + pins > 10) || (frame.IsStrikeOrSpare && frame.Rolls[0] + pins > 20)).Build(),
RuleBuilder <Game> .Instance()
.Given(g => g.CurrentFrame.IsFinalFrame)
.Then(g => g.CurrentFrame.ScoreRule = (f) => f.Rolls.Sum(r => r)).Build(),
RuleBuilder <Game> .Instance()
.Given(g => !g.CurrentFrame.IsFinalFrame)
.And(g => g.CurrentFrame.Rolls.Sum(r => r) < 10)
.Then(g => g.CurrentFrame.ScoreRule = (f) => f.Rolls.Sum(r => r)).Build(),
RuleBuilder <Game> .Instance()
.Given(g => !g.CurrentFrame.IsFinalFrame)
.And(g => g.CurrentFrame.Rolls.Sum(r => r).Between(10, 19))
.Then(g => g.CurrentFrame.ScoreRule = (f) => f.Rolls.Sum(r => r) + f.NextFrame.Rolls.FirstOrDefault()).Build(),
RuleBuilder <Game> .Instance()
.Given(g => !g.CurrentFrame.IsFinalFrame)
.And(g => g.CurrentFrame.Rolls.Sum(r => r) == 20)
.Then(g => g.CurrentFrame.ScoreRule = (f) => 20 + f.NextFrame.Rolls.Take(2).Sum(r => r).Max(10)).Build()
}),
new Interceptor <VirtualMethodInterceptor>(),
new InterceptionBehavior <RuleInterceptionBehavior <Game> >());
}
private ObjectFactory()
{
try
{
container = new UnityContainer();
UnityConfigurationSection section = (UnityConfigurationSection)ConfigurationManager.GetSection("unity");
section.Configure(container);
container.AddNewExtension <UnityPolicyExtension>();
switch (ConfigurationManager.AppSettings["logLevel"].ToLower())
{
case "off":
Logger.SetLevel(Logger.Level.OFF);
break;
case "error":
Logger.SetLevel(Logger.Level.ERROR);
break;
case "info":
Logger.SetLevel(Logger.Level.INFO);
break;
case "debug":
Logger.SetLevel(Logger.Level.DEBUG);
break;
}
//LogWriterFactory factory = new LogWriterFactory(new SystemConfigurationSource());
//LogWriter logWriter = factory.Create();
//Logger.SetLogger(logWriter);
}
catch (Exception ex)
{
throw new AppException("Can't get the context of the Application", ex);
}
}
public static void InterceptUsingPolicyInjection(IUnityContainer container)
{
ConsoleHelper.WriteGreenLine("Intercept using policy injection...");
container.AddNewExtension <Interception>();
container.RegisterType <IConnectionStringCache, SimpleConnectionStringCache>();
container.RegisterType <IConnectionStringStorage, SimpleConnectionStringStorage>(
new InterceptionBehavior <PolicyInjectionBehavior>(),
new Interceptor <InterfaceInterceptor>());
var first = new InjectionProperty("Order", 1);
var cache = new InjectionProperty("Cache", container.Resolve <IConnectionStringCache>());
var second = new InjectionProperty("Order", 2);
container.Configure <Interception>()
.AddPolicy("logging")
.AddMatchingRule <AssemblyMatchingRule>(new InjectionConstructor(new InjectionParameter("Practice.Unity.Storage")))
.AddCallHandler <LoggingCallHandler>(new ContainerControlledLifetimeManager(), new InjectionConstructor(), first);
container.Configure <Interception>()
.AddPolicy("caching")
.AddMatchingRule <MemberNameMatchingRule>(new InjectionConstructor(new[] { "Get*" /*, "Save*"*/ }, true))
.AddMatchingRule <NamespaceMatchingRule>(new InjectionConstructor("Practice.Unity.Storage", true))
.AddCallHandler <ConnectionStringCachingCallHandler>(new ContainerControlledLifetimeManager(), new InjectionConstructor(), second, cache);
var storage = container.Resolve <IConnectionStringStorage>();
Console.WriteLine("执行方法");
Random random = new Random((int)DateTime.Now.Ticks);
string res;
for (int i = 0; i < 4; i++)
{
string key = string.Format("12{0}", random.Next(3));
res = storage.GetConnectionString(key);
Console.WriteLine(string.Format("获取键值为{0}的结果为：{1}", key, res));
}
}
public static IUnityContainer GetUnityContainer()
{
Current.RegisterType <IControllerActivator, CustomControllerActivator>();
container.AddNewExtension <Interception>();
//DAL();
//SysRepository();
//SysBll();
//SysService();
//第一种
//UnityConfigurationSection section = (UnityConfigurationSection)System.Configuration.ConfigurationManager.GetSection("unity");
//section.Containers[0].Configure(container);
//第二种
//container.LoadConfiguration("containerOne");
//第三种
//UnityConfigurationSection section = (UnityConfigurationSection)ConfigurationManager.GetSection("unity");
//section.Containers["containerOne"].Configure(container);
//独立配置文件
var unityConfig = System.AppDomain.CurrentDomain.BaseDirectory + @"Config\unity.config";
var fileMap = new ExeConfigurationFileMap()
{
ExeConfigFilename = unityConfig
};
var configuration = ConfigurationManager.OpenMappedExeConfiguration(fileMap, ConfigurationUserLevel.None);
var unitySection = (UnityConfigurationSection)configuration.GetSection("unity");
//container.LoadConfiguration(unitySection);
unitySection.Containers["containerOne"].Configure(container);
return(Current);
}
static ServiceLoader()
{
try
{
UnityConfigurationSection unitySection = ConfigurationManager.GetSection("unity") as UnityConfigurationSection;
if (unitySection == null)
{
throw new ConfigurationErrorsException(string.Format(CultureInfo.CurrentCulture, "缺少Unity配置部分."));
}
Container = new UnityContainer();
foreach (var item in unitySection.Containers)
{
item.Configure(Container);
}
//unitySection.Configure(Container);
Container.AddNewExtension <Interception>();
}
catch (Exception ex) {
throw new ConfigurationErrorsException(ex.ToString());
}
//LoadMapper();
}
public static void Setup(IUnityContainer container)
{
container.AddNewExtension <Interception>();
var assemblies = AppDomain.CurrentDomain.GetAssemblies();
aspectsTypes = new List <Type>();
foreach (var asm in assemblies)
{
aspectsTypes.AddRange(asm.GetTypes().Where(t => typeof(IAspectAttribute).IsAssignableFrom(t) && t.IsClass));
}
AspectConfiguration.container = container;
//var interceptionConfiguration = container.Configure<Interception>();
//foreach (var asm in assemblies)
//{
// foreach (var type in asm.GetTypes())
// {
// foreach (var method in type.GetMethods())
// {
// foreach (var aspectType in aspectsTypes)
// {
// if (method.IsDefined(aspectType, false))
// {
// interceptionConfiguration.AddPolicy("xpto").AddMatchingRule(
// new CustomAttributeMatchingRule(aspectType, false));
// }
// }
// }
// }
//}
}
public static IUnityContainer RegisterTypes(
IUnityContainer container,
LoaderProperties loaderProperties,
IntegrationProperties integrationProperties,
Properties properties)
{
//fix Diagnostic extension
container.RegisterType <ILoggerFactory, LoggerFactory>(
new ContainerControlledLifetimeManager(), new InjectionConstructor(new ResolvedParameter <IEnumerable <ILoggerProvider> >())
);
container.AddExtension(new Diagnostic());
container.RegisterType <DynamicResourceDictionaryContainer>();
container.RegisterType <ProcessRemoteValidationIf>();
container.AddNewExtension <LoaderConfigurationExtension>();
container.AddNewExtension <ActionContainerConfiguration>();
container.AddNewExtension <TaskContainerConfiguration>();
container.AddNewExtension <ValidationConfiguration>();
container.RegisterType <IConnectionProvider, CoreConnectionProvider>();
container.RegisterType <ICustomerProvider, CustomerProvider>();
container.RegisterType <IIdentityProvider, CoreIdentityWithSessionProvider>();
// логируем в консоль
//container.RegisterInstance<ILogger>(new TextWriterLogger(Console.Out));
container.RegisterInstance <ILogger>(new NLogLogger("NLogClient.config"));
container.RegisterType <IContentDefinitionService, ContentDefinitionService>();
container.RegisterType <DefinitionEditorService>();
container
.RegisterType <IXmlProductService, XmlProductService>()
.RegisterType <IUserProvider, HttpContextUserProvider>()
.RegisterType <IQPNotificationService, QPNotificationService>()
// change default provider to filesystem-based one since it does not require app to recompile on changes.
// AppDataProductControlProvider does not cache reads from disk
.RegisterType <IProductControlProvider, ContentBasedProductControlProvider>();
container.RegisterFactory <CustomActionService>(c =>
{
var customer = c.Resolve <IConnectionProvider>().GetCustomer();
return(new CustomActionService(
new QpConnectionInfo(customer.ConnectionString, (DatabaseType)customer.DatabaseType),
1));
});
container.RegisterType <IRegionTagReplaceService, RegionTagService>();
container.RegisterType <IRegionService, RegionService>();
container.RegisterType <INotesService, NotesFromContentService>();
container.RegisterType <IProductUpdateService, ProductUpdateService>();
//container.RegisterType<IRegionTagReplaceService, RegionTagReplaceService>();
BindingValueProviderFactory.Current = new DefaultBindingValueProviderFactory(new QPModelBindingValueProvider());
container.RegisterType <ILoggerFactory, LoggerFactory>(new ContainerControlledLifetimeManager(), new InjectionConstructor(new ResolvedParameter <IEnumerable <ILoggerProvider> >()));
container.RegisterType <ITaskService, TaskService>();
container.RegisterType <IProductRelevanceService, ProductRelevanceService>();
var entitiesAssembly = typeof(IArticleFilter).Assembly;
foreach (var filterClass in entitiesAssembly.GetExportedTypes().Where(x => typeof(IArticleFilter).IsAssignableFrom(x) && x.IsClass && !x.IsAbstract))
{
container.RegisterType(typeof(IArticleFilter), filterClass, filterClass.Name);
}
container.RegisterType <IProductChangeSubscriber, RelevanceUpdaterOnProductChange>("RelevanceUpdaterOnProductChange");
container.RegisterFactory <IProductChangeNotificator>(x =>
{
var notificator = new ProductChangeNotificator(x.Resolve <ILogger>());
notificator.AddSubscribers(x.ResolveAll <IProductChangeSubscriber>());
return(notificator);
}, new ContainerControlledLifetimeManager());
container.RegisterType <IContentProvider <NotificationChannel>, NotificationChannelProvider>();
container.AddNewExtension <FormattersContainerConfiguration>();
container.RegisterType <StructureCacheTracker>();
container.RegisterType <IWarmUpProvider, ProductLoaderWarmUpProvider>();
container.RegisterSingleton <WarmUpRepeater>();
switch (loaderProperties.SettingsSource)
{
case SettingsSource.Content:
container.RegisterType <ISettingsService, SettingsFromContentCoreService>(new InjectionConstructor(typeof(VersionedCacheProviderBase), typeof(IConnectionProvider), loaderProperties.SettingsContentId));
break;
case SettingsSource.AppSettings:
container.RegisterType <ISettingsService, SettingsFromQpCoreService>();
break;
}
switch (loaderProperties.DefaultSerializer)
{
case DefaultSerializer.Json:
container.RegisterType <IArticleFormatter, JsonProductFormatter>();
break;
case DefaultSerializer.Xml:
container.RegisterType <IArticleFormatter, XmlProductFormatter>();
break;
}
var connection = container.Resolve <IConnectionProvider>();
if (connection.QPMode)
{
container
.RegisterConsolidationCache(properties.AutoRegisterConsolidationCache)
.As <IFactory>()
.With <FactoryWatcher>(properties.WatcherInterval)
.Watch();
}
else
{
container.RegisterType <ICustomerProvider, SingleCustomerCoreProvider>()
.RegisterConsolidationCache(properties.AutoRegisterConsolidationCache, SingleCustomerCoreProvider.Key)
.As <IFactory>()
.With <FactoryWatcher>()
.WithCallback((sender, e) => { container.Resolve <WarmUpRepeater>().Start(); })
.Watch();
}
if (connection.QPMode || connection.UseQPMonitoring)
{
container.RegisterQpMonitoring();
}
else
{
container.RegisterNonQpMonitoring();
}
RegisterExtraValidation(container, integrationProperties);
return(container);
}
public static void RegisterTypes(IUnityContainer container)
{
container.RegisterType <IAuthenticationManager>(new InjectionFactory(c => HttpContext.Current.GetOwinContext().Authentication));
container.AddNewExtension <BusinessLogicUnityExtension>();
}
private static void SetDefaultLifetimeManager(IUnityContainer container)
{
container.AddNewExtension <LifetimeContainerExtension>();
}
internal static IUnityContainer AddParameterizedAutoFactoryExtension(this IUnityContainer container) => container.AddNewExtension <UnityParameterizedAutoFactoryExtension>();
internal override void Execute(IUnityContainer container)
{
container.AddNewExtension <T>();
}
public static void RegisterTypes(IUnityContainer container)
{
container.AddNewExtension <Interception>();
var connectionString =
System.Web.Configuration.WebConfigurationManager.ConnectionStrings["Mongo"].ConnectionString;
var database = System.Web.Configuration.WebConfigurationManager.ConnectionStrings["Mongo"].ProviderName;
container.RegisterType <IMongoConnectionHandler, MongoConnectionHandler>(
new ContainerControlledLifetimeManager(),
new InjectionConstructor(connectionString, database));
// orchestrators
container.RegisterTypes(
AllClasses.FromLoadedAssemblies().Where(
t => t.Namespace == "RightpointLabs.Pourcast.Application.Orchestrators.Concrete"),
WithMappings.FromAllInterfaces,
WithName.Default,
WithLifetime.Custom <PerRequestLifetimeManager>,
getInjectionMembers: t => new InjectionMember[]
{
new InterceptionBehavior <PolicyInjectionBehavior>(),
new Interceptor <InterfaceInterceptor>()
});
// repositories
container.RegisterTypes(
AllClasses.FromLoadedAssemblies().Where(
t => t.Namespace == "RightpointLabs.Pourcast.Infrastructure.Persistence.Repositories"),
WithMappings.FromAllInterfaces,
WithName.Default,
WithLifetime.Custom <PerRequestLifetimeManager>,
getInjectionMembers: t => new InjectionMember[]
{
new InterceptionBehavior <PolicyInjectionBehavior>(),
new Interceptor <InterfaceInterceptor>()
});
container.RegisterTypes(
AllClasses.FromLoadedAssemblies().Where(
t => t.Namespace == "RightpointLabs.Pourcast.Infrastructure.Persistence.Collections"),
WithMappings.FromAllInterfaces,
WithName.Default,
WithLifetime.Custom <ContainerControlledLifetimeManager>);
// domain services
container.RegisterType <IEmailService, SmtpEmailService>(new PerRequestLifetimeManager());
container.RegisterType <IDateTimeProvider, CurrentDateTimeProvider>(new ContainerControlledLifetimeManager());
// event handlers (must be named!)
container.RegisterType(typeof(IEventHandler <>), typeof(EventStoreHandler <>), "EventStore", new PerRequestLifetimeManager());
container.RegisterType <IEventHandler <PourStopped>, KegNearingEmptyNotificationHandler>("KegNearingEmptyNotification", new PerRequestLifetimeManager());
container.RegisterType <IEventHandler <KegEmptied>, KegEmptiedNotificationHandler>("KegEmptiedNotification", new PerRequestLifetimeManager());
// signalr event handlers (must be named!)
container.RegisterType <IEventHandler <PourStarted>, PourStartedClientHandler>("BeerPourStartedClientHandler", new PerRequestLifetimeManager());
container.RegisterType <IEventHandler <PourStopped>, PourStoppedClientHandler>("BeerPourStoppedClientHandler", new PerRequestLifetimeManager());
container.RegisterType <IEventHandler <KegRemovedFromTap>, KegRemovedFromTapClientHandler>("KegRemovedFromTapClientHandler", new PerRequestLifetimeManager());
container.RegisterType <IEventHandler <KegTapped>, KegTappedClientHandler>("KegTappedClientHandler", new PerRequestLifetimeManager());
// misc
container.RegisterType <SmtpClient>(new PerRequestLifetimeManager(), new InjectionConstructor());
container.RegisterType <IConnectionManager>(new ContainerControlledLifetimeManager(), new InjectionFactory(c => GlobalHost.ConnectionManager));
var locator = new App_Start.UnityServiceLocator(container);
ServiceLocator.SetLocatorProvider(() => locator);
}
/// <summary>
/// Creates unity container extensions.
/// </summary>
/// <param name="createContainer">
/// The create container.
/// </param>
private static void CreateUnityContainerExtensions(IUnityContainer createContainer)
{
createContainer.AddNewExtension <EnterpriseLibraryCoreExtension>();
}
public static void Install(IUnityContainer container)
{
container.RegisterType <IEmployeeRequestQuery <Request>, EmployeeRequestQuery <Request> >();
container.RegisterType <IEmployeeRequestQuery <RequestArch>, EmployeeRequestQuery <RequestArch> >();
container.RegisterType <IQuery <AllowableObjectISQueryParam, IEnumerable <RequestObjectISDTO> >, AllowableObjectISQuery>();
container.RegisterType <IQuery <AllowableObjectTypeQueryParam, IEnumerable <SimpleDTO> >, AllowableObjectTypeQuery>();
container.RegisterType <IQuery <ArchiveYearQueryParam, IEnumerable <Year> >, ArchiveYearQuery>();
container.RegisterType <IQuery <DescriptionProblemQueryParam, IEnumerable <SimpleDTO> >, DescriptionProblemQuery>();
container.RegisterType <IQuery <EmployeeArchiveYearQueryParam, IEnumerable <Year> >, EmployeeArchiveYearQuery>();
container.RegisterType <IQuery <EmployeeObjectQueryParam, IEnumerable <EmployeeObjectDTO> >, EmployeeObjectQuery>();
container.RegisterType <IQuery <RequestLastEventQueryParam, IEnumerable <RequestEventDTO> >, RequestLastEventQuery>();
container.RegisterType <IQuery <RequestStateCountQueryParam, IEnumerable <RequestStateCountDTO> >, RequestStateCountQuery>();
container.RegisterType <IRequestQuery <Request>, RequestQuery <Request> >();
container.RegisterType <IRequestQuery <RequestArch>, RequestQuery <RequestArch> >();
Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
container.AddNewExtension <Interception>();
Assembly dataService = assemblies.
SingleOrDefault(assembly => assembly.GetName().Name == "HelpDesk.DataService");
foreach (Type t in AllClasses.FromAssemblies(dataService)
.Where(t => t.Name.EndsWith("Service") && t.Name != "BaseService"))
{
Type interfaceType = dataService.GetType("HelpDesk.DataService.Interface.I" + t.Name);
IList <MethodInfo> mInfo = t.GetType().GetMethods().ToList();
Attribute transactional = Attribute.GetCustomAttribute(t, typeof(TransactionAttribute));
Attribute cached = Attribute.GetCustomAttribute(t, typeof(CacheAttribute));
if (transactional != null && cached != null)
{
container.RegisterType(interfaceType, t,
new Interceptor <InterfaceInterceptor>(),
new InterceptionBehavior <TransactionBehavior>(),
new InterceptionBehavior <CacheBehavior>()
);
}
else if (transactional != null)
{
container.RegisterType(interfaceType, t,
new Interceptor <InterfaceInterceptor>(),
new InterceptionBehavior <TransactionBehavior>()
);
}
else if (cached != null)
{
container.RegisterType(interfaceType, t,
new Interceptor <InterfaceInterceptor>(),
new InterceptionBehavior <CacheBehavior>()
);
}
else
{
container.RegisterType(interfaceType, t);
}
}
}
private static IUnityContainer RegisterTypes(IUnityContainer unityContainer, LoaderProperties loaderProps, Properties props)
{
if (props == null)
{
throw new ArgumentNullException(nameof(props));
}
unityContainer.RegisterType <DynamicResourceDictionaryContainer>();
unityContainer.RegisterType <ProcessRemoteValidationIf>();
unityContainer.AddNewExtension <LoaderConfigurationExtension>();
unityContainer.AddNewExtension <QPAutopublishContainerConfiguration>();
unityContainer.AddNewExtension <FormattersContainerConfiguration>();
unityContainer.AddNewExtension <APIContainerConfiguration>();
unityContainer.AddNewExtension <QPAPIContainerConfiguration>();
unityContainer.RegisterType <IConnectionProvider, CoreConnectionProvider>();
unityContainer.RegisterType <ICustomerProvider, CustomerProvider>();
unityContainer.RegisterType <IIdentityProvider, CoreIdentityProvider>();
if (props.UseAuthorization)
{
unityContainer.RegisterType <IUserProvider, IdentityUserProvider>();
}
else
{
unityContainer.RegisterType <IUserProvider, ConfigurableUserProvider>();
}
unityContainer.RegisterType <ISettingsService, SettingsFromContentCoreService>();
unityContainer.RegisterType <IRegionTagReplaceService, RegionTagService>();
unityContainer.RegisterType <IRegionService, RegionService>();
unityContainer.RegisterType <IXmlProductService, XmlProductService>();
unityContainer.RegisterType <IContentDefinitionService, ContentDefinitionService>();
unityContainer.RegisterType <INotesService, NotesFromContentService>();
unityContainer.RegisterType <IDocumentGenerator, DocumentGenerator>();
unityContainer.RegisterType <IContentProvider <NotificationChannel>, NotificationChannelProvider>();
unityContainer.RegisterType <StructureCacheTracker>();
unityContainer.RegisterType <IWarmUpProvider, ProductLoaderWarmUpProvider>();
unityContainer.RegisterSingleton <WarmUpRepeater>();
switch (loaderProps.SettingsSource)
{
case SettingsSource.Content:
unityContainer.RegisterType <ISettingsService, SettingsFromContentCoreService>();
break;
case SettingsSource.AppSettings:
unityContainer.RegisterType <ISettingsService, SettingsFromQpCoreService>();
break;
}
switch (loaderProps.DefaultSerializer)
{
case DefaultSerializer.Json:
unityContainer.RegisterType <IArticleFormatter, JsonProductFormatter>();
break;
case DefaultSerializer.Xml:
unityContainer.RegisterType <IArticleFormatter, XmlProductFormatter>();
break;
}
var connection = unityContainer.Resolve <IConnectionProvider>();
if (connection.QPMode)
{
unityContainer
.RegisterConsolidationCache(props.AutoRegisterConsolidationCache)
.As <IFactory>()
.With <FactoryWatcher>(props.WatcherInterval)
.Watch();
}
else
{
unityContainer.RegisterType <ICustomerProvider, SingleCustomerCoreProvider>();
unityContainer
.RegisterConsolidationCache(props.AutoRegisterConsolidationCache, SingleCustomerCoreProvider.Key)
.As <IFactory>()
.With <FactoryWatcher>()
.WithCallback((sender, e) => { unityContainer.Resolve <WarmUpRepeater>().Start(); })
.Watch();
}
if (connection.QPMode || connection.UseQPMonitoring)
{
unityContainer.RegisterQpMonitoring();
}
else
{
unityContainer.RegisterNonQpMonitoring();
}
return(unityContainer);
}
/// <summary>
/// Registers the type mappings with the Unity container.
/// </summary>
/// <param name="container">The unity container to configure.</param>
/// <remarks>
/// There is no need to register concrete types such as controllers or
/// API controllers (unless you want to change the defaults), as Unity
/// allows resolving a concrete type even if it was not previously
/// registered.
/// </remarks>
public static void RegisterTypes(IUnityContainer container)
{
// NOTE: To load from web.config uncomment the line below.
// Make sure to add a Unity.Configuration to the using statements.
// container.LoadConfiguration();
/*
* 安裝NuGet套件:
* 1.Unity
* 2.Unity.AspNet.WebApi
* 3.Unity.Interception
* 4.Unity.RegistrationByConvention
* 5.NanoProfiler.Web
* 6.NanoProfiler.Data
*/
// TODO: Register your type's mappings here.
container.RegisterType <IConnectionStringHelper, ConnectionStringHelper>();
container.RegisterType <IConnectionHelper, ConnectionHelper>();
//container.RegisterType<ICustomerService, CustomerService>();
//container.RegisterType<ICustomerRepository, CustomerRepository>();
#region 做法1: NanoProfilerAttribute + NanoProfilerCallHandler (結合Attribute與ICallHandler)
/*
* 作用: 針對任一方法可以掛上Attribute，攔截該方法，在執行方法前或之後想要執行某段程式。
* 步驟:
* 1.建立 NanoProfilerCallHandler
* 2.建立 NanoProfilerAttribute
* 3.在想要執行 ICallHandler的Invoke 的地方，掛上[NanoProfiler]
* 4.設定UnityConfig.cs的RegisterTypes 設定攔截器，針對有掛上[NanoProfiler]的方法，其類別來做註冊
*/
/*
* //註冊單一類別 ICustomerService
* container.AddNewExtension<Interception>(); //要先註冊
* container.RegisterType<ICustomerService, CustomerService>()
* .Configure<Interception>()
* .SetInterceptorFor<ICustomerService>(new InterfaceInterceptor());
*
* //註冊單一類別 ICustomerRepository
* //container.AddNewExtension<Interception>(); //寫一次就好
* container.RegisterType<ICustomerRepository, CustomerRepository>()
* .Configure<Interception>()
* .SetInterceptorFor<ICustomerRepository>(new InterfaceInterceptor());
*/
/*
* //註冊多個類別
* //要安裝 Unity.RegistrationByConvention，才有擴充方法RegisterTypes
* //針對所有組件名稱結尾是Service或Repository的類別都要註冊
* container.AddNewExtension<Interception>(); //要先註冊
* container.RegisterTypes
* (
* AllClasses.FromLoadedAssemblies()
* .Where(x => x.Name.EndsWith("Service") || x.Name.EndsWith("Repository")),
* WithMappings.FromMatchingInterface
* )
* .Configure<Interception>()
* .SetInterceptorFor<ICustomerService>(new InterfaceInterceptor())
* .SetInterceptorFor<ICustomerRepository>(new InterfaceInterceptor());
*/
#endregion 做法1: NanoProfilerAttribute + NanoProfilerCallHandler (結合Attribute與ICallHandler)
#region 做法2: NanoProfilerInterceptionBehavior (IInterceptionBehavior)
/*
* 作用: 針對任一類別，攔截其所有方法，在執行方法前或之後想要執行某段程式。
* 步驟:
* 1.建立 NanoProfilerInterceptionBehavior
* 2.設定UnityConfig.cs的RegisterTypes 設定攔截器，要執行的類別做註冊
*/
/*
* //註冊單一類別 ICustomerService
* container.AddNewExtension<Interception>(); //要先註冊
* container.RegisterType<ICustomerService, CustomerService>(
* new Interceptor<InterfaceInterceptor>(),
* new InterceptionBehavior<NanoProfilerInterceptionBehavior>()
* );
*
* //註冊單一類別 ICustomerRepository
* //container.AddNewExtension<Interception>(); //寫一次就好
* container.RegisterType<ICustomerRepository, CustomerRepository>(
* new Interceptor<InterfaceInterceptor>(),
* new InterceptionBehavior<NanoProfilerInterceptionBehavior>()
* );
*/
//註冊多個類別
//要安裝 Unity.RegistrationByConvention，才有擴充方法RegisterTypes
//針對所有組件名稱結尾是Service或Repository的類別都要註冊
container.AddNewExtension <Interception>(); //要先註冊
container.RegisterTypes(
AllClasses.FromLoadedAssemblies()
.Where(x => x.Name.EndsWith("Service") || x.Name.EndsWith("Repository")),
WithMappings.FromMatchingInterface,
WithName.Default,
overwriteExistingMappings: true,
getInjectionMembers: t => new InjectionMember[]
{
new Interceptor <InterfaceInterceptor>(),
new InterceptionBehavior <NanoProfilerInterceptionBehavior>(),
}
);
#endregion 做法2: NanoProfilerInterceptionBehavior (IInterceptionBehavior)
}
/// <summary>
/// Constructor de la clase. Crea el contenedor y agrega la extensión de intercepción para inyectar políticas
/// </summary>
public UnityInjectorContainer()
{
_unityContainer = new UnityContainer();
_unityContainer.AddNewExtension <Interception>();
}
public static void RegisterServices(IUnityContainer container)
{
Container = container;
/* container
* .AddNewExtension<Interception>()
* .AddNewExtension<InterceptOnRegister>()
* .Configure<InterceptOnRegister>()
* .SetDefaultInterceptor<VirtualMethodInterceptor>();*/
container
//Cms
.RegisterType <IBannerService, BannerService>()
.RegisterType <ISimplePageService, SimplePageService>()
//Core
.RegisterType(typeof(IRepository <>), typeof(Repository <>))
.RegisterType(typeof(IRepository2 <>), typeof(Repository2 <>))
.RegisterType <IContextProvider, ContextProvider>()
//Common
.RegisterType <IMailService, MailService>()
.RegisterType <IFileVMService, FileVMService>()
.RegisterType <IFileService, FileService>()
//Catalog
.RegisterType <ISiteObjectService, SiteObjectService>()
.RegisterType <ISiteObjectRelationService, SiteObjectRelationService>()
.RegisterType <IMainPageService, MainPageService>()
.RegisterType <INewsService, NewsService>()
.RegisterType <IEntityCommonService, EntityCommonService>()
//Center
.RegisterType <ICityService, CityService>()
.RegisterType <IUserWorkService, UserWorkService>()
.RegisterType <IComplexService, ComplexService>()
.RegisterType <IEmployeeVMService, EmployeeVMService>()
.RegisterType <IEmployeeService, EmployeeService>()
//Shop
.RegisterType <IDiscountService, DiscountService>()
.RegisterType <IEditExamVMService, EditExamVMService>()
.RegisterType <ISpecialistExportService, SpecialistExportService>()
.RegisterType <IOrderDetailService, OrderDetailService>()
.RegisterType <IEditCourseVMService, EditCourseVMService>()
//Education
.RegisterType <IStudentService, StudentService>()
//Profile
.RegisterType <IMessageSectionService, MessageSectionService>()
//Other
.RegisterType <IOrderDetailService, OrderDetailService>()
.RegisterType <ICartService, CartService>()
.RegisterType <IContractVMService, ContractVMService>()
.RegisterType <IOrderService, OrderService>()
.RegisterType <IDictionariesService, DictionariesService>()
.RegisterType <IRegistrationVMService, RegistrationVMService>()
// .RegisterType<IProductService, ProductService>()
.RegisterType <ICachingService, CachingService>()
.RegisterType <ICourseService, CourseService>()
.RegisterType <ITrackVMService, TrackVMService>()
.RegisterType <IPriceService, PriceService>()
.RegisterType <IGroupService, GroupService>()
.RegisterType <IEditTrackVMService, EditTrackVMService>()
.RegisterType <IUserService, UserService>()
.RegisterType <IAuthService, AuthService>()
.RegisterType <IGroupVMService, GroupVMService>()
.RegisterType <ICertificationcVMService,
CertificationVMService>()
.RegisterType <IVendorVMService,
VendorVMService>()
.RegisterType <IDayShiftService, DayShiftService>()
.RegisterType <ITrackService, TrackService>()
.RegisterType <IExamService, ExamService>()
.RegisterType <ISectionService, SectionService>()
.RegisterType <ICustomSectionService, CustomSectionService>()
.RegisterType <ICustomSectionTypeService, CustomSectionTypeService>()
.RegisterType <IUserSettingsService, UserSettingsService>()
.RegisterType <ICertificationService, CertificationService>()
.RegisterType <IVendorService, VendorService>()
.RegisterType <ICourseListVMService, CourseListVMService>()
.RegisterType <IResponseService, ResponseService>();
container
.AddNewExtension <Interception>()
.Configure <Interception>()
.SetDefaultInterceptorFor <MainPageService>(new VirtualMethodInterceptor())
.SetDefaultInterceptorFor <MailTemplateService>(
new VirtualMethodInterceptor())
.SetDefaultInterceptorFor <GroupService>(new VirtualMethodInterceptor())
.SetDefaultInterceptorFor <PriceService>(new VirtualMethodInterceptor())
.SetDefaultInterceptorFor <CityService>(new VirtualMethodInterceptor())
.SetDefaultInterceptorFor <CourseService>(new VirtualMethodInterceptor())
.SetDefaultInterceptorFor <TrackService>(new VirtualMethodInterceptor())
.SetDefaultInterceptorFor <SectionService>(new VirtualMethodInterceptor())
.SetDefaultInterceptorFor <ExtrasService>(new VirtualMethodInterceptor())
.SetDefaultInterceptorFor <MessageSectionService>(
new VirtualMethodInterceptor());
}
private static void AddTheAutoMockingContainerExtensionToTheContainer(IUnityContainer container)
{
container.AddNewExtension <AutoMockingContainerExtension>();
return;
}
static ContainerManager()
{
_container = new UnityContainer();
_container.AddNewExtension <QuartzUnityExtension>();
}
/// <summary>
/// Registers dependencies in the supplied container.
/// </summary>
/// <param name="container">Instance of the container to populate.</param>
private static void RegisterDependencies(IUnityContainer container)
{
container.AddNewExtension <CoreDependencyExtension>();
}
public static void start(string _ConfigFile)
{
IUnityContainer container = UnityHelper.GetUnityContainer();
container.RegisterType <MyCodeSqlSugarClient>(new PerThreadLifetimeManager());
//注册缓存对象
container.RegisterType <IMyCodeCacheService, RedisCache>(new InjectionConstructor(SystemConfig.RedisAddress, SystemConfig.CachePrefix));
container.AddNewExtension <QuartzUnityExtension>();
ConfigFile = _ConfigFile;
List <jobinfo> list = new List <jobinfo>();
try
{
if (sched != null)
{
stop();
sched = null;
}
//sched = new StdSchedulerFactory().GetScheduler();
sched = container.Resolve <IScheduler>();
XmlDocument document = new XmlDocument();
document.Load(ConfigFile);
XmlNode node = document.SelectSingleNode("Jobs");
if (node.ChildNodes.Count > 0)
{
foreach (XmlNode node2 in node.ChildNodes)
{
jobinfo item = new jobinfo
{
name = node2.Attributes["name"].Value,
type = node2.Attributes["type"].Value,
CronExpression = node2.Attributes["CronExpression"].Value,
enabled = bool.Parse(node2.Attributes["enabled"].Value)
};
if (item.enabled)
{
list.Add(item);
IJobDetail jobDetail = JobBuilder.Create(Type.GetType(item.type)).WithIdentity(item.name, item.name + "Group").Build();
ITrigger trigger = TriggerBuilder.Create().WithIdentity(item.name, item.name + "Group").WithCronSchedule(item.CronExpression).Build();
sched.ScheduleJob(jobDetail, trigger);
}
}
if (list.Count > 0)
{
sched.Start();
}
else
{
Console.WriteLine("暂未有计划任务开启1");
}
}
else
{
Console.WriteLine("暂未有计划任务开启");
}
}
catch (Exception exception)
{
Console.WriteLine(JsonConvert.SerializeObject(list));
Console.WriteLine(exception);
LogHelper.Error("出错", exception);
}
Console.ReadKey();
}
static SearcherAOPFactory()
{
container = new UnityContainer();
container.RegisterType <ISearcherAOP, SearcherAOP>();//声明UnityContainer并注册IUserProcessor
container.AddNewExtension <Interception>().Configure <Interception>().SetInterceptorFor <ISearcherAOP>(new InterfaceInterceptor());
}
public IUnityContainer Configure(IUnityContainer container)
{
var childBootstrappers = new IContainerBootstrapper[]
{
new ContainerBootstrapper(),
new DataAccess.Service.ContainerBootstrapper(),
new Manager.ContainerBootstrapper(),
new NotifyConsumer.ContainerBootstrapper()
};
Array.ForEach(childBootstrappers, _ => _.Configure(container));
container.AddNewExtension <Interception>();
GlobalHost.DependencyResolver = new SignalRDependencyResolver(container);
container.RegisterType <IOperationContextHelper, WcfOperationContextHelper>();
container.RegisterType <ILogger>(new InjectionFactory(
_ => new Logger(new NLoggerAdapter((new NLogLogExFactory()).GetLogger("logger")))));
container.RegisterType <IMapperFactory, MapperFactory>();
container
.RegisterType
<IGameDataRetrieveDataAccessService,
GameDataRetrieveDataAccessClient <NetNamedPipeProxy <IGameDataRetrieveDataAccessService> > >(
"GameDataRetrieveDataAccessClient",
new InjectionConstructor(
"net.tcp://localhost/EntityFX.Gdcame.DataAccess/EntityFX.Gdcame.DataAccess.Contract.GameData.IGameDataRetrieveDataAccessService"
)
,
new InterceptionBehavior <PolicyInjectionBehavior>()
, new Interceptor <InterfaceInterceptor>()
);
container
.RegisterType <IUserDataAccessService, UserDataAccessClient <NetNamedPipeProxy <IUserDataAccessService> > >(
"UserDataAccessClient",
new InjectionConstructor(
"net.tcp://localhost/EntityFX.Gdcame.DataAccess/EntityFX.Gdcame.DataAccess.Contract.User.IUserDataAccessService"
)
,
new InterceptionBehavior <PolicyInjectionBehavior>()
, new Interceptor <InterfaceInterceptor>()
);
container
.RegisterType
<IGameDataStoreDataAccessService,
GameDataStoreDataAccessClient <NetNamedPipeProxy <IGameDataStoreDataAccessService> > >(
"GameDataStoreDataAccessClient",
new InjectionConstructor(
"net.tcp://localhost/private/EntityFX.Gdcame.DataAccess.Contract.GameData.IGameDataStoreDataAccessService"
),
new InterceptionBehavior <PolicyInjectionBehavior>()
, new Interceptor <InterfaceInterceptor>()
);
container.RegisterType <IGameFactory, GameFactory>();
container.RegisterInstance(new GameSessions(container.Resolve <ILogger>(), container.Resolve <IGameFactory>()));
container
.RegisterType
<INotifyConsumerService, NotifyConsumerServiceClient <NetNamedPipeProxy <INotifyConsumerService> > >(
"NotifyConsumerServiceClient",
new InjectionConstructor(
"net.tcp://localhost/private/EntityFX.Gdcame.NotifyConsumer.Contract.INotifyConsumerService"
)
, new InterceptionBehavior <PolicyInjectionBehavior>()
, new Interceptor <InterfaceInterceptor>()
);
container.RegisterType <INotifyConsumerService, NotifyConsumerService>(new InjectionConstructor(
new ResolvedParameter <ILogger>(),
new ResolvedParameter <IMapper <GameData, GameDataModel> >(),
new ResolvedParameter <IHubContextAccessor>(),
new ResolvedParameter <IConnections>()
)
, new Interceptor <InterfaceInterceptor>()
, new InterceptionBehavior <LoggerInterceptor>()
);
container.RegisterType <INotifyGameDataChanged, NotifyGameDataChanged>(
new InjectionConstructor(
new ResolvedParameter <int>(),
new ResolvedParameter <string>(),
new ResolvedParameter <IGameDataStoreDataAccessService>(),
new ResolvedParameter <IMapperFactory>(),
new ResolvedParameter <INotifyConsumerClientFactory>()
)
);
container.RegisterType <INotifyConsumerClientFactory, NotifyConsumerClientFactory>(new InjectionConstructor(
new ResolvedParameter <IUnityContainer>(),
"NotifyConsumerServiceClient"));
if (ConfigurationManager.AppSettings["UseLoggerInterceptor"] == "True")
{
container.Configure <Interception>()
.AddPolicy("logging")
.AddCallHandler <LoggerCallHandler>(new ContainerControlledLifetimeManager())
.AddMatchingRule <NamespaceMatchingRule>(new InjectionConstructor("EntityFX.Gdcame.*", true));
}
if (!Environment.UserInteractive)
{
container.RegisterType <IServiceInfoHelper, ServiceInfoHelperLogger>();
}
else
{
container.RegisterType <IServiceInfoHelper, ServiceInfoHelperConsole>();
}
return(container);
}
public static void Configure(IUnityContainer container)
{
#region registering simple types
container.RegisterType <IDeployService, DeployService>(new HierarchicalLifetimeManager());
container.RegisterType <IServiceLogger, ServiceLogger>(new HierarchicalLifetimeManager());
container.RegisterType <IPackageManager, PackageManager>(new HierarchicalLifetimeManager());
container.RegisterType <IValidator, DirectoryValidator>("dir")
.RegisterType <IValidator, IISValidator>("iis")
.RegisterType <IValidator, DatabaseValidator>("db");
container.RegisterType <IDeployer, DirectoryDeployer>("dir")
.RegisterType <IDeployer, IISDeployer>("iis")
.RegisterType <IDeployer, DatabaseDeployer>("db");
#endregion
#region registering factories
container.RegisterType <IConfFactory, ConfFactory>(new HierarchicalLifetimeManager());
container.RegisterType <Func <IPackageManager> >(new InjectionFactory(c => new Func <IPackageManager>(() => c.Resolve <IPackageManager>())));
container.RegisterType <Func <IISInfo, string, IIISManager> >(new InjectionFactory(c => new Func <IISInfo, string, IIISManager>(
(v, s) => {
switch (v.Version)
{
case "6": return(new IIS6Manager(v, s));
case "7": return(new IIS7Manager(v, s));
default: throw new ArgumentException("Unknown version of IIS has been specified", "v");
}
}
)));
container.RegisterType <IDeployServiceFactory, DeployServiceFactory>(new HierarchicalLifetimeManager());
container.RegisterType <Func <string, DeployContext, IConfFactory, IConf> >(new InjectionFactory(
c => new Func <string, DeployContext, IConfFactory, IConf>((sk, dc, cf) => new Conf(sk, dc, cf))));
container.RegisterType <Func <IDeployEvents> >(new InjectionFactory(
c => new Func <IDeployEvents>(() => OperationContext.Current.GetCallbackChannel <IDeployEvents>())));
container.RegisterType <Func <IConf, IEnumerable <IValidator> > >(
new InjectionFactory(c => new Func <IConf, IEnumerable <IValidator> >(
ds => {
var ctorParam = new ParameterOverride("conf", ds);
return(ds.Survey.DeployMode == DeployMode.Install ?
new List <IValidator> {
c.Resolve <IValidator>("dir", ctorParam), c.Resolve <IValidator>("iis", ctorParam), c.Resolve <IValidator>("db", ctorParam)
} :
new List <IValidator> {
c.Resolve <IValidator>("dir", ctorParam), c.Resolve <IValidator>("iis", ctorParam)
});
})));
container.RegisterType <Func <IConf, IEnumerable <IDeployer> > >(
new InjectionFactory(c => new Func <IConf, IEnumerable <IDeployer> >(
ds => {
var ctorParam = new ParameterOverride("conf", ds);
return(ds.Survey.DeployMode == DeployMode.Install ?
new List <IDeployer> {
c.Resolve <IDeployer>("dir", ctorParam), c.Resolve <IDeployer>("iis", ctorParam), c.Resolve <IDeployer>("db", ctorParam)
} :
new List <IDeployer> {
c.Resolve <IDeployer>("dir", ctorParam)
});
})));
container.RegisterType <Func <IConf, string, ISession> >(new InjectionFactory(
c => new Func <IConf, string, ISession>((ds, u) => new Session(ds, u))));
container.RegisterType <Func <IDeployEvents, IConf, IServiceLogger, ISession, IDeployExceptionHandler> >(new InjectionFactory(
c => new Func <IDeployEvents, IConf, IServiceLogger, ISession, IDeployExceptionHandler>(
(de, dss, sl, dsn) => new DeployExceptionHandler(de, dss, sl, dsn))));
#endregion
container.AddNewExtension <Interception>();
container.Configure <Interception>()
.SetInterceptorFor <IValidator>("dir", new TransparentProxyInterceptor())
.SetInterceptorFor <IValidator>("iis", new TransparentProxyInterceptor())
.SetInterceptorFor <IValidator>("db", new TransparentProxyInterceptor())
.SetInterceptorFor <IDeployer>("dir", new TransparentProxyInterceptor())
.SetInterceptorFor <IDeployer>("iis", new TransparentProxyInterceptor())
.SetInterceptorFor <IDeployer>("db", new TransparentProxyInterceptor())
.SetInterceptorFor <IPackageManager>(new TransparentProxyInterceptor());
var methodsToTrack = new List <string>();
methodsToTrack.AddRange(GetMethods <IDeployer>());
methodsToTrack.AddRange(GetMethods <IValidator>());
methodsToTrack.AddRange(GetMethods <IPackageManager>());
container.Configure <Interception>()
.AddPolicy("ServiceMethodsInterceptionPolicy")
.AddMatchingRule <MemberNameMatchingRule>(new InjectionConstructor(new InjectionParameter(methodsToTrack.ToArray())))
.AddCallHandler(new LoggerInterceptor(container));
}
public static void Initialize()
{
#region Neo4j
_container.RegisterType <NeoServerConfiguration>(new ContainerControlledLifetimeManager(), new InjectionFactory(o => NeoServerConfiguration.GetConfiguration(new Uri(Settings.Default.Neo4jServerUrl), Settings.Default.Neo4jUserName, Settings.Default.Neo4jPassword)));
_container.RegisterType <IGraphClientFactory, GraphClientFactory>(new ContainerControlledLifetimeManager());
_container.RegisterType <IUnitOfWorkFactory, UnitOfWorkFactory>(new ContainerControlledLifetimeManager());
#endregion
#region NHibernate
_container.RegisterInstance(NHibernateConfiguration.SessionFactory, new ContainerControlledLifetimeManager());
#endregion
#region AOP
#region Call Handlers
_container.RegisterType <ICallHandler, LoggingCallHandler>(typeof(LoggingCallHandler).Name, new ContainerControlledLifetimeManager(), new InjectionProperty(nameof(LoggingCallHandler.Order), 1));
_container.RegisterType <ICallHandler, TransactionCallHandler>(typeof(TransactionCallHandler).Name, new ContainerControlledLifetimeManager(), new InjectionProperty(nameof(TransactionCallHandler.Order), 2));
#endregion
#region Controllers Interception
_container.AddNewExtension <Interception>();
Interception interception = _container.Configure <Interception>();
Assembly.GetExecutingAssembly().GetTypes().Where(o => o.IsSubclassOf(typeof(ApiController))).ToList().ForEach(o => interception.SetInterceptorFor(o, new VirtualMethodInterceptor()));
#endregion
#endregion
#region DAOs
_container.RegisterType <IUserDao>(new ContainerControlledLifetimeManager(), new InjectionFactory(o =>
{
var dao = new UserDao();
dao.SetSessionFactory(NHibernateConfiguration.SessionFactory);
return(dao);
}));
#endregion
#region Validators
_container.RegisterType <CreateHotSpotInputDtoValidator>(new ContainerControlledLifetimeManager());
_container.RegisterType <CreateRefugeeInputDtoValidator>(new ContainerControlledLifetimeManager());
_container.RegisterType <UpdateRefugeeInputDtoValidator>(new ContainerControlledLifetimeManager());
_container.RegisterType <UpdateRefugeeInputDtoValidator>(new ContainerControlledLifetimeManager());
_container.RegisterType <AuthenticationInputDtoValidator>(new ContainerControlledLifetimeManager());
_container.RegisterType <CreateRefugeesFamilyRelationshipInputDtoValidator>(new ContainerControlledLifetimeManager());
#endregion
#region Utilities
_container.RegisterType <ICurrentHttpRequest, CurrentHttpRequest>(new ContainerControlledLifetimeManager());
#endregion
}
public IUnityContainer Configure(IUnityContainer container)
{
var childBootstrappers = new IContainerBootstrapper[]
{
new ContainerBootstrapper(),
new DataAccess.Service.ContainerBootstrapper(),
new Manager.ContainerBootstrapper(),
new NotifyConsumer.ContainerBootstrapper()
};
Array.ForEach(childBootstrappers, _ => _.Configure(container));
container.AddNewExtension <Interception>();
GlobalHost.DependencyResolver = new SignalRDependencyResolver(container);
container.RegisterType <IOperationContextHelper, WcfOperationContextHelper>();
container.RegisterType <ILogger>(new InjectionFactory(
_ => new Logger(new NLoggerAdapter((new NLogLogExFactory()).GetLogger("logger")))));
container.RegisterType <IMapperFactory, MapperFactory>();
container.RegisterType <IGameDataRetrieveDataAccessService, GameDataRetrieveDataAccessDocumentService>(
new InterceptionBehavior <PolicyInjectionBehavior>()
, new Interceptor <InterfaceInterceptor>()
);
container.RegisterType <IUserDataAccessService, UserDataAccessService>(
new InterceptionBehavior <PolicyInjectionBehavior>()
, new Interceptor <InterfaceInterceptor>()
);
container.RegisterType <IGameDataStoreDataAccessService, GameDataStoreDataAccessDocumentService>(
new InterceptionBehavior <PolicyInjectionBehavior>()
, new Interceptor <InterfaceInterceptor>()
);
//Store
container.RegisterType <IMapper <IncrementorBase, StoredIncrementor>, StoreIncrementorContractMapper>();
container.RegisterType <IMapper <CounterBase, StoredCounterBase>, StoreCounterContractMapper>();
container
.RegisterType
<IMapper <GameCash, StoredCash>, StoreFundsCountersContractMapper>();
container.RegisterType <IMapper <Item, StoredItem>, StoreFundsDriverContractMapper>();
container.RegisterType <IMapper <CustomRuleInfo, StoredCustomRuleInfo>, StoreCustomRuleInfoContractMapper>();
container.RegisterType <IMapper <IGame, StoredGameData>, StoreGameDataMapper>("StoreGameDataMapper");
/////
container.RegisterType <IGameFactory, GameFactory>();
container.RegisterInstance(new GameSessions(container.Resolve <ILogger>(), container.Resolve <IGameFactory>()));
container.RegisterType <INotifyConsumerService, NotifyConsumerService>(new InjectionConstructor(
new ResolvedParameter <ILogger>(),
new ResolvedParameter <IMapper <GameData, GameDataModel> >(),
new ResolvedParameter <IHubContextAccessor>(),
new ResolvedParameter <IConnections>()
)
, new InterceptionBehavior <PolicyInjectionBehavior>()
, new Interceptor <InterfaceInterceptor>()
);
container.RegisterType <INotifyGameDataChanged, NotifyGameDataChanged>(
new InjectionConstructor(
new ResolvedParameter <string>(),
new ResolvedParameter <string>(),
new ResolvedParameter <IGameDataStoreDataAccessService>(),
new ResolvedParameter <IMapperFactory>(),
new ResolvedParameter <INotifyConsumerClientFactory>()
)
);
container.RegisterType <INotifyConsumerClientFactory, NotifyConsumerClientFactory>(new InjectionConstructor(
new ResolvedParameter <IUnityContainer>(),
string.Empty));
if (ConfigurationManager.AppSettings["UseLoggerInterceptor"] == "True")
{
container.Configure <Interception>()
.AddPolicy("logging")
.AddCallHandler <LoggerCallHandler>(new ContainerControlledLifetimeManager())
.AddMatchingRule <NamespaceMatchingRule>(new InjectionConstructor("EntityFX.Gdcame.*", true));
}
container.RegisterType <IHashHelper, HashHelper>();
if (!Environment.UserInteractive)
{
container.RegisterType <IServiceInfoHelper, ServiceInfoHelperLogger>();
}
else
{
container.RegisterType <IServiceInfoHelper, ServiceInfoHelperConsole>();
}
return(container);
}
public IUnityContainer Configure(IUnityContainer container)
{
//container.AddNewExtension<Interception>();
// NOTE: To load from web.config uncomment the line below. Make sure to add a Microsoft.Practices.Unity.Configuration to the using statements.
// container.LoadConfiguration();
container.RegisterType <ILogger>(new InjectionFactory(
_ => new Logger(new NLoggerAdapter((new NLogLogExFactory()).GetLogger("logger")))));
var childBootstrappers = new IContainerBootstrapper[]
{
GetRepositoryProvider(_appConfiguration.RepositoryProvider),
new DataAccess.Service.ContainerBootstrapper(),
new Manager.ContainerBootstrapper(),
new NotifyConsumer.ContainerBootstrapper()
};
Array.ForEach(childBootstrappers, _ => _.Configure(container));
container.AddNewExtension <Interception>();
GlobalHost.DependencyResolver = new SignalRDependencyResolver(container);
container.RegisterType <IMapperFactory, MapperFactory>();
container.RegisterType <IGameDataRetrieveDataAccessService, GameDataRetrieveDataAccessDocumentService>(
new InterceptionBehavior <PolicyInjectionBehavior>()
, new Interceptor <InterfaceInterceptor>()
);
container.RegisterType <IUserDataAccessService, UserDataAccessService>(
new InterceptionBehavior <PolicyInjectionBehavior>()
, new Interceptor <InterfaceInterceptor>()
);
container.RegisterType <IGameDataStoreDataAccessService, GameDataStoreDataAccessDocumentService>(
new InterceptionBehavior <PolicyInjectionBehavior>()
, new Interceptor <InterfaceInterceptor>()
);
//Store
container.RegisterType <IMapper <IncrementorBase, StoredIncrementor>, StoreIncrementorContractMapper>();
container.RegisterType <IMapper <GameEngine.Contract.Counters.CounterBase, StoredCounterBase>, StoreCounterContractMapper>();
container
.RegisterType
<IMapper <GameCash, StoredCash>, StoreFundsCountersContractMapper>();
container.RegisterType <IMapper <Item, StoredItem>, StoreFundsDriverContractMapper>();
container.RegisterType <IMapper <CustomRuleInfo, StoredCustomRuleInfo>, StoreCustomRuleInfoContractMapper>();
container.RegisterType <IMapper <IGame, StoredGameData>, StoreGameDataMapper>("StoreGameDataMapper");
/////
container.RegisterType <IGameFactory, GameFactory>();
container.RegisterType <IGameDataPersister, GameDataPersister>(
new InjectionConstructor(
new ResolvedParameter <IGameDataStoreDataAccessService>(),
new ResolvedParameter <IMapperFactory>()
)
);
container.RegisterType <IGameDataPersisterFactory, GameDataPersisterFactory>();
container.RegisterType <IHashHelper, HashHelper>();
container.RegisterInstance <IPerformanceHelper>(new PerformanceHelper());
container.RegisterInstance(new PerformanceInfo());
container.RegisterInstance(new SystemInfo()
{
CpusCount = Environment.ProcessorCount, Os = Environment.OSVersion.ToString(), Runtime = RuntimeHelper.GetRuntimeName(), MemoryTotal = RuntimeHelper.GetTotalMemoryInMb()
});
container.RegisterInstance(
new GameSessions(container.Resolve <ILogger>(),
container.Resolve <IGameFactory>(), container.Resolve <PerformanceInfo>()));
container.RegisterType <INotifyConsumerService, NotifyConsumerService>(new InjectionConstructor(
new ResolvedParameter <ILogger>(),
new ResolvedParameter <IMapper <GameData, GameDataModel> >(),
new ResolvedParameter <IHubContextAccessor>(),
new ResolvedParameter <IConnections>()
)
, new InterceptionBehavior <PolicyInjectionBehavior>()
, new Interceptor <InterfaceInterceptor>()
);
container.RegisterType <IGameDataChangesNotifier, GameDataChangesNotifier>();
container.RegisterType <INotifyConsumerClientFactory, NotifyConsumerClientFactory>(new InjectionConstructor(
new ResolvedParameter <IUnityContainer>(),
string.Empty));
/* if (ConfigurationManager.AppSettings["UseLoggerInterceptor"] == "True")
* {
* container.Configure<Interception>()
* .AddPolicy("logging")
* .AddCallHandler<LoggerCallHandler>(new ContainerControlledLifetimeManager())
* .AddMatchingRule<NamespaceMatchingRule>(new InjectionConstructor("EntityFX.Gdcame.*", true));
* }*/
container.RegisterType <IMapper <Cash, CashModel>, FundsCounterModelMapper>();
container.RegisterType <IMapper <CounterBase, CounterModelBase>, CounterModelMapper>();
container.RegisterType <IMapper <Gdcame.Common.Contract.Items.Item, ItemModel>, FundsDriverModelMapper>();
container.RegisterType <IMapper <GameData, GameDataModel>, GameDataModelMapper>();
container.RegisterType <IMapper <BuyFundDriverResult, BuyItemModel>, FundsDriverBuyInfoMapper>();
container.RegisterType <IMapper <StatisticsInfo, ServerStatisticsInfoModel>, StatisticsInfoMapper>();
container.RegisterType <IMapper <TopRatingStatistics, TopRatingStatisticsModel>, TopRatingStatisticsModelMapper>();
container.RegisterType <IGameClientFactory, NoWcfGameManagerFactory>();
container.RegisterType <ISessionManagerClientFactory, SessionManagerClientFactory>();
container.RegisterType <ApplicationUserManagerFacotory>();
container.RegisterType <IUserStore <GameUser>, GameUserStore>();
container.RegisterType <IGameDataProvider, GameDataProvider>();
container.RegisterType <IGameApiController, GameApiController>();
// container.RegisterType<IRatingController, RatingController>();
container.RegisterType <IRatingController, LocalRatingController>();
container.RegisterType <IServerController, ServerController>();
container.RegisterType <IOperationContextHelper, NoWcfOperationContextHelper>();
container.RegisterType <UserManager <GameUser>, ApplicationUserManager>();
return(container);
}
