/// <summary> /// Create a new instance of <see cref="RegisterEventArgs"/>. /// </summary> /// <param name="typeFrom">Type to map from.</param> /// <param name="typeTo">Type to map to.</param> /// <param name="name">Name for the registration.</param> /// <param name="lifetimeManager"><see cref="LifetimeManager"/> to manage instances.</param> public RegisterEventArgs(Type typeFrom, Type typeTo, string name, LifetimeManager lifetimeManager) : base(name) { this.typeFrom = typeFrom; this.typeTo = typeTo; this.lifetimeManager = lifetimeManager; }
/// <summary> /// Create a <see cref="RegisterInstanceEventArgs"/> instance initialized with the given arguments. /// </summary> /// <param name="registeredType">Type of instance being registered.</param> /// <param name="instance">The instance object itself.</param> /// <param name="name">Name to register under, null if default registration.</param> /// <param name="lifetimeManager"><see cref="LifetimeManager"/> object that handles how /// the instance will be owned.</param> public RegisterInstanceEventArgs(Type registeredType, object instance, string name, LifetimeManager lifetimeManager) : base(name) { this.registeredType = registeredType; this.instance = instance; this.lifetimeManager = lifetimeManager; }
public TypeRegistration(Type registrationType, Type mappedToType, LifetimeManager lifetimeManager, Expression factory) { this.RegistrationType = registrationType; this.MappedToType = mappedToType; this.LifetimeManager = lifetimeManager; this.Factory = factory; }
public static void RegisterCollection(this UnityContainer container, Type serviceType, IEnumerable<Type> implementations, LifetimeManager lifetimeManager = null) { foreach (var impl in implementations) { container.RegisterType(serviceType, impl, impl.FullName, lifetimeManager ?? new TransientLifetimeManager(), new InjectionMember[0]); } }
public DelegateLifetimeManager( Func<object> sourceFunc, LifetimeManager baseManager = null) { this._resolveDelegate = sourceFunc; this._baseManager = baseManager; }
public IUnityContainer RegisterInstance(Type t, string name, object instance, LifetimeManager lifetime) { ConfigActions.Add(ConfigurationActionRecord.RegisterInstanceAction( t, name, instance, lifetime)); return this; }
public IUnityContainer RegisterType(Type @from, Type to, string name, LifetimeManager lifetimeManager, params InjectionMember[] injectionMembers) { var bypassLogging = injectionMembers.Any(injectionMember => injectionMember.GetType() == typeof (BypassLoggingInjectionMember)); if (@from == null || bypassLogging) { // we're assuming this is just a component registration in which case our logging injection, by interface, will not work. return _unityContainer.RegisterType(@from, to, name, lifetimeManager, injectionMembers); } return _unityContainer.RegisterType(@from, to, name, lifetimeManager, GetInjectionMembersAndLogging(injectionMembers)); }
/// <summary> /// Register a type as all implemented interface (except those that start with <c>System</c>). /// </summary> /// <param name="container">instance</param> /// <param name="concrete">Class to register</param> /// <param name="lifetime"> /// The lifetime. Typically <c>HierarchicalLifetimeManager</c> (scoped), /// <c>ContainerControlledLifetimeManager</c> (singleton) or <c>TransientLifetimeManager</c> (transient) /// </param> public static void Register(this IUnityContainer container, Type concrete, LifetimeManager lifetime) { // required so that all interface registrations uses the same instance. container.RegisterType(concrete, concrete, lifetime); var interfaces = concrete.GetInterfaces().Where(x => !x.Namespace.StartsWith("System")); foreach (var @interface in interfaces) { container.RegisterType(@interface, concrete, lifetime); } }
private void setInstanceInterceptorFor(Type registeredType, String name, Object instance, LifetimeManager manager) { foreach (IInstanceInterceptor interceptor in interceptors.OfType<IInstanceInterceptor>()) { if ((interceptor.CanIntercept(registeredType) == true) && (interceptor.GetInterceptableMethods(registeredType, instance.GetType()).Count() != 0)) { this.Container.Configure<Interception>().SetInterceptorFor(registeredType, name, interceptor); break; } } }
private void setTypeInterceptorFor(Type typeFrom, Type typeTo, String name, LifetimeManager lifetimeManager) { foreach (ITypeInterceptor interceptor in interceptors.OfType<ITypeInterceptor>()) { if ((interceptor.CanIntercept(typeFrom) == true) && (interceptor.GetInterceptableMethods(typeFrom, typeTo).Count() != 0)) { this.Container.Configure<Interception>().SetInterceptorFor(typeFrom, name, interceptor); break; } } }
public static void RegisterAutoMapperType(this IUnityContainer container, LifetimeManager lifetimeManager = null) { RegisterAutoMapperProfiles(container); var profiles = container.ResolveAll<Profile>(); var autoMapperConfigurationStore = new ConfigurationStore(new TypeMapFactory(), MapperRegistry.Mappers); profiles.Each(autoMapperConfigurationStore.AddProfile); autoMapperConfigurationStore.AssertConfigurationIsValid(); container.RegisterInstance<IConfigurationProvider>(autoMapperConfigurationStore, new ContainerControlledLifetimeManager()); container.RegisterInstance<IConfiguration>(autoMapperConfigurationStore, new ContainerControlledLifetimeManager()); //container.RegisterType<IMappingEngine, MappingEngine>(lifetimeManager ?? new TransientLifetimeManager(), new InjectionConstructor(typeof(IConfigurationProvider))); container.RegisterType<IMappingEngine, MappingEngine>(lifetimeManager ?? new TransientLifetimeManager(), new InjectionConstructor(typeof(IConfigurationProvider)), new InjectionFactory(_ => Mapper.Engine)); }
public static void RegisterAutoMapperType(this IUnityContainer container, LifetimeManager lifetimeManager = null) { //Automate profiles RegisterAutomapperProfiles(container); //Collect all profiles in container and resolve them. var profiles = container.ResolveAll<Profile>(); var autoMapperConfigurationStore = new ConfigurationStore(new TypeMapFactory(), MapperRegistry.Mappers); profiles.Each(autoMapperConfigurationStore.AddProfile); //Automapper Validate autoMapperConfigurationStore.AssertConfigurationIsValid(); //Unity Injection container.RegisterInstance<IConfigurationProvider>(autoMapperConfigurationStore, new ContainerControlledLifetimeManager()); container.RegisterInstance<IConfiguration>(autoMapperConfigurationStore, new ContainerControlledLifetimeManager()); container.RegisterType<IMappingEngine, MappingEngine>(lifetimeManager ?? new TransientLifetimeManager(), new InjectionConstructor(typeof(IConfigurationProvider))); container.RegisterType<IStorage, MemoryStorage>(); container.RegisterType<ICustomerRepository, CustomerRepository>(); }
private void SetLifetimeManager(Type lifetimeType, string name, LifetimeManager lifetimeManager) { if (lifetimeManager.InUse) { throw new InvalidOperationException(Resources.LifetimeManagerInUse); } if (lifetimeType.IsGenericTypeDefinition) { LifetimeManagerFactory factory = new LifetimeManagerFactory(Context, lifetimeManager.GetType()); Context.Policies.Set<ILifetimeFactoryPolicy>(factory, new NamedTypeBuildKey(lifetimeType, name)); } else { lifetimeManager.InUse = true; Context.Policies.Set<ILifetimePolicy>(lifetimeManager, new NamedTypeBuildKey(lifetimeType, name)); if (lifetimeManager is IDisposable) { Context.Lifetime.Add(lifetimeManager); } } }
public void RegisterType(Type from, Type to, LifetimeManager lifetime) { this.RegisterType(from.ToString(), to.ToString(), lifetime == null ? string.Empty : lifetime.GetType().ToString()); }
/// <summary> /// Instantiates a <see cref="Registration"/> /// </summary> /// <param name="type"></param> /// <param name="mapTo"></param> /// <param name="lifetime"></param> /// <param name="name"></param> /// <param name="injectionConstructor"></param> public Registration(Type type, Type mapTo, LifetimeManager lifetime, string name, InjectionConstructor injectionConstructor = null) { _type = type; _mapTo = mapTo; _lifetime = lifetime; _name = name; _injectionConstructor = injectionConstructor; }
public IUnityContainer RegisterType(Type from, Type to, string name, LifetimeManager lifetimeManager, params InjectionMember[] injectionMembers) { return container.RegisterType(from, to, name, lifetimeManager, injectionMembers); }
public IUnityContainer RegisterInstance(Type t, string name, object instance, LifetimeManager lifetime) { return container.RegisterInstance(t, name, instance, lifetime); }
public IUnityContainer RegisterInstance(Type t, string name, object instance, LifetimeManager lifetime) { throw new System.NotImplementedException(); }
public static ConfigurationActionRecord RegisterInstanceAction(Type t, string name, object instance, LifetimeManager lifetimeManager) { return new ConfigurationActionRecord(TestDoubles.ConfigurationMethod.RegisterInstance, t, null, name, instance, lifetimeManager); }
public ConfigurationActionRecord(ConfigurationMethod configurationMethod, Type typeFrom, Type typeTo, string name, object instance, LifetimeManager lifetime) { this.configurationMethod = configurationMethod; this.typeFrom = typeFrom; this.typeTo = typeTo; this.name = string.IsNullOrEmpty(name) ? null : name; this.instance = instance; this.lifetime = lifetime; }
/// <summary> /// RegisterType an instance with the container. /// </summary> /// <remarks> /// <para> /// Instance registration is much like setting a type as a singleton, except that instead /// of the container creating the instance the first time it is requested, the user /// creates the instance ahead of type and adds that instance to the container. /// </para> /// </remarks> /// <param name="t">Type of instance to register (may be an implemented interface instead of the full type).</param> /// <param name="instance">Object to returned.</param> /// <param name="name">Name for registration.</param> /// <param name="lifetime"> /// <para>If true, the container will take over the lifetime of the instance, /// calling Dispose on it (if it's <see cref="IDisposable"/>) when the container is Disposed.</para> /// <para> /// If false, container will not maintain a strong reference to <paramref name="instance"/>. User is reponsible /// for disposing instance, and for keeping the instance from being garbage collected.</para></param> /// <returns>The <see cref="UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> public override IUnityContainer RegisterInstance(Type t, string name, object instance, LifetimeManager lifetime) { Guard.ArgumentNotNull(instance, "instance"); Guard.ArgumentNotNull(lifetime, "lifetime"); Guard.TypeIsAssignable(t, instance.GetType(), "instance"); registeringInstance(this, new RegisterInstanceEventArgs(t, instance, name, lifetime)); return this; }
public IUnityContainer RegisterType(Type from, Type to, string name, LifetimeManager lifetimeManager, InjectionMember[] injectionMembers);
public static ConfigurationActionRecord RegisterAction(Type typeFrom, Type typeTo, string name, LifetimeManager lifetime) { return new ConfigurationActionRecord(TestDoubles.ConfigurationMethod.Register, typeFrom, typeTo, name, null, lifetime); }
/// <summary> /// RegisterType a type mapping with the container, where the created instances will use /// the given <see cref="LifetimeManager"/>. /// </summary> /// <param name="from"><see cref="Type"/> that will be requested.</param> /// <param name="to"><see cref="Type"/> that will actually be returned.</param> /// <param name="name">Name to use for registration, null if a default registration.</param> /// <param name="lifetimeManager">The <see cref="LifetimeManager"/> that controls the lifetime /// of the returned instance.</param> /// <param name="injectionMembers">Injection configuration objects.</param> /// <returns>The <see cref="UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> public IUnityContainer RegisterType(Type from, Type to, string name, LifetimeManager lifetimeManager, InjectionMember[] injectionMembers) { Guard.ArgumentNotNull(to, "to"); if(string.IsNullOrEmpty(name)) { name = null; } if (from != null && !from.IsGenericType && !to.IsGenericType) { Guard.TypeIsAssignable(from, to, "from"); } registering(this, new RegisterEventArgs(from, to, name, lifetimeManager)); if (injectionMembers.Length > 0) { ClearExistingBuildPlan(to, name); foreach(var member in injectionMembers) { member.AddPolicies(from, to, name, policies); } } return this; }
public IUnityContainer RegisterInstance(Type t, string name, object instance, LifetimeManager lifetime) { if (instance == null) { throw new ArgumentNullException("instance"); } if (lifetime == null) { throw new ArgumentNullException("lifetime"); } if (!string.IsNullOrEmpty(name)) { throw new NotSupportedException("Named registrations are not supported"); } this.RegisteringInstance(this, new RegisterInstanceEventArgs(t, instance, name, lifetime)); lock (this.lockObj) { lifetime.SetValue(instance); this.lifetimeTable.AddOrUpdate(t, lifetime); this.factoryExpressionTable.AddOrUpdate(t, Expression.Constant(instance)); this.ClearBuildPlans(); } return this; }
public IUnityContainer RegisterType(Type from, Type to, string name, LifetimeManager lifetimeManager, params InjectionMember[] injectionMembers) { if (to == null) { throw new ArgumentNullException("to"); } if (injectionMembers == null) { throw new ArgumentNullException("injectionMembers"); } if ((from != null && from.GetTypeInfo().IsGenericTypeDefinition) || to.GetTypeInfo().IsGenericTypeDefinition) { throw new ArgumentException("Open Generic Types are not supported"); } if (!string.IsNullOrEmpty(name)) { throw new NotSupportedException("Named registrations are not supported"); } if (injectionMembers.Length > 1) { throw new NotSupportedException("Multiple injection members are not supported"); } Logger.RegisterType(from ?? to, to, lifetimeManager); this.Registering(this, new RegisterEventArgs(from, to, name, lifetimeManager)); lock (this.lockObj) { if (from != null) { this.typeMappingTable.AddOrUpdate(from, to); } if (lifetimeManager != null) { this.lifetimeTable.AddOrUpdate(to, lifetimeManager); } if (injectionMembers.Length == 1) { this.factoryExpressionTable.AddOrUpdate(to, injectionMembers[0].GenExpression(to, this)); } this.ClearBuildPlans(); } return this; }
public IUnityContainer RegisterType(Type from, Type to, string name, LifetimeManager lifetimeManager, params InjectionMember[] injectionMembers) { throw new NotImplementedException(); }
public IUnityContainer RegisterInstance(Type t, string name, object instance, LifetimeManager lifetime);
public IUnityContainer RegisterType(Type from, Type to, string name, LifetimeManager lifetimeManager, params InjectionMember[] injectionMembers) { ConfigActions.Add( ConfigurationActionRecord.RegisterAction(from, to, name, lifetimeManager)); return this; }
/// <summary> /// RegisterType a type mapping with the container, where the created instances will use /// the given <see cref="LifetimeManager"/>. /// </summary> /// <param name="from"><see cref="Type"/> that will be requested.</param> /// <param name="to"><see cref="Type"/> that will actually be returned.</param> /// <param name="name">Name to use for registration, null if a default registration.</param> /// <param name="lifetimeManager">The <see cref="LifetimeManager"/> that controls the lifetime /// of the returned instance.</param> /// <returns>The <see cref="UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> public override IUnityContainer RegisterType(Type from, Type to, string name, LifetimeManager lifetimeManager) { if (to != null && !from.IsGenericType && !to.IsGenericType) { Guard.TypeIsAssignable(from, to, "from"); } registering(this, new RegisterEventArgs(from, to, name, lifetimeManager)); return this; }
/// <summary> /// RegisterType an instance with the container. /// </summary> /// <remarks> /// <para> /// Instance registration is much like setting a type as a singleton, except that instead /// of the container creating the instance the first time it is requested, the user /// creates the instance ahead of type and adds that instance to the container. /// </para> /// </remarks> /// <param name="t">Type of instance to register (may be an implemented interface instead of the full type).</param> /// <param name="instance">Object to returned.</param> /// <param name="name">Name for registration.</param> /// <param name="lifetime"> /// <para>If true, the container will take over the lifetime of the instance, /// calling Dispose on it (if it's <see cref="IDisposable"/>) when the container is Disposed.</para> /// <para> /// If false, container will not maintain a strong reference to <paramref name="instance"/>. User is responsible /// for disposing instance, and for keeping the instance from being garbage collected.</para></param> /// <returns>The <see cref="UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> public IUnityContainer RegisterInstance(Type t, string name, object instance, LifetimeManager lifetime) { Guard.ArgumentNotNull(instance, "instance"); Guard.ArgumentNotNull(lifetime, "lifetime"); Guard.InstanceIsAssignable(t, instance, "instance"); RegisteringInstance(this, new RegisterInstanceEventArgs(t, instance, name, lifetime)); return(this); }