private void OnRegistering(object sender, RegisterEventArgs e) { m_Entries.Add(new TypeRegistrationEntry(e.TypeFrom ?? e.TypeTo, e.Name)); if (Registering != null) Registering(sender, e); }
private void OnRegistering(object sender, RegisterEventArgs e) { var component = e.TypeTo.GetCustomAttribute<ComponentAttribute>(); if (component == null) return; foreach (var iface in e.TypeTo.GetTypeInfo().ImplementedInterfaces) { // Register the named component with the full type name since // Unity does not allow multiple registrations with the same type. this.Context.RegisterNamedType(iface, e.TypeTo.FullName); // Next, we set the policy for building the key for the type without // key and map it to the one we registered above, with type + name. this.Context.Policies.Set<IBuildKeyMappingPolicy>( new BuildKeyMappingPolicy(new NamedTypeBuildKey(e.TypeTo, null)), new NamedTypeBuildKey(iface, e.TypeTo.FullName)); var named = e.TypeTo.GetCustomAttribute<NamedAttribute>(true); if (named != null) { // We must also register the key mapping with the custom key. // key and map it to the one we registered above, with type + name. this.Context.Policies.Set<IBuildKeyMappingPolicy>( new BuildKeyMappingPolicy(new NamedTypeBuildKey(e.TypeTo, named.Name)), new NamedTypeBuildKey(iface, e.TypeTo.FullName)); } } }
private void TypeRegistering(object sender, RegisterEventArgs args) { if (!typeof(IMessageConsumer).IsAssignableFrom(args.TypeTo)) return; args.LifetimeManager = new TransientLifetimeManager(); interceptor.ItemCreated(args.TypeTo, true); }
private void OnRegistering(object sender, RegisterEventArgs e) { string returnedName = EnsureAndReturnName(e.Name, e.TypeFrom); if (!string.IsNullOrEmpty(returnedName)) { e.Name = returnedName; } }
void OnRegistering(object sender, RegisterEventArgs e) { Trace.WriteLine(String.Format("Registering: {0}", e.Name ?? "_Default_")); Trace.WriteLine(String.Format(" Type: {0}", e.TypeTo)); Trace.WriteLine(String.Format(" MappedTo: {0}", e.TypeFrom)); if (e.LifetimeManager != null) { Trace.WriteLine(String.Format(" Lifetime: {0}", e.LifetimeManager.GetType())); } }
private void OnRegister(object sender, RegisterEventArgs e) { if (ShouldIntercept(e)) { var container = sender as IUnityContainer; var i = new Interceptor<InterfaceInterceptor>(); i.AddPolicies(e.TypeFrom, e.TypeTo, e.Name, Context.Policies); _interceptionBehaviors.ForEach( (b) => { var interfaceBehavior = new InterceptionBehavior(b); interfaceBehavior.AddPolicies(e.TypeFrom, e.TypeTo, e.Name, Context.Policies); }); } }
private void CheckStepScope(object sender, RegisterEventArgs args) { var isStepScope = args.LifetimeManager is StepScopeLifetimeManager; // First we need to check any registered dependency with the same registered type and name Container.Registrations.Where(r => r.RegisteredType != (args.TypeFrom ?? args.TypeTo) && r.MappedToType == args.TypeTo && r.Name == args.Name).ForEach(r => { if (StepScopeSynchronization.IsStepScope(r.MappedToType, r.Name)) { // if the previously registered dependency is in step scope, a newly defined // liftetime manager takes precedence. If no lifetime manager is defined for // the new dependency, it is in step scope. if (args.LifetimeManager == null) { isStepScope = true; } if (!isStepScope) { StepScopeSynchronization.RemoveScopeDependency(r.RegisteredType, r.Name); StepScopeSynchronization.RemoveScopeDependency(r.MappedToType, r.Name); } } else if (isStepScope) { // if the previously registered dependency is not in step scope but the new dependency // is, the previously registered dependency is put in step scope. if (r.RegisteredType != r.MappedToType) { StepScopeSynchronization.AddStepScopeDependency(r.RegisteredType, r.Name, Container, r.MappedToType); } StepScopeSynchronization.AddStepScopeDependency(r.MappedToType, r.Name, Container, r.MappedToType); } }); // Finally, we register the new dependency in the step scope if required if (isStepScope) { if (args.TypeFrom != null) { StepScopeSynchronization.AddStepScopeDependency(args.TypeFrom, args.Name, Container, args.TypeTo); } StepScopeSynchronization.AddStepScopeDependency(args.TypeTo, args.Name, Container, args.TypeTo); } }
void OnRegistering( object sender, RegisterEventArgs e ) { //var model = e.ComponentModel; var conventions = this.Container.Resolve<BootstrapConventions>(); if ( e.TypeFrom.Is<IRegionInjectionHandler>() ) { if ( this.buffer.Any() ) { var mh = this.Container.Resolve<IRegionInjectionHandler>(); foreach ( var kvp in this.buffer ) { mh.RegisterViewsAsInterestedIn( regionName: kvp.Key, views: kvp.Value.AsEnumerable() ); } this.buffer.Clear(); } } else { var regionName = conventions.GetInterestedRegionNameIfAny( e.TypeTo ); if ( !String.IsNullOrWhiteSpace( regionName ) ) { var viewType = e.TypeTo; if ( this.Container.IsRegistered<IRegionInjectionHandler>() ) { var mh = this.Container.Resolve<IRegionInjectionHandler>(); mh.RegisterViewAsInterestedIn( regionName, viewType ); } else if ( this.buffer.ContainsKey( regionName ) ) { this.buffer[ regionName ].Add( viewType ); } else { this.buffer.Add( regionName, new List<Type>() { viewType } ); } } } }
private void AddRegistration(object sender, RegisterEventArgs e) { if (e.TypeFrom == null || !e.TypeFrom.GetTypeInfo().IsInterface) { return; } List<Type> stack = null; if (!_typeStacks.ContainsKey(e.TypeFrom)) { stack = new List<Type>(); _typeStacks.Add(e.TypeFrom, stack); } else { stack = _typeStacks[e.TypeFrom]; } stack.Add(e.TypeTo); }
void Attach( String key, RegisterEventArgs h ) { var broker = this.Container.Resolve<IMessageBroker>(); var invocationModel = h.TypeTo.Is<INeedSafeSubscription>() ? InvocationModel.Safe : InvocationModel.Default; h.TypeTo.GetAttributes<SubscribeToMessageAttribute>() .Return( attributes => { return attributes.Select( a => typeof( IMessageHandler<> ).MakeGenericType( a.MessageType ) ) .Where( gh => this.IsInterestingHandler( h, gh ) ); }, () => { return h.TypeTo.GetInterfaces() .Where( i => ( i.Is<IMessageHandler>() || i.Is<IHandleMessage>() ) && i.IsGenericType ); }, attributes => { return !attributes.Any(); } ) .ForEach( t => this.Subscribe( broker, key, h, t, invocationModel ) ); }
private void OnRegister(object sender, RegisterEventArgs e) { Context.RegisterNamedType(e.TypeFrom ?? e.TypeTo, e.Name); if (e.TypeFrom != null) { if (e.TypeFrom.GetTypeInfo().IsGenericTypeDefinition&& e.TypeTo.GetTypeInfo().IsGenericTypeDefinition) { Context.Policies.Set <IBuildKeyMappingPolicy>( new GenericTypeBuildKeyMappingPolicy(new NamedTypeBuildKey(e.TypeTo, e.Name)), new NamedTypeBuildKey(e.TypeFrom, e.Name)); } else { Context.Policies.Set <IBuildKeyMappingPolicy>( new BuildKeyMappingPolicy(new NamedTypeBuildKey(e.TypeTo, e.Name)), new NamedTypeBuildKey(e.TypeFrom, e.Name)); } } if (e.LifetimeManager != null) { this.SetLifetimeManager(e.TypeTo, e.Name, e.LifetimeManager); } }
private void OnRegister(object sender, RegisterEventArgs e) { Context.RegisterNamedType(e.TypeFrom ?? e.TypeTo, e.Name); if (e.TypeFrom != null) { if (e.TypeFrom.GetTypeInfo().IsGenericTypeDefinition && e.TypeTo.GetTypeInfo().IsGenericTypeDefinition) { Context.Policies.Set<IBuildKeyMappingPolicy>( new GenericTypeBuildKeyMappingPolicy(new NamedTypeBuildKey(e.TypeTo, e.Name)), new NamedTypeBuildKey(e.TypeFrom, e.Name)); } else { Context.Policies.Set<IBuildKeyMappingPolicy>( new BuildKeyMappingPolicy(new NamedTypeBuildKey(e.TypeTo, e.Name)), new NamedTypeBuildKey(e.TypeFrom, e.Name)); } } if (e.LifetimeManager != null) { SetLifetimeManager(e.TypeTo, e.Name, e.LifetimeManager); } }
private void OnRegisterType(object sender, RegisterEventArgs e) { object[] atts = null; if (e.TypeFrom != null) { atts = e.TypeFrom.GetCustomAttributes(typeof(SystemImmutableComponentAttribute), false); } object[] atts2 = null; if (e.TypeTo != null) { atts2 = e.TypeTo.GetCustomAttributes(typeof(SystemImmutableComponentAttribute), false); } if ((atts != null && atts.Length > 0) || (atts2 != null && atts2.Length > 0) && (SistemComponentTypeRegistered != null)) { var duplicated = (_registeredTypes.Contains(e.TypeFrom) || (_registeredTypes.Contains(e.TypeTo))); SistemComponentTypeRegistered(this, new TypeRegisterEventArgs(e, duplicated)); } AddType(e.TypeFrom, e.TypeTo); }
private bool ShouldIntercept(RegisterEventArgs e) { return e != null && e.TypeFrom != null && e.TypeFrom.IsInterface && _interfaces.Contains(e.TypeFrom); }
void Context_Registering(object sender, RegisterEventArgs e) { _logger.Log(String.Format("REG TYPE {0}", (e.TypeTo ?? e.TypeFrom).Name), Category.Debug, Priority.None); }
Boolean IsInterestingHandler( RegisterEventArgs e, Type t ) { return e.TypeFrom.Is( t ) || e.TypeTo.Is( t ); }
void Subscribe( IMessageBroker broker, String key, RegisterEventArgs h, Type genericHandler, InvocationModel invocationModel ) { var messageType = genericHandler.GetGenericArguments().Single(); logger.Debug ( "\tSubscribing to message: {0}", messageType.ToString( "SN" ) ); if ( genericHandler.Is<IMessageHandler>() ) { broker.Subscribe( this, messageType, invocationModel, msg => { if ( this.Container != null ) { var handler = this.Container.Resolve( h.TypeFrom, key ) as IMessageHandler; if ( handler != null ) { logger.Debug ( "Dispatching message {0} to IMessageHandler {1}", msg.GetType().ToString( "SN" ), handler.GetType().ToString( "SN" ) ); if ( handler.ShouldHandle( msg ) ) { handler.Handle( msg ); } } else { logger.Debug ( "IMessageHandler for {0} is null.", msg.GetType().ToString( "SN" ) ); } } else { logger.Debug( "Kernel is null." ); logger.Debug( "Kernel is null." ); } } ); } else if ( genericHandler.Is<IHandleMessage>() ) { broker.Subscribe( this, messageType, invocationModel, ( s, msg ) => { if ( this.Container != null ) { var handler = this.Container.Resolve( h.TypeFrom, key ) as IHandleMessage; if ( handler != null ) { logger.Debug ( "Dispatching message {0} to IHandleMessage {1}", msg.GetType().ToString( "SN" ), handler.GetType().ToString( "SN" ) ); if ( handler.ShouldHandle( s, msg ) ) { handler.Handle( s, msg ); } } else { logger.Debug ( "IHandleMessage for {0} is null.", msg.GetType().ToString( "SN" ) ); } } else { logger.Debug( "Kernel is null." ); } } ); } }
private void TypeRegistering(object sender, RegisterEventArgs args) { var type = args.TypeTo; if (_interceptor.Match(type)) _interceptor.ItemCreated(type, args.LifetimeManager == null || args.LifetimeManager is TransientLifetimeManager); }
public TypeRegisterEventArgs(RegisterEventArgs e, bool isDuplicated) : this(e.TypeFrom, e.TypeTo, e.Name, e.LifetimeManager, isDuplicated) { }