private static void CheckIfRegistered(UnityContainer unityContainer) { log4net.Config.XmlConfigurator.Configure(); var log = log4net.LogManager.GetLogger(typeof(Program)); log.Info("Checking if manager and plugins are registered"); if (!unityContainer.IsRegistered <ITransferManager>(_transferManager)) { log.Error("Given transfer manager isn't registered"); log.Info(GetHelp()); throw new InvalidPluginException("Given Transfer Manager isn't registered."); } if (!unityContainer.IsRegistered <IInputPlugin>(_inputPlugin)) { log.Error("Given Input Plugin isn't registered"); log.Info(GetHelp()); throw new InvalidPluginException("Given Input Plugin isn't registered."); } if (!unityContainer.IsRegistered <IOutputPlugin>(_outputPlugin)) { log.Error("Given Output Plugin isn't registered"); log.Info(GetHelp()); throw new InvalidPluginException("Given Output Plugin isn't registered."); } log.Info("Manager and plugins are registered"); }
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 } ); //Dependency injection with unity container var container = new UnityContainer(); if (!container.IsRegistered <IUserRepository>()) { container.RegisterType <IUserRepository, UserRepository>(); } if (!container.IsRegistered <ICommentRepository>()) { container.RegisterType <ICommentRepository, CommentRepository>(); } if (!container.IsRegistered <ICategoryRepository>()) { container.RegisterType <ICategoryRepository, CategoryRepository>(); } if (!container.IsRegistered <IBookRepository>()) { container.RegisterType <IBookRepository, BookRepository>(); } if (!container.IsRegistered <IMovieRepository>()) { container.RegisterType <IMovieRepository, MovieRepository>(); } if (!container.IsRegistered <IUserService>()) { container.RegisterType <IUserService, UserService>(); } if (!container.IsRegistered <ICommentService>()) { container.RegisterType <ICommentService, CommentService>(); } if (!container.IsRegistered <ICategoryService>()) { container.RegisterType <ICategoryService, CategoryService>(); } if (!container.IsRegistered <IBookService>()) { container.RegisterType <IBookService, BookService>(); } if (!container.IsRegistered <IMovieService>()) { container.RegisterType <IMovieService, MovieService>(); } config.DependencyResolver = new UnityResolver(container); }
public TService GetInstance <TService>() where TService : class { if (_container.IsRegistered <TService>()) { _container.RegisterType <TService>(); } return(_container.Resolve <TService>()); }
public void RegisterType_Valid() { var helper = new UnityHelper(); var container = new UnityContainer(); Assert.IsFalse(container.IsRegistered(typeof(ITestInterface))); helper.RegisterType(container, typeof(ITestInterface), typeof(TestClass1), RegistrationType.Singleton); Assert.IsTrue(container.IsRegistered(typeof(ITestInterface))); }
public void RegisterDependencies() { IUnityContainer container = new UnityContainer(); MockStartupController controller = new MockStartupController(container); controller.CallRegisterDependencies(); Assert.That(container.IsRegistered <IStartupView>(), Is.True); Assert.That(container.IsRegistered <IMainView>(), Is.True); }
public void Run <TPresenter>() where TPresenter : class, IPresenter { if (!_container.IsRegistered <TPresenter>()) { _container.RegisterType(typeof(TPresenter)); } var presenter = _container.Resolve <TPresenter>(); presenter.Run(); }
//REGISTER //Register interface to class public void Register <T, TT>(IoCLifeTimeType ltt) where TT : class, T { var ltm = getLifeTimeManager(ltt); if (!Container.IsRegistered <T>()) { Container.RegisterType <T, TT>(ltm).Configure <Interception>().SetInterceptorFor <T>(new InterfaceInterceptor()); } //else throw new Exception("Already registered."); }
public void RegisterInstance_Valid() { var helper = new UnityHelper(); var instance = new TestClass1() { Name = "test" }; var container = new UnityContainer(); Assert.IsFalse(container.IsRegistered(typeof(ITestInterface))); helper.RegisterInstance(container, typeof(ITestInterface), instance); Assert.IsTrue(container.IsRegistered(typeof(ITestInterface))); Assert.AreEqual(instance, container.Resolve <ITestInterface>()); }
public Object Get(Type type) { if (!_container.IsRegistered(type)) { var interfaces = type.GetInterfaces(); if (interfaces.Length == 1 && _container.IsRegistered(interfaces[0])) { var instance = _container.Resolve(interfaces[0]); _container.RegisterInstance(type, instance); return(instance); } } return(_container.Resolve(type)); }
static MessageService() { if (!MessagingEnabled) { return; } var unitySection = ConfigurationManager.GetSection("unity"); if (unitySection == null) { log.Error("Required unity configuration for Message Sender"); return; } try { var unity = new UnityContainer().LoadConfiguration(unityContainerName); if (unity.IsRegistered <IMessageSender>()) { sender = unity.Resolve <IMessageSender>(); } else { log.Error("Required unity configuration for Message Sender"); } } catch (Exception ex) { log.Error("Error while resolving Message Sender: " + ex); } }
/// <summary> /// Creates and initializes an instance of type T /// </summary> /// <typeparam name="T">Type of service to initialize</typeparam> /// <returns>Instance of the service created</returns> public static T Resolve <T>() { bool isRegistered; lock (UnityContainer) { isRegistered = UnityContainer.IsRegistered <T>(); } if (!isRegistered) { CountdownEvent latch = new CountdownEvent(1); Latches.TryAdd(typeof(T), latch); latch.Wait(); } T ret; lock (UnityContainer) { ret = UnityContainer.Resolve <T>(); } return(ret); }
private static void Initialize() { var container = new UnityContainer(); container.RegisterInstance <IMessageRouter>(new MessageRouter()); HttpServiceLocator.Namespaces = new string[] { "WebApiDemo.PlugIn.Models" }; HttpServiceLocator.DefaultInstance.GetHttpClient = p => new HttpClient() { BaseAddress = new Uri("http://localhost:54619/PersonModule/") }; HttpServiceLocator.DefaultInstance.GetValues = p => container.ResolveAll(p).ToArray(); HttpServiceLocator.DefaultInstance.RegisterValue = (x, y, z) => container.RegisterInstance(x, y, z); HttpServiceLocator.DefaultInstance.TryGetValue = delegate(Type serviceType, string name, out object value) { value = null; if (container.IsRegistered(serviceType, name)) { value = container.Resolve(serviceType, name); return(true); } return(false); }; ServiceLocator.SetLocatorProvider(() => HttpServiceLocator.DefaultInstance); }
public override object GetService(Type serviceType) { if (_container.IsRegistered(serviceType)) { return(_container.Resolve(serviceType)); } return(base.GetService(serviceType)); }
private static void ConfigureCoreContextByUnity(object section) { if (((UnityConfigurationSection)section).Containers["Core"] != null) { var unity = new UnityContainer().LoadConfiguration("Core"); if (unity.IsRegistered <IConfigurationClient>()) { Configuration = unity.Resolve <IConfigurationClient>(); } if (unity.IsRegistered <ITenantManagerClient>()) { TenantManager = unity.Resolve <ITenantManagerClient>(); } if (unity.IsRegistered <IUserManagerClient>()) { UserManager = unity.Resolve <IUserManagerClient>(); } if (unity.IsRegistered <IGroupManagerClient>()) { GroupManager = unity.Resolve <IGroupManagerClient>(); } if (unity.IsRegistered <IAuthManagerClient>()) { Authentication = unity.Resolve <IAuthManagerClient>(); } if (unity.IsRegistered <IAzManagerClient>()) { AuthorizationManager = unity.Resolve <IAzManagerClient>(); } if (unity.IsRegistered <ISubscriptionManagerClient>()) { SubscriptionManager = unity.Resolve <ISubscriptionManagerClient>(); } } }
private object Resolve(Resolution resolution) { var type = resolution.Key as Type; // Unity will create objects even if not registered return(type != null && _container.IsRegistered(type) ? ((IContainer)this).Resolve(resolution.Key) : null); }
private TIUser PrivateGetUser(string userName) { if (!_unityContainer.IsRegistered <TIUser>(userName)) { throw new TestActionsException(string.Format("Пользователь \"{0}\" незарегистрирован.", userName)); } return(_unityContainer.Resolve <TIUser>(userName)); }
static CalculateOtFactory() { IUnityContainer container = new UnityContainer().LoadConfiguration(); if (container.IsRegistered <ICalculate>("CalOtPay")) { CalOtPay = container.Resolve <ICalculate>("CalOtPay"); } }
public void IsRegisteredReturnsCorrectValue() { IUnityContainer container = new UnityContainer(); container.RegisterType <MyClass>(new InjectionConstructor("Name")); var inst = container.Resolve <MyClass>(); Assert.IsTrue(container.IsRegistered <MyClass>()); }
/// <summary> /// Обеспечивает проверку на возможность решения типа. /// </summary> /// <typeparam name="T">Тип для резолвинга.</typeparam> /// <returns>Инициализированный объект типа или null.</returns> private T SaveResolve <T>() where T : class { T result = null; if (_container.IsRegistered <T>()) { result = _container.Resolve <T>(); } //if return(result); }
public void UnityIsRegistered() { UnityContainer c = new UnityContainer(); c.RegisterInstance <IServiceScopeFactory>(new UnityServiceScopeFactory(c)); var sp = new UnityServiceProvider(c); c.RegisterInstance <IServiceProvider>(sp); c.RegisterSingleton <IFoo, Foo>(); c.IsRegistered(typeof(IFoo)).Should().BeTrue(); }
public void MenuConfiguration_ConstructorParameterContainerNotNullReturnsMenuConfiguration() { IUnityContainer fakeUnityContainer = new UnityContainer(); var menuConfiguration = new MenuConfiguration(fakeUnityContainer); menuConfiguration.Configure(); var isRegistered = fakeUnityContainer.IsRegistered <IMenu>(); Assert.True(isRegistered); }
public void DataLoaderConfiguration_ConfigureAddDataLoaderToConfiguration() { var fakeUnityContainer = new UnityContainer(); var dataLoaderConfiguration = new DataLoaderConfiguration(fakeUnityContainer); dataLoaderConfiguration.Configure(); var isRegistered = fakeUnityContainer.IsRegistered <IDataLoader>(); Assert.True(isRegistered); }
public void Can_scan_folder_and_exclude_assemblies_by_using_a_predicate() { var container = new UnityContainer(); container.Configure(x => x.Scan(scan => { scan.AssembliesInDirectory(Environment.CurrentDirectory, a => a.GetName().Name != "UnityConfiguration.Tests"); scan.With <FirstInterfaceConvention>(); })); Assert.That(container.IsRegistered <IFooService>(), Is.False); }
public void Does_not_register_when_interface_is_not_found() { var container = new UnityContainer(); container.Configure(x => x.Scan(scan => { scan.AssemblyContaining <NamedService>(); scan.With <NamingConvention>().WithInterfaceName(t => "IDoNotExist"); })); Assert.That(container.IsRegistered <INamedService>(), Is.False); }
private void RegisterCustomObjectItemType(Type type, string lifeCycle) { Type interfaceType = null; interfaceType = this.GetInterfaceType(type, lifeCycle); if (interfaceType == null) { return; } if (unityContainer.IsRegistered(interfaceType)) { return; } switch (GetObjectLifeCycle(lifeCycle)) { case ObjectLifeCycle.Singleton: unityContainer.RegisterInstance(interfaceType, Activator.CreateInstance(type)); break; case ObjectLifeCycle.New: //判定是否给予该程序集注册了类型,如果没有给予该程序集注册类型,则不进行任何的处理. bool flag = ValidationIsRegisterInterceptor(type); if (!flag) { unityContainer.RegisterType(interfaceType, type); } else { this.RegisterAop(interfaceType, type); } break; } }
public static IUnityContainer GetContainer() { var container = new UnityContainer(); container.RegisterType <IMediator, Mediator>(); var classes = AllClasses.FromAssemblies(typeof(UnityConfiguration).Assembly) .Where(x => x.Name.Contains("Controller") == false && x.FullName.Contains("Data.Model") == false) .ToList(); container.RegisterTypes(classes, WithMappings.FromAllInterfaces, GetName, GetLifetimeManager); container.RegisterInstance <SingleInstanceFactory>(t => container.IsRegistered(t) ? container.Resolve(t) : null); container.RegisterInstance <MultiInstanceFactory>(t => container.ResolveAll(t)); return(container); }
private static IMediator BuildMediator() { var container = new UnityContainer(); container.RegisterType <IMediator, Mediator>(); container.RegisterTypes(AllClasses.FromAssemblies(typeof(Ping).Assembly), WithMappings.FromAllInterfaces, GetName, GetLifetimeManager); container.RegisterType(typeof(INotificationHandler <>), typeof(GenericHandler), GetName(typeof(GenericHandler))); container.RegisterType(typeof(IAsyncNotificationHandler <>), typeof(GenericAsyncHandler), GetName(typeof(GenericAsyncHandler))); container.RegisterInstance(Console.Out); container.RegisterInstance <SingleInstanceFactory>(t => container.IsRegistered(t) ? container.Resolve(t) : null); container.RegisterInstance <MultiInstanceFactory>(t => container.ResolveAll(t)); var mediator = container.Resolve <IMediator>(); return(mediator); }
private static IResponseCachedProvider GetProvider(string name) { if (!string.IsNullOrEmpty(name)) { try { if (Container.IsRegistered <IResponseCachedProvider>(name)) { return(Container.Resolve <IResponseCachedProvider>(name)); } } catch (Exception ex) { // todo: 日志 } } return(null); }
public void TryNavigate(string viewName, object parameter) { if (String.IsNullOrEmpty(viewName)) { return; } if (!UnityContainer.IsRegistered <object>(viewName)) { return; } CurrentRegion = RegionManager.Regions[GlobalRegionNames.MainRegion]; CurrentRegion.NavigationService.RequestNavigate(viewName, new NavigationParameters { { "", parameter } }); }
public void HttpClientCanBeCreatedByUnity() { UnityContainer unityContainer = new UnityContainer(); ServiceCollection serviceCollection = new ServiceCollection(); serviceCollection.AddHttpClient("Google", (c) => { c.BaseAddress = new Uri("https://google.com/"); }); serviceCollection.BuildServiceProvider(unityContainer); Assert.True(unityContainer.IsRegistered <IHttpClientFactory>()); IHttpClientFactory clientFactory = unityContainer.Resolve <IHttpClientFactory>(); HttpClient httpClient = clientFactory.CreateClient("Google"); Assert.NotNull(httpClient); Assert.Equal("https://google.com/", httpClient.BaseAddress.ToString()); }