void OnRegistered(object sender, ComponentRegisteredEventArgs e)
{
var services = e.ComponentRegistration.Services
.OfType <TypedService>()
.Select(t => t.ServiceType)
.ToArray();
var implementation = e.ComponentRegistration.Activator.LimitType;
var bag = new Bag()
{
Services = services,
Implementation = implementation
};
if (this.IsInterestingHandler(bag, typeof(IMessageHandler)) || this.IsInterestingHandler(bag, typeof(IHandleMessage)))
{
logger.Debug
(
"Registered component is IMessageHandler/IHandleMessage: {0}/{1}, but no broker yet registered. buffering...",
services.FirstOrDefault() == null ? "<null>" : services.FirstOrDefault().ToString("SN"),
implementation.ToString("SN")
);
this.buffer.Add(new Tuple <Guid, Bag>(e.ComponentRegistration.Id, bag));
}
}
public void WhenRegistrationIsMade_ComponentRegisteredEventFired()
{
object eventSender = null;
ComponentRegisteredEventArgs args = null;
var eventCount = 0;
var registry = new ComponentRegistry();
registry.Registered += (sender, e) =>
{
eventSender = sender;
args = e;
++eventCount;
};
var registration = Factory.CreateSingletonObjectRegistration();
registry.Register(registration);
Assert.AreEqual(1, eventCount);
Assert.IsNotNull(eventSender);
Assert.AreSame(registry, eventSender);
Assert.IsNotNull(args);
Assert.AreSame(registry, args.ComponentRegistry);
Assert.AreSame(registration, args.ComponentRegistration);
}
private static void RegistryOnRegistered([CanBeNull] object sender, [NotNull] ComponentRegisteredEventArgs args)
{
if (UnitOfWorkHelper.IsConventionalUowClass(args.ComponentRegistration.Activator.LimitType) ||
UnitOfWorkHelper.HasUnitOfWorkAttribute(args.ComponentRegistration.Activator.LimitType))
{
UnitOfWorkRegistrar(args);
}
}
public void ConstructorSetsProperties()
{
var registry = new ComponentRegistry();
var registration = Factory.CreateSingletonObjectRegistration();
var args = new ComponentRegisteredEventArgs(registry, registration);
Assert.Same(registry, args.ComponentRegistry);
Assert.Same(registration, args.ComponentRegistration);
}
private void RegistryOnRegistered(object sender, ComponentRegisteredEventArgs args)
{
Type implType = args.ComponentRegistration.Activator.LimitType;
if (typeof(IRepository).IsAssignableFrom(implType))
{
args.ComponentRegistration.InterceptedBy <UnitOfWorkInterceptor>();
}
}
/// <summary>
/// Raises the <see cref="E:ComponentRegistered"/> event.
/// </summary>
/// <param name="e">The <see cref="Radical.ComponentModel.ComponentRegisteredEventArgs"/> instance containing the event data.</param>
protected virtual void OnComponentRegistered(ComponentRegisteredEventArgs e)
{
var h = this.ComponentRegistered;
if (h != null)
{
h(this, e);
}
}
private static void MultipleInterceptorRegistrar(ComponentRegisteredEventArgs args)
{
Type implType = args.ComponentRegistration.Activator.LimitType;
if (typeof(IApplicationService).IsAssignableFrom(implType))
{
args.ComponentRegistration.InterceptedBy(typeof(UnitOfWorkInterceptor), typeof(ExceptionInterceptor));
}
}
void OnComponentRegistered(object sender, ComponentRegisteredEventArgs e)
{
if (e.Entry.Services.Any(s => this.IsBootable(s)) || this.IsBootable(e.Entry.Component))
{
var t = this.GetTypeToResolve(e.Entry);
var svc = (IBootable)this.container.Resolve(t);
svc.Boot();
}
}
public static void RegisterSingleComponent <TLimit, TActivatorData, TSingleRegistrationStyle>(IComponentRegistry cr, IRegistrationBuilder <TLimit, TActivatorData, TSingleRegistrationStyle> rb) where TActivatorData : IConcreteActivatorData where TSingleRegistrationStyle : SingleRegistrationStyle
{
IComponentRegistration registration = rb.CreateRegistration <TLimit, TActivatorData, TSingleRegistrationStyle>();
cr.Register(registration, rb.RegistrationStyle.PreserveDefaults);
ComponentRegisteredEventArgs e = new ComponentRegisteredEventArgs(cr, registration);
foreach (EventHandler <ComponentRegisteredEventArgs> handler in rb.RegistrationStyle.RegisteredHandlers)
{
handler(cr, e);
}
}
/// <summary>
/// Register a component in the component registry. This helper method is necessary
/// in order to execute OnRegistered hooks and respect PreserveDefaults.
/// </summary>
/// <remarks>Hoping to refactor this out.</remarks>
/// <typeparam name="TLimit"></typeparam>
/// <typeparam name="TActivatorData"></typeparam>
/// <typeparam name="TSingleRegistrationStyle"></typeparam>
/// <param name="cr">Component registry to make registration in.</param>
/// <param name="rb">Registration builder with data for new registration.</param>
public static void RegisterSingleComponent <TLimit, TActivatorData, TSingleRegistrationStyle>(
IComponentRegistry cr,
IRegistrationBuilder <TLimit, TActivatorData, TSingleRegistrationStyle> rb)
where TSingleRegistrationStyle : SingleRegistrationStyle
where TActivatorData : IConcreteActivatorData
{
var registration = CreateRegistration(rb);
cr.Register(registration, rb.RegistrationStyle.PreserveDefaults);
var registeredEventArgs = new ComponentRegisteredEventArgs(cr, registration);
foreach (var rh in rb.RegistrationStyle.RegisteredHandlers)
{
rh(cr, registeredEventArgs);
}
}
public void OnComponentRegistered(object sender, ComponentRegisteredEventArgs args)
{
TypeInfo implementationType = args.ComponentRegistration.Activator.LimitType.GetTypeInfo();
if (IsGoingToCreateProxyForImplementationType(implementationType))
{
ConstructorInfo[] constructors = implementationType.GetConstructors(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
if (constructors.Length == 1)
{
if (constructors.Single().GetParameters().Any())
{
throw new InvalidOperationException($"{implementationType.FullName} has only one constructor which has parameter");
}
}
else
{
if (constructors.All(c => !c.GetParameters().Any()))
{
throw new InvalidOperationException($"{implementationType.FullName} has more than one constructor, but all without parameter");
}
if (constructors.All(c => c.GetParameters().Any()))
{
throw new InvalidOperationException($"{implementationType.FullName} has more than one constructor, but all with parameter");
}
if (constructors.GroupBy(c => c.IsPublic).Count() == 1)
{
throw new InvalidOperationException($"{implementationType.FullName} has more than one constructor, all with same visibility level");
}
if (constructors.Single(c => !c.IsPublic).GetParameters().Any())
{
throw new InvalidOperationException($"{implementationType.FullName} has more than one constructor, and its non public constructor has parameter");
}
}
if (implementationType.GetMethods(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.DeclaredOnly).Any(m => (m.IsPublic || m.IsFamily /*protected*/) && !m.IsVirtual))
{
throw new InvalidOperationException($"{implementationType.FullName} has non virtual public/protected instance members");
}
}
}
/// <summary>
/// Register a component in the component registry. This helper method is necessary
/// in order to execute OnRegistered hooks and respect PreserveDefaults.
/// </summary>
/// <remarks>Hoping to refactor this out.</remarks>
/// <typeparam name="TLimit"></typeparam>
/// <typeparam name="TActivatorData"></typeparam>
/// <typeparam name="TSingleRegistrationStyle"></typeparam>
/// <param name="cr">Component registry to make registration in.</param>
/// <param name="builder">Registration builder with data for new registration.</param>
public static void RegisterSingleComponent <TLimit, TActivatorData, TSingleRegistrationStyle>(
IComponentRegistry cr,
IRegistrationBuilder <TLimit, TActivatorData, TSingleRegistrationStyle> builder)
where TSingleRegistrationStyle : SingleRegistrationStyle
where TActivatorData : IConcreteActivatorData
{
if (cr == null)
{
throw new ArgumentNullException("cr");
}
var registration = CreateRegistration(builder);
cr.Register(registration, builder.RegistrationStyle.PreserveDefaults);
var registeredEventArgs = new ComponentRegisteredEventArgs(cr, registration);
foreach (var rh in builder.RegistrationStyle.RegisteredHandlers)
{
rh(cr, registeredEventArgs);
}
}
void OnRegistered(object sender, ComponentRegisteredEventArgs e)
{
var typeTo = e.ComponentRegistration.Activator.LimitType;
var regionName = this.conventions.GetInterestedRegionNameIfAny(typeTo);
if (!String.IsNullOrWhiteSpace(regionName))
{
var viewType = typeTo;
if (this.buffer.ContainsKey(regionName))
{
this.buffer[regionName].Add(viewType);
}
else
{
this.buffer.Add(regionName, new List <Type>()
{
viewType
});
}
}
}
public void NullRegistrationDetected()
{
var registry = new ComponentRegistry();
var args = new ComponentRegisteredEventArgs(registry, null);
}
public void NullContainerDetected()
{
var registration = Factory.CreateSingletonObjectRegistration();
var args = new ComponentRegisteredEventArgs(null, registration);
}
private static void Registry_Registered(object sender, ComponentRegisteredEventArgs e)
{
e.ComponentRegistration.Activating += ComponentRegistration_Activating;
}
private void OnRegistered(ComponentRegisteredEventArgs arg)
{
_logger.Verbose("Registered data seed {SeedServiceDescription}",
arg.ComponentRegistration.Services.Select(s => s.Description).ToArray());
}
private static void UnitOfWorkRegistrar([NotNull] ComponentRegisteredEventArgs args)
{
args.ComponentRegistration.InterceptedBy <UnitOfWorkInterceptor>(true);
}
/// <summary>
/// Invoked when a component is registered with the underlying builder.
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
void builder_Registered(object sender, ComponentRegisteredEventArgs args)
{
registered.Add(args.ComponentRegistration);
}
