public void CanUseContainerToResolveFactoryParameters()
{
bool factoryWasCalled = false;
string connectionString = "Northwind";
IUnityContainer container = new UnityContainer();
container.AddNewExtension<StaticFactoryExtension>()
.Configure<IStaticFactoryConfiguration>()
.RegisterFactory<MockDatabase>(c =>
{
Assert.AreSame(container, c);
factoryWasCalled = true;
string cs = c.Resolve<string>("connectionString");
return MockDatabase.Create(cs);
})
.Container
.RegisterInstance<string>("connectionString", connectionString);
MockDatabase db = container.Resolve<MockDatabase>();
Assert.IsTrue(factoryWasCalled);
Assert.IsNotNull(db);
Assert.AreEqual(connectionString, db.ConnectionString);
}
public void CanSetUpAPolicyWithExternallyConfiguredRulesAndHandlers()
{
IUnityContainer container = new UnityContainer();
container.AddNewExtension<Interception>();
container
.Configure<Interception>()
.AddPolicy("policy1")
.AddMatchingRule("rule1")
.AddCallHandler("handler1")
.AddCallHandler("handler2").Interception.Container
.RegisterType<IMatchingRule, AlwaysMatchingRule>("rule1")
.RegisterType<ICallHandler, GlobalCountCallHandler>(
"handler1",
new InjectionConstructor("handler1"))
.RegisterType<ICallHandler, GlobalCountCallHandler>(
"handler2",
new InjectionConstructor("handler2"),
new InjectionProperty("Order", 10));
GlobalCountCallHandler.Calls.Clear();
container
.Configure<Interception>()
.SetInterceptorFor<Wrappable>("wrappable", new VirtualMethodInterceptor());
Wrappable wrappable1 = container.Resolve<Wrappable>("wrappable");
wrappable1.Method2();
Assert.AreEqual(1, GlobalCountCallHandler.Calls["handler1"]);
Assert.AreEqual(1, GlobalCountCallHandler.Calls["handler2"]);
}
public static IUnityContainer GetContainer(FrontEndUnityContainerAvailable containerSelected)
{
IUnityContainer result = new UnityContainer();
result.RegisterType(typeof(IAuthenticationProxy), typeof(AuthenticationProxy), new InjectionMember[0]);
result.RegisterType(typeof(IMembershipProxy), typeof(MembershipProxy), new InjectionMember[0]);
result.RegisterType(typeof(IRoleManagerProxy), typeof(RoleManagerProxy), new InjectionMember[0]);
result.RegisterType(typeof(IRolesProxy), typeof(RolesProxy), new InjectionMember[0]);
result.RegisterType(typeof(IProfileProxy), typeof(ProfileProxy), new InjectionMember[0]);
result.RegisterType(typeof(ILoggingProxy), typeof(LoggingProxy), new InjectionMember[0]);
result.RegisterType(typeof(ISyndicationProxy), typeof(SyndicationProxy), new InjectionMember[0]);
result.RegisterType(typeof(IUserRequestContextFrontEnd), typeof(UserRequestContextFrontEnd), new InjectionMember[0]);
result.RegisterType(typeof(IUserSessionModel), typeof(UserSessionAtHttpCookies), new InjectionMember[0]);
switch (containerSelected)
{
case FrontEndUnityContainerAvailable.ProxiesToCustomHost:
result.RegisterType(typeof(IClientChannelInitializer<>), typeof(ClientChannelCustomHostInitializer<>), new InjectionMember[0]);
break;
case FrontEndUnityContainerAvailable.ProxiesToAzure:
result.RegisterType(typeof(IClientChannelInitializer<>), typeof(ClientChannelAzureInternalRoleInitializer<>), new InjectionMember[0]);
break;
default:
throw new Exception("IUnityContainer does not exist in the list of available providers");
}
return result;
}
public void StaticMethodsShouldNotBeInjected()
{
IUnityContainer container = new UnityContainer();
GuineaPig pig = container.Resolve<GuineaPig>();
Assert.IsFalse(GuineaPig.StaticMethodWasCalled);
}
public override void Configure(Container container)
{
var unityContainer = new UnityContainer()
.AddNewExtension<BuildTracking>()
.AddNewExtension<LogCreation>();
var userRepository = new InMemoryAuthRepository();
this.Plugins.Add(new AuthFeature(() => new AuthUserSession(),
new IAuthProvider[] { new BasicAuthProvider()}));
this.Plugins.Add(new RegistrationFeature());
unityContainer.RegisterInstance<ICacheClient>(new MemoryCacheClient());
unityContainer.RegisterInstance<IUserAuthRepository>(userRepository);
unityContainer.RegisterInstance<IDbConnectionFactory>(new OrmLiteConnectionFactory("~/Database/SmartDom.db".MapServerPath(),
SqliteOrmLiteDialectProvider.Instance));
unityContainer.RegisterType<IOrmWrapper, OrmWrapper>();
unityContainer.RegisterType<IConfigurationRepository, AppConfigRepository>();
unityContainer.RegisterType<MediaAdapterAbstractFactory<SerialPort>, SerialPortAdapterFactory>(new ContainerControlledLifetimeManager());
unityContainer.RegisterType<ModbusMasterAbstractFactory<SerialPort>, RtuSerialModbusMasterFactory>(new ContainerControlledLifetimeManager());
unityContainer.RegisterType<IGenericRepository<Device>, DeviceDbRepository>(new ContainerControlledLifetimeManager(),
new InjectionMethod("Initialize"));
unityContainer.RegisterType<IDeviceAccessLayer, SerialAccessLayer>(new ContainerControlledLifetimeManager());
unityContainer.RegisterType<IMessageDecoder, MessageDecoder>();
unityContainer.RegisterType<IDeviceManager, DeviceManager>();
var unityAdapter = new UnityContainerAdapter(unityContainer);
container.Adapter = unityAdapter;
AddUser(userRepository);
}
public void CanAddExtensionWithNonDefaultConstructor()
{
IUnityContainer container = new UnityContainer();
container.AddNewExtension<ContainerExtensionWithNonDefaultConstructor>();
var extension = container.Configure(typeof (ContainerExtensionWithNonDefaultConstructor));
Assert.IsNotNull(extension);
}
public void ContainerThrowsWhenConfiguringStaticMethodForInjection()
{
IUnityContainer container = new UnityContainer()
.RegisterType<GuineaPig>(
new InjectionMethod("ShouldntBeCalled"));
Assert.Fail("Should not get here");
}
public void DoesNotRegisterTypeWithNoLifetimeOrInjectionMembers()
{
var container = new UnityContainer();
container.RegisterTypes(new[] { typeof(MockLogger) }, getName: t => "name");
Assert.IsFalse(container.Registrations.Any(r => r.MappedToType == typeof(MockLogger)));
}
public void ContainerControlledLifetimeReturnsSameInstanceFromMultipleThreads()
{
IUnityContainer container = new UnityContainer()
.AddExtension(new SpyExtension(new DelayStrategy(), UnityBuildStage.Lifetime))
.RegisterType<object>(new ContainerControlledLifetimeManager());
object result1 = null;
object result2 = null;
Thread thread1 = new Thread(delegate()
{
result1 = container.Resolve<object>();
});
Thread thread2 = new Thread(delegate()
{
result2 = container.Resolve<object>();
});
thread1.Start();
thread2.Start();
thread2.Join();
thread1.Join();
Assert.IsNotNull(result1);
Assert.AreSame(result1, result2);
}
public void CanConfigureRemotingInterceptionOnInterface()
{
IUnityContainer container = new UnityContainer();
container.AddNewExtension<Interception>();
container.Configure<Interception>().SetInterceptorFor<Interface>(new TransparentProxyInterceptor());
}
public void When_getting_controller_attributes_then_builds_up_instance()
{
using (var container = new UnityContainer())
{
// Arrange
var someInstance = new SomeClass();
container.RegisterInstance<ISomeInterface>(someInstance);
container.RegisterType<TestFilterAttribute>(new InjectionProperty("Some"));
var context = new ControllerContext { Controller = new ControllerWithTypeAttribute() };
var controllerDescriptor = new ReflectedControllerDescriptor(context.Controller.GetType());
var action = context.Controller.GetType().GetMethod("MyActionMethod");
var actionDescriptor = new ReflectedActionDescriptor(action, "MyActionMethod", controllerDescriptor);
var provider = new UnityFilterAttributeFilterProvider(container);
// Act
Filter filter = provider.GetFilters(context, actionDescriptor).Single();
// Assert
TestFilterAttribute attrib = filter.Instance as TestFilterAttribute;
Assert.IsNotNull(attrib);
Assert.AreEqual(FilterScope.Controller, filter.Scope);
Assert.AreEqual(1234, filter.Order);
Assert.AreSame(someInstance, attrib.Some);
}
}
protected virtual void Arrange()
{
Container =
new UnityContainer()
.RegisterType<BaseClass, DerivedClass>("derived",
new Interceptor<TransparentProxyInterceptor>(),
new InterceptionBehavior<PolicyInjectionBehavior>())
.RegisterType<BaseClass, DerivedWithNoOverrideClass>("derived-nooverride",
new Interceptor<TransparentProxyInterceptor>(),
new InterceptionBehavior<PolicyInjectionBehavior>())
.RegisterType<BaseClass>(
new Interceptor<TransparentProxyInterceptor>(),
new InterceptionBehavior<PolicyInjectionBehavior>())
.AddNewExtension<Interception>()
.Configure<Interception>()
.AddPolicy("base")
.AddMatchingRule(new TypeMatchingRule(typeof(BaseClass)))
.AddMatchingRule(new MemberNameMatchingRule("InterceptedMethod"))
.AddCallHandler(new AppendSuffixCallHandler { Suffix = "-basehandler", Order = 1 })
.Interception
.AddPolicy("derived-no-override")
.AddMatchingRule(new TypeMatchingRule(typeof(DerivedWithNoOverrideClass)))
.AddMatchingRule(new MemberNameMatchingRule("InterceptedMethod"))
.AddCallHandler(new AppendSuffixCallHandler { Suffix = "-derivednooverridehandler", Order = 2 })
.Interception
.AddPolicy("derived")
.AddMatchingRule(new TypeMatchingRule(typeof(DerivedClass)))
.AddMatchingRule(new MemberNameMatchingRule("InterceptedMethod"))
.AddCallHandler(new AppendSuffixCallHandler { Suffix = "-derivedhandler", Order = 3 })
.Interception
.Container;
}
public void OptionalDependencyParametersAreInjectedWithNull()
{
IUnityContainer container = new UnityContainer();
var result = container.Resolve<ObjectWithOptionalConstructorParameter>();
Assert.IsNull(result.SomeInterface);
}
public void ContainerCallsExtensionsInitializeMethod()
{
MockContainerExtension extension = new MockContainerExtension();
IUnityContainer container = new UnityContainer();
container.AddExtension(extension);
Assert.IsTrue(extension.InitializeWasCalled);
}
public void CanResolveALazy()
{
var container = new UnityContainer()
.RegisterType<ILogger, MockLogger>();
var lazy = container.Resolve<Lazy<ILogger>>();
Assert.IsNotNull(lazy);
}
public void CanConfigureDefaultRemotingInterceptionOnMBRO()
{
IUnityContainer container = new UnityContainer();
container.AddNewExtension<Interception>();
container.Configure<Interception>()
.SetDefaultInterceptorFor<Wrappable>(new TransparentProxyInterceptor());
}
public void OptionalPropertiesGetNullWhenNotConfigured()
{
IUnityContainer container = new UnityContainer();
var result = container.Resolve<ObjectWithOptionalProperty>();
Assert.IsNull(result.SomeInterface);
}
public void CanConfigureContainerToCallDefaultConstructor()
{
IUnityContainer container = new UnityContainer()
.RegisterType<GuineaPig>(new InjectionConstructor());
GuineaPig pig = container.Resolve<GuineaPig>();
Assert.IsTrue(pig.DefaultConstructorCalled);
}
public void CanResolveAFunc()
{
var container = new UnityContainer()
.RegisterType<ILogger, MockLogger>();
var resolver = container.Resolve<Func<ILogger>>();
Assert.IsNotNull(resolver);
}
public void UnityResolver_Resolves_Registered_DBContect_Test()
{
var container = new UnityContainer();
container.RegisterInstance<IDataContext>(_context);
var resolver = new UnityResolver(container);
var instance = resolver.GetService(typeof(IDataContext));
Assert.IsNotNull(instance);
}
public void ContainerReturnsEmptyArrayIfNoObjectsRegistered()
{
IUnityContainer container = new UnityContainer();
List<object> results = new List<object>(container.ResolveAll<object>());
Assert.IsNotNull(results);
CollectionAssert.AreEqual(new object[0], results);
}
public void UnityResolver_Resolves_Registered_PersistenceService_Test()
{
var container = new UnityContainer();
container.RegisterInstance<IPersistenceService>(new PersistenceService(_context));
var resolver = new UnityResolver(container);
var instance = resolver.GetService(typeof(IPersistenceService));
Assert.IsNotNull(instance);
}
public void UnityResolver_Resolves_Registered_LogService_Test()
{
var container = new UnityContainer();
container.RegisterInstance<ILogService>(new LogService("ConnectionString", new EmailService()));
var resolver = new UnityResolver(container);
var instance = resolver.GetService(typeof(ILogService));
Assert.IsNotNull(instance);
}
public void UnityResolver_Resolves_Registered_Utilities_Test()
{
var container = new UnityContainer();
container.RegisterInstance<IUtilities>(new Utilities(new PersistenceService(_context),new LogService("ConnectionString", new EmailService())));
var resolver = new UnityResolver(container);
var instance = resolver.GetService(typeof(IUtilities));
Assert.IsNotNull(instance);
}
public void CanBuildUpProxiedClass()
{
using (var channelFactory = GetChannelFactory())
{
var client = new UnityContainer().BuildUp<IService>(channelFactory.CreateChannel());
Assert.IsNotNull(client);
}
}
static void Main(string[] args)
{
var container = new UnityContainer();
container.RegisterType<IFoo,Foo>(new ContainerControlledLifetimeManager(), new InjectionConstructor("Scott"));
IFoo myFoo = container.Resolve<IFoo>();
IFoo myFoo2 = container.Resolve<IFoo>();
Console.WriteLine(myFoo.Name);
Console.WriteLine(Object.ReferenceEquals(myFoo, myFoo2));
}
public void CanGetExtensionConfigurationFromContainer()
{
IUnityContainer container = new UnityContainer()
.AddNewExtension<StaticFactoryExtension>();
IStaticFactoryConfiguration config = container.Configure<IStaticFactoryConfiguration>();
Assert.IsNotNull(config);
}
public void CanResolveGenericTypeMappedWithMatchingInterface()
{
var container = new UnityContainer();
container.RegisterTypes(AllClasses.FromAssemblies(typeof(IList<>).GetTypeInfo().Assembly), WithMappings.FromMatchingInterface, WithName.Default, WithLifetime.None);
var list = container.Resolve<IList<int>>();
Assert.IsInstanceOfType(list, typeof(List<int>));
}
public void CanSafelyDisposeContainerTwice()
{
DisposableExtension extension = new DisposableExtension();
IUnityContainer container = new UnityContainer()
.AddExtension(extension);
container.Dispose();
container.Dispose();
}
public void ContainerThrowsWhenConfiguringStaticMethodForInjection()
{
AssertExtensions.AssertException<InvalidOperationException>(() =>
{
IUnityContainer container = new UnityContainer()
.RegisterType<GuineaPig>(
new InjectionMethod("ShouldntBeCalled"));
});
}
private static void SetInterceptorFor(this UnityContainer container, List <Type> types)
{
if (container == null)
{
return;
}
//多次添加拦截器，会进行多次重复拦截
if (!isAlreadyAddInterception)
{
container.AddNewExtension <Interception>();
isAlreadyAddInterception = true;
}
types.ForEach(item =>
{
if (HasLoggerAttribute(item))
{
container.Configure <Interception>().SetInterceptorFor(item, virtualMethodInterceptor);
}
});
}
/// <summary>
/// register controller factory
/// </summary>
private void registerControllerFactory()
{
IUnityContainer container = new UnityContainer();
UnityConfigurationSection section = null;
System.Configuration.Configuration config = null;
ExeConfigurationFileMap map = new ExeConfigurationFileMap();
map.ExeConfigFilename = EyouSoft.Toolkit.Utils.GetMapPath("/Config/IDAL.Configuration.xml");
config = ConfigurationManager.OpenMappedExeConfiguration(map, ConfigurationUserLevel.None);
section = (UnityConfigurationSection)config.GetSection("unity");
section.Containers.Default.Configure(container);
container
.RegisterType <EyouSoft.BackgroundServices.IDAL.IPluginService, EyouSoft.BackgroundServices.DAL.PluginService>()
.RegisterType <EyouSoft.BackgroundServices.IDAL.ISysBackRemindService, EyouSoft.BackgroundServices.DAL.SysBackRemindService>()
.RegisterType <EyouSoft.BackgroundServices.IDAL.ISysBirthdayRemindService, EyouSoft.BackgroundServices.DAL.SysBirthdayRemindService>()
.RegisterType <EyouSoft.BackgroundServices.IDAL.ISysLeaveRemindService, EyouSoft.BackgroundServices.DAL.SysLeaveRemindService>()
.RegisterType <EyouSoft.BackgroundServices.IDAL.ISysTimerServices, EyouSoft.BackgroundServices.DAL.SysTimerServices>();
Application.Add("container", container);
}
protected override void OnCreate(Bundle savedInstanceState)
{
TabLayoutResource = Resource.Layout.Tabbar;
ToolbarResource = Resource.Layout.Toolbar;
base.OnCreate(savedInstanceState);
Xamarin.Essentials.Platform.Init(this, savedInstanceState);
global::Xamarin.Forms.Forms.Init(this, savedInstanceState);
// configure container
IUnityContainer container = new UnityContainer();
UnityForms.RegisterTypes(container);
UnityPlatform.RegisterTypes(container, this);
var app = container.Resolve <App>();
LoadApplication(app);
// TODO check permissions (INTERNET)
}
public void CanDisposeChildWithoutDisposingParent()
{
DisposableObject parentSpy = new DisposableObject();
DisposableObject childSpy = new DisposableObject();
UnityContainer parent = new UnityContainer();
parent.RegisterInstance(parentSpy);
IUnityContainer child = parent.CreateChildContainer()
.RegisterInstance(childSpy);
child.Dispose();
Assert.IsFalse(parentSpy.WasDisposed);
Assert.IsTrue(childSpy.WasDisposed);
childSpy.WasDisposed = false;
parent.Dispose();
Assert.IsTrue(parentSpy.WasDisposed);
Assert.IsFalse(childSpy.WasDisposed);
}
public void CanSetUpAPolicyWithGivenRulesAndHandlersTypesWithGenerics()
{
IUnityContainer container = new UnityContainer();
container.AddNewExtension<Interception>();
container
.Configure<Interception>()
.AddPolicy("foo")
.AddMatchingRule<AlwaysMatchingRule>()
.AddCallHandler<GlobalCountCallHandler>();
GlobalCountCallHandler.Calls.Clear();
container
.Configure<Interception>()
.SetInterceptorFor<Wrappable>("wrappable", new TransparentProxyInterceptor());
Wrappable wrappable1 = container.Resolve<Wrappable>("wrappable");
wrappable1.Method2();
Assert.AreEqual(1, GlobalCountCallHandler.Calls["default"]);
}
public void CanSetUpSeveralEmptyRules()
{
// there is no visible effect for this, but it should still be resolved.
IUnityContainer container = new UnityContainer();
container.AddNewExtension<Interception>();
// empty
container
.Configure<Interception>()
.AddPolicy("foo").Interception
.AddPolicy("bar");
List<InjectionPolicy> policies
= new List<InjectionPolicy>(container.ResolveAll<InjectionPolicy>());
Assert.AreEqual(3, policies.Count);
Assert.IsInstanceOfType(policies[0], typeof(AttributeDrivenPolicy));
Assert.IsInstanceOfType(policies[1], typeof(RuleDrivenPolicy));
Assert.AreEqual("foo", policies[1].Name);
Assert.IsInstanceOfType(policies[2], typeof(RuleDrivenPolicy));
Assert.AreEqual("bar", policies[2].Name);
}
public static void RegisterComponents()
{
var container = new UnityContainer();
// register all your components with the container here
// it is NOT necessary to register your controllers
// e.g. container.RegisterType<ITestService, TestService>();
container.RegisterType(typeof(ApplicationContext));
container.RegisterType <CarDAO, MSSQLCarDAO>();
container.RegisterType <AccountDAO, MSSQLAccountDAO>();
container.RegisterType <OrderDAO, MSSQLOrderDAO>();
container.RegisterType <TripDAO, MSSQLTripDAO>();
container.RegisterType <AccountService, AccountServiceImpl>();
container.RegisterType <CarService, CarServiceImpl>();
container.RegisterType <OrderService, OrderServiceImpl>();
container.RegisterType <TripService, TripServiceImpl>();
container.RegisterType <Services.Filters.Filter, FilterImpl>();
DependencyResolver.SetResolver(new UnityDependencyResolver(container));
}
public void UnityCanResolveMefComponentRegisteredByTypeAndRegistrationNameTest()
{
// Setup
var unityContainer = new UnityContainer();
var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
// Add composition support for unity
unityContainer.AddNewExtension <CompositionIntegration>();
unityContainer.Configure <CompositionIntegration>().Catalogs.Add(assemblyCatalog);
var mefComponent = unityContainer.Resolve <IMefComponent>("component2");
Assert.That(mefComponent, Is.Not.Null);
Assert.That(mefComponent.GetType(), Is.EqualTo(typeof(MefComponent2)));
unityContainer.RegisterType <IUnityComponent, UnityComponent2>();
var unityComponent = unityContainer.Resolve <IUnityComponent>();
Assert.That(unityComponent, Is.Not.Null);
Assert.That(unityComponent.MefComponent.GetType(), Is.EqualTo(typeof(MefComponent2)));
}
protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
var container = new UnityContainer();
container.RegisterInstance <IUnityContainer>(container);
container.RegisterInstance <IWindowService>(new WindowService());
container.RegisterType <ITimerService, TimerService>();
container.RegisterInstance <ITimeService>(new TimeService());
container.RegisterInstance <IMessageBoxService>(new MessageBoxService());
UnityServiceLocator locator = new UnityServiceLocator(container);
ServiceLocator.SetLocatorProvider(() => locator);
var main = new MainWindow();
var vm = new MainWindowViewModel();
vm.ApplicationExit += MainWindowViewModel_ApplicationExit;
main.DataContext = vm;
main.Show();
}
public static void RegisterComponents()
{
var container = new UnityContainer();
// register all your components with the container here
// it is NOT necessary to register your controllers
// e.g. container.RegisterType<ITestService, TestService>();
container.RegisterType <ITwitterClient, TwitterClient>();
container.RegisterType <IFavoritesRepository, FavoritesRepository>();
container.RegisterType <IConfigurationReader, ConfigurationReader>();
//container.RegisterType<IUserStore<ApplicationUser>, UserStore<ApplicationUser>>(new HierarchicalLifetimeManager());
//container.RegisterType<DbContext, ApplicationDbContext>(new HierarchicalLifetimeManager());
container.RegisterType <DbContext, ApplicationDbContext>(new HierarchicalLifetimeManager());
container.RegisterType <UserManager <ApplicationUser> >(new HierarchicalLifetimeManager());
container.RegisterType <IUserStore <ApplicationUser>, UserStore <ApplicationUser> >(new HierarchicalLifetimeManager());
container.RegisterType <AccountController>(new InjectionConstructor());
DependencyResolver.SetResolver(new UnityDependencyResolver(container));
}
public void ConfigurationComposition()
{
var mapping = new ExeConfigurationFileMap()
{
ExeConfigFilename = "unity.config"
};
var configuration = ConfigurationManager.OpenMappedExeConfiguration(mapping, ConfigurationUserLevel.None);
var container = new UnityContainer();
if (!(configuration.GetSection("unity") is UnityConfigurationSection section))
{
Assert.Fail("section named unity is not of type UnityConfigurationSection");
return;
}
container.LoadConfiguration(section);
var dependee = container.Resolve <IDependee>();
Assert.IsNotNull(dependee);
Assert.IsNotNull(dependee.Dependency);
}
public static void Configure()
{
UnityContainer register = IocContainer.Default;
register.RegisterType <IUnitOfWork, UnitOfWork>();
register.RegisterType <IDbContext, ApplyDbContext>(new PerThreadLifetimeManager());
register.RegisterType <IJsPermissionApplyRepository, JsPermissionApplyRepository>();
register.RegisterType <IBlogChangeApplyRepository, BlogChangeApplyRepository>();
register.RegisterType <IJsPermissionApplyService, JsPermissionApplyService>();
register.RegisterType <IBlogChangeApplyService, BlogChangeApplyService>();
register.RegisterType <IEventBus, EventBus>();
register.RegisterType <IEventHandler <MessageSentEvent>, MessageSentEventHandler>();
register.RegisterType <IEventHandler <JsPermissionOpenedEvent>, JsPermissionOpenedEventHandler>();
register.RegisterType <IEventHandler <BlogChangedEvent>, BlogChangedEventHandler>();
register.RegisterType <IApplyAuthenticationService, ApplyAuthenticationService>();
ConfigureMapper();
}
public void UnityResolver_Resolves_Registered_ContactRepository_Through_ContactsController_Test()
{
var config = new HttpConfiguration();
config.Routes.MapHttpRoute("default",
"api/{controller}/{id}", new { id = RouteParameter.Optional });
var container = new UnityContainer();
container.RegisterInstance <ICheapPaymentGateway>(new CheapPaymentGateway.CheapPaymentGateway());
config.DependencyResolver = new UnityResolver(container);
var server = new HttpServer(config);
var client = new HttpClient(server);
client.GetAsync("http://anything/api/contacts").ContinueWith(task =>
{
var response = task.Result;
Assert.IsNotNull(response.Content);
});
}
private static IUnityContainer BuildUnityContainer()
{
var currentContainer = new UnityContainer();
currentContainer.RegisterType <IVisitStorage, VisitStorage>(new
HierarchicalLifetimeManager());
currentContainer.RegisterType <IClientStorage, ClientStorage>(new
HierarchicalLifetimeManager());
currentContainer.RegisterType <IProcedureStorage, ProcedureStorage>(new
HierarchicalLifetimeManager());
currentContainer.RegisterType <IPurchaseStorage, PurchaseStorage>(new
HierarchicalLifetimeManager());
currentContainer.RegisterType <VisitLogic>(new
HierarchicalLifetimeManager());
currentContainer.RegisterType <ReportLogicClient>(new HierarchicalLifetimeManager());
currentContainer.RegisterType <ClientLogic>(new HierarchicalLifetimeManager());
currentContainer.RegisterType <ProcedureLogic>(new
HierarchicalLifetimeManager());
currentContainer.RegisterType <PurchaseLogic>(new
HierarchicalLifetimeManager());
return(currentContainer);
}
/// <summary>
/// 根据containerName获取指定的Container
/// </summary>
/// <param name="containerName"></param>
/// <returns></returns>
public static IUnityContainer GetContainer(string containerName = "Container")
{
if (!_UnityContainerDictionary.ContainsKey(containerName))
{
lock (_SyncHelper)
{
if (!_UnityContainerDictionary.ContainsKey(containerName))
{
//配置 UnityContainer
IUnityContainer container = new UnityContainer();
ExeConfigurationFileMap fileMap = new ExeConfigurationFileMap();
fileMap.ExeConfigFilename = Path.Combine(GetConfigFile());
System.Configuration.Configuration configuration = ConfigurationManager.OpenMappedExeConfiguration(fileMap, ConfigurationUserLevel.None);
UnityConfigurationSection configSection = (UnityConfigurationSection)configuration.GetSection(UnityConfigurationSection.SectionName);
configSection.Configure(container, containerName);
_UnityContainerDictionary.Add(containerName, container);
}
}
}
return(_UnityContainerDictionary[containerName]);
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
var container = new UnityContainer();
container.RegisterType <IDDMSSearchDocument, DDMSSearchDocument>(new HierarchicalLifetimeManager());
container.RegisterType <IDDMSUploadDocument, DDMSUploadDocument>(new HierarchicalLifetimeManager());
container.RegisterType <IDDMSDeleteDocument, DDMSDeleteDocument>(new HierarchicalLifetimeManager());
config.DependencyResolver = new UnityResolver(container);
}
private static IUnityContainer BuildUnityContainer()
{
var container = new UnityContainer();
// register all your components with the container here
// it is NOT necessary to register your controllers
// e.g. container.RegisterType<ITestService, TestService>();
container.RegisterType <IBillContext, BillContext>()
.RegisterType <IBillModelMapper, BillModelMapper>()
.RegisterType <IBillService, BillService>()
.RegisterType <IWebSecurityWrapper, WebSecurityWrapper>()
.RegisterType <IFrequencyMapper, FrequencyMapper>()
.RegisterType <IPaymentScheduleService, PaymentScheduleService>()
.RegisterType <IEventSummaryMapper, EventSummaryMapper>()
.RegisterType <IScheduleFilters>(new InjectionFactory(c => CreateFilters()));
RegisterTypes(container);
return(container);
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
var container = new UnityContainer();
container.RegisterType <IAccountService, AccountService>(new HierarchicalLifetimeManager());
container.RegisterType <IEventService, EventService>(new HierarchicalLifetimeManager());
container.RegisterType <IUserService, UserService>(new HierarchicalLifetimeManager());
container.RegisterType <IConnectionService, ConnectionService>(new HierarchicalLifetimeManager());
container.RegisterType <IMeetingService, MeetingService>(new HierarchicalLifetimeManager());
container.RegisterType <IMeetingRepository, MeetingRepository>(new HierarchicalLifetimeManager());
container.RegisterType <IMeetingRequestService, MeetingRequestService>(new HierarchicalLifetimeManager());
container.RegisterType <IMeetingRequestRepository, MeetingRequestRepository>(new HierarchicalLifetimeManager());
container.RegisterType <IAuthRepository, AuthRepository>(new HierarchicalLifetimeManager());
container.RegisterType <IEventRepository, EventRepository>(new HierarchicalLifetimeManager());
container.RegisterType <IUserRepository, UserRepository>(new HierarchicalLifetimeManager());
container.RegisterType <IConnectionRepository, ConnectionRepository>(new HierarchicalLifetimeManager());
container.RegisterType <IConnectionNotificationRepository, ConnectionNotificationRepository>(new HierarchicalLifetimeManager());
config.DependencyResolver = new UnityResolver(container);
// Web API configuration and services
// Configure Web API to use only bearer token authentication.
config.SuppressDefaultHostAuthentication();
config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType));
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
var jsonFormatter = config.Formatters.OfType <JsonMediaTypeFormatter>().First();
jsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/octet-stream"));
}
public UnityControllerFactory(string containerName = "")
{
if (containers.ContainsKey(containerName))
{
this.UnityContainer = containers[containerName];
return;
}
lock (syncHelper)
{
if (containers.ContainsKey(containerName))
{
this.UnityContainer = containers[containerName];
return;
}
IUnityContainer container = new UnityContainer();
//配置UnityContainer
UnityConfigurationSection configSection = ConfigurationManager.GetSection(UnityConfigurationSection.SectionName) as UnityConfigurationSection;
if (null == configSection && !string.IsNullOrEmpty(containerName))
{
throw new ConfigurationErrorsException("The <unity> configuration section does not exist.");
}
if (null != configSection)
{
if (string.IsNullOrEmpty(containerName))
{
configSection.Configure(container);
}
else
{
configSection.Configure(container, containerName);
}
}
containers.Add(containerName, container);
this.UnityContainer = containers[containerName];
}
}
public static void Run(UnityContainer container)
{
container.RegisterType <OrganizationQueryModule>();
container.RegisterType <EFOrganizationQueryModule>();
container.RegisterType <AddressQueryModule>();
container.RegisterType <EFAddressQueryModule>();
container.RegisterType <OrganizationCommandModule>();
container.RegisterInstance(typeof(ILog), LogProvider.For <OrganizationService>(), new ContainerControlledLifetimeManager());
container.RegisterType <AddOrganizationCommandHandler>();
container.RegisterType <AddEFOrganisationCommandHandler>();
container.RegisterType <ChangeOrganizationCommandHandler>();
container.RegisterType <OrganizationAddedEventHandler>();
container.RegisterType <OrganizationAddedLegacyEventHandler>();
//Factories
//container.RegisterType(typeof(ICommandFactory<AddOrganizationCommand>),typeof(CommandFactory<AddOrganizationCommand, AxaAddOrganizationCommandExtension>));
//container.RegisterType<IDomainFactory, AxaDomainFactory>();
container.RegisterType(typeof(ICommandFactory <>), typeof(CommandFactory <>));
container.RegisterType <IDomainFactory, DomainFactory>();
container.RegisterType(typeof(IDomainTracking <>), typeof(DomainTracking <>));
//Repositories
container.RegisterType <IOrganizationRepository, OrganizationRepository>();
container.RegisterType(typeof(IDapperGenericRepository <>), typeof(DapperGenericRepository <>));
container.RegisterType(typeof(IEFGenericRepository <>), typeof(EFGenericRepository <>));
container.RegisterType <DbContext, OrganisationDbContext>(new ContainerControlledLifetimeManager());
container.RegisterType(typeof(IGenericRepository <>), typeof(EFGenericRepository <>));
//Command Processor
paramore.brighter.commandprocessor.CommandProcessor commandProcessor = CreateCommandProcesor(container);
container.RegisterInstance(typeof(IAmACommandProcessor), commandProcessor);
}
static void Main()
{
var container = new UnityContainer();
container.RegisterType <ILoginForm, LoginForm>();
container.RegisterType <ILoginVmService, LoginVmService>();
container.RegisterType <ILoginService, LoginService>();
container.RegisterType <IEmployeeRepository, EmployeeRepository>();
container.RegisterType <IMenuForm, MenuForm>();
container.RegisterType <IAdminPanel, AdminPanelForm>();
container.RegisterType <IExchangeForm, ExchangeForm>();
container.RegisterType <IExchangeService, ExchangeService>();
container.RegisterType <IExchangeVmService, ExchangeVmService>();
container.RegisterType <ICreateClientForm, CreateClientForm>();
container.RegisterType <IClientTypeRepository, ClientTypeRepository>();
container.RegisterType <IClientRepository, ClientRepository>();
container.RegisterType <IMobiFinanceContext, MobiFinanceContext>();
container.RegisterType <IClientOverviewForm, ClientOverviewForm>();
container.RegisterType <IClientOverviewVmService, ClientOverviewVmService>();
container.RegisterType <IBankServicesVmService, BankServicesVmService>();
container.RegisterType <IBankServicesOverviewForm, BankServicesOverviewForm>();
container.RegisterType <IEmployeeTypeRepository, EmployeeTypeRepository>();
container.RegisterType <IAccountRepository, AccountRepository>();
container.RegisterType <ISavingAccountRepository, SavingAccountRepository>();
container.RegisterType <ILoanRepository, LoanRepository>();
container.RegisterType <ILoanTypeRepository, LoanTypeRepository>();
container.RegisterType <ISavingAccountTypeRepository, SavingAccountTypeRepository>();
container.RegisterType <IAccountTypeRepository, AccountTypeRepository>();
container.RegisterType <IOpeningBankServicesForm, OpeningBankServicesForm>();
container.RegisterType <IOpenAccountBankServiceForm, OpenAccountBankServiceForm>();
container.RegisterType <IOpenSavingAccountBankServiceForm, OpenSavingAccountBankServiceForm>();
container.RegisterType <IOpenLoanBankServiceForm, OpenLoanBankServiceForm>();
container.RegisterType <ILoanAssessment, LoanAssessment>();
container.RegisterType <ILoanRequestsForm, LoanRequestsForm>();
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(container.Resolve <LoginForm>());
}
static void Main(string[] args)
{
UnityContainer unity = new UnityContainer();
unity.RegisterType <IRepositorioAgendamento, Agendamentos>();
unity.RegisterType <IRepositorio <Paciente>, Pacientes>();
unity.RegisterType <IServicoDePagamento, ServicoDePagamentoMaster>();
ServicoDeConsultaDeDadosDePaciente servicoDeConsultaDeDadosDePaciente = unity.Resolve <ServicoDeConsultaDeDadosDePaciente>();
var retorno = servicoDeConsultaDeDadosDePaciente.RetornarResultadosDeExame("284434343434334");
foreach (ResultadoViewModel resultado in retorno)
{
Console.Write(resultado.Descricao);
}
Console.ReadKey();
}
protected void Application_Start()
{
var container = new UnityContainer();
GlobalConfiguration.Configure(WebApiConfig.Register);
GlobalConfiguration.Configuration.DependencyResolver = new UnityDependencyResolver(container);
var cacheConfig = ConfigurationBuilder.BuildConfiguration(settings =>
{
settings
.WithSystemRuntimeCacheHandle("inprocess");
////.WithExpiration(ExpirationMode.Absolute, TimeSpan.FromMinutes(10));
////settings.WithRedisBackPlate("redisConnection");
////settings.WithRedisCacheHandle("redisConnection", true);
});
container.RegisterType(
typeof(ICacheManager <>),
new ContainerControlledLifetimeManager(),
new InjectionFactory(
(c, t, n) => CacheFactory.FromConfiguration(t.GetGenericArguments()[0], cacheConfig)));
}
public static void Init(TestContext context)
{
var container = new UnityContainer();
var config = TestConfigurationInternal.GetConfig();
_dispatcher = new Mock <IGlobalEventDispatcher>().Object;
container.RegisterBaseTypes(config);
// we need to override initial loading of bookmaker details and producers
var bookmakerDetailsProviderMock = new Mock <BookmakerDetailsProvider>("bookmakerDetailsUriFormat",
new TestDataFetcher(),
new Deserializer <bookmaker_details>(),
new BookmakerDetailsMapperFactory());
bookmakerDetailsProviderMock.Setup(x => x.GetData(It.IsAny <string>())).Returns(TestConfigurationInternal.GetBookmakerDetails());
var defaultBookmakerDetailsProvider = bookmakerDetailsProviderMock.Object;
container.RegisterInstance <IDataProvider <BookmakerDetailsDTO> >(defaultBookmakerDetailsProvider, new ContainerControlledLifetimeManager());
container.RegisterInstance <BookmakerDetailsProvider>(defaultBookmakerDetailsProvider, new ContainerControlledLifetimeManager());
var newConfig = new OddsFeedConfigurationInternal(config, defaultBookmakerDetailsProvider);
newConfig.Load();
container.RegisterInstance <IOddsFeedConfiguration>(newConfig, new ContainerControlledLifetimeManager());
container.RegisterInstance <IOddsFeedConfigurationInternal>(newConfig, new ContainerControlledLifetimeManager());
container.RegisterTypes(_dispatcher);
container.RegisterType <IProducerManager, ProducerManager>(
new ContainerControlledLifetimeManager(),
new InjectionConstructor(
new TestProducersProvider(),
config));
container.RegisterAdditionalTypes();
_childContainer1 = ((IUnityContainer)container).CreateChildContainer();
_childContainer2 = ((IUnityContainer)container).CreateChildContainer();
}
public void AssembledCorrectlyLogCallHandler()
{
using (var configSource = new FileConfigurationSource("LogCallHandler.config", false))
{
Logger.SetLogWriter(new LogWriterFactory(configSource.GetSection).Create(), false);
PolicyInjectionSettings settings = new PolicyInjectionSettings();
PolicyData policyData = new PolicyData("policy");
LogCallHandlerData data = new LogCallHandlerData("fooHandler", 66);
data.BeforeMessage = "before";
data.AfterMessage = "after";
data.IncludeCallTime = true;
data.EventId = 100;
data.Categories.Add(new LogCallHandlerCategoryEntry("category1"));
data.Categories.Add(new LogCallHandlerCategoryEntry("category2"));
policyData.MatchingRules.Add(new CustomMatchingRuleData("matchesEverything", typeof(AlwaysMatchingRule)));
policyData.Handlers.Add(data);
settings.Policies.Add(policyData);
IUnityContainer container = new UnityContainer().AddNewExtension <Interception>();
settings.ConfigureContainer(container);
var policy = container.Resolve <RuleDrivenPolicy>("policy");
LogCallHandler handler = (LogCallHandler)
(policy.GetHandlersFor(GetMethodImpl(MethodBase.GetCurrentMethod()), container)).ElementAt(0);
Assert.IsNotNull(handler);
Assert.AreEqual(66, handler.Order);
Assert.AreEqual("before", handler.BeforeMessage);
Assert.AreEqual("after", handler.AfterMessage);
Assert.AreEqual(true, handler.IncludeCallTime);
Assert.AreEqual(100, handler.EventId);
Assert.AreEqual(2, handler.Categories.Count);
CollectionAssert.Contains(handler.Categories, "category1");
CollectionAssert.Contains(handler.Categories, "category2");
}
}
private static void WorkerRoutine(object arg)
{
var token = (CancellationToken)arg;
using (var container = new UnityContainer())
{
UnityConfiguration.ConfigureBindings(container);
var log = container.Resolve <ILog>();
log.Info("========== Initializing service ==========");
while (!token.IsCancellationRequested)
{
try
{
using (var scope = container.CreateChildContainer())
{
var manager = scope.Resolve <IImportManager>();
log.Info("Running importer");
manager.Import();
}
}
catch (Exception ex)
{
log.Error($"Unhandled exception when running importer: {ex}");
}
try
{
Task.WaitAll(Task.Delay(TimeSpan.FromHours(1), token));
}
catch (AggregateException)
{
}
}
}
}
protected virtual void Arrange()
{
Container =
new UnityContainer();
Container.RegisterType <BaseClass, DerivedClass>("derived",
new Interceptor <TransparentProxyInterceptor>(),
new InterceptionBehavior <PolicyInjectionBehavior>());
Container.RegisterType <BaseClass, DerivedWithNoOverrideClass>("derived-nooverride",
new Interceptor <TransparentProxyInterceptor>(),
new InterceptionBehavior <PolicyInjectionBehavior>());
Container.RegisterType <BaseClass>(
new Interceptor <TransparentProxyInterceptor>(),
new InterceptionBehavior <PolicyInjectionBehavior>());
Container.AddNewExtension <Interception>()
.Configure <Interception>()
.AddPolicy("base")
.AddMatchingRule(new TypeMatchingRule(typeof(BaseClass)))
.AddMatchingRule(new MemberNameMatchingRule("InterceptedMethod"))
.AddCallHandler(new AppendSuffixCallHandler {
Suffix = "-basehandler", Order = 1
})
.Interception
.AddPolicy("derived-no-override")
.AddMatchingRule(new TypeMatchingRule(typeof(DerivedWithNoOverrideClass)))
.AddMatchingRule(new MemberNameMatchingRule("InterceptedMethod"))
.AddCallHandler(new AppendSuffixCallHandler {
Suffix = "-derivednooverridehandler", Order = 2
})
.Interception
.AddPolicy("derived")
.AddMatchingRule(new TypeMatchingRule(typeof(DerivedClass)))
.AddMatchingRule(new MemberNameMatchingRule("InterceptedMethod"))
.AddCallHandler(new AppendSuffixCallHandler {
Suffix = "-derivedhandler", Order = 3
});
}
public static void Register(HttpConfiguration config)
{
// Configuración y servicios de API web
var container = new UnityContainer();
container.RegisterType <IHttpInvoker, HttpInvoker>(
new ContainerControlledLifetimeManager());
container.RegisterType <ITwitterApiClient, TwitterApiClient>(
new ContainerControlledLifetimeManager(),
new InjectionFactory(c =>
{
IHttpInvoker httpInvoker = container.Resolve <IHttpInvoker>();
TwitterApiClient instance = new TwitterApiClient(httpInvoker);
instance.SetCredentials("jkuG56zlta1exJJ3kGi2mlXRM"
, "kPHXBkmLqOV9thDnFE4QJpvzND7hkJBp8AYtwcIts9l64LEmt8"
, "430727651-vHPtvToq1UK3RHm3tMrQmQA4BW3PdJlxAopL53We"
, "rEArJ1vb8Uuh24WTeh9tW8DKFPNWfEvEFte3jdfUkXaPC");
return(instance);
}));
RequiresAuthorizationFilter authorizationFilter =
new RequiresAuthorizationFilter(WebSocketController.ClientsConnections);
container.RegisterInstance(typeof(RequiresAuthorizationFilter), authorizationFilter);
config.DependencyResolver = new UnityResolver(container);
config.Filters.Add(authorizationFilter);
// Rutas de API web
config.MapHttpAttributeRoutes();
//config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate:
// "api/{controller}/{id}", defaults: new { id =
// RouteParameter.Optional }
//);
}
protected void Application_Start(object sender, EventArgs e)
{
GlobalConfiguration.Configuration.Formatters.XmlFormatter.UseXmlSerializer = true;
// http://stackoverflow.com/questions/9847564/how-do-i-get-asp-net-web-api-to-return-json-instead-of-xml-using-chrome
GlobalConfiguration.Configuration.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/html"));
// Force controllers assembly to be loaded
var assembly = typeof(bma.client.Controllers.AnalyzeController).Assembly;
GlobalConfiguration.Configuration.Routes.MapHttpRoute(
name: "LongRunningActionsSpecificApi",
routeTemplate: "api/lra/{appId}/{action}",
defaults: new { controller = "longrunningactionsspecific" },
constraints: new { appId = @"[0-9A-Fa-f]{8}[-]?([0-9A-Fa-f]{4}[-]?){3}[0-9A-Fa-f]{12}" }
);
GlobalConfiguration.Configuration.Routes.MapHttpRoute(
name: "LongRunningActionsApi",
routeTemplate: "api/lra/{appId}",
defaults: new { controller = "longrunningactions" },
constraints: new { appId = @"[0-9A-Fa-f]{8}[-]?([0-9A-Fa-f]{4}[-]?){3}[0-9A-Fa-f]{12}" }
);
GlobalConfiguration.Configuration.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}"
);
var container = new UnityContainer();
container.LoadConfiguration();
container.RegisterInstance <System.Web.Http.Hosting.IHostBufferPolicySelector>(new System.Web.Http.WebHost.WebHostBufferPolicySelector());
GlobalConfiguration.Configuration.DependencyResolver = new UnityResolver(container);
var cors = new EnableCorsAttribute("*", "*", "*");
GlobalConfiguration.Configuration.EnableCors(cors);
}
public static void Register(HttpConfiguration config)
{
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
// Uncomment the following line of code to enable query support for actions with an IQueryable or IQueryable<T> return type.
// To avoid processing unexpected or malicious queries, use the validation settings on QueryableAttribute to validate incoming queries.
// For more information, visit http://go.microsoft.com/fwlink/?LinkId=279712.
//config.EnableQuerySupport();
// To disable tracing in your application, please comment out or remove the following line of code
// For more information, refer to: http://www.asp.net/web-api
config.EnableSystemDiagnosticsTracing();
#region IoC
var container = new UnityContainer();
container.RegisterType <IOpmVerificator, OpmVerificator>(new HierarchicalLifetimeManager());
string idmUrl = System.Configuration.ConfigurationManager.AppSettings["IdmUrl"];
IIdentityManagement idm = new IdentityManagement(idmUrl);
container.RegisterInstance(idm);
string eanEicCheckerUrl = System.Configuration.ConfigurationManager.AppSettings["EanEicCheckerUrl"];
IEanEicCheckerHttpClient eanEicCheckerHttpClient = new EanEicCheckerHttpClient(eanEicCheckerUrl);
container.RegisterInstance(eanEicCheckerHttpClient);
IOpmRepository opmInMemoryRepository = new OpmInMemoryRepository();
OpmRepoFiller.Fill(opmInMemoryRepository);
container.RegisterInstance(opmInMemoryRepository);
config.DependencyResolver = new UnityResolver(container);
#endregion IoC
}
