public Registration(Guid id, Person person, RegistrationTarget registrationTarget, RegistrationDate registrationDate) : base(id)
{
if (id.Equals(Guid.Empty))
{
throw new ArgumentException(nameof(person), "Id cannot be an empty guid.");
}
if (person is null)
{
throw new ArgumentNullException(nameof(person), "Person cannot be null.");
}
if (registrationTarget is null)
{
throw new ArgumentNullException(nameof(registrationTarget), "RegistrationSubject cannot be null.");
}
if (registrationDate is null)
{
throw new ArgumentNullException(nameof(registrationDate), "RegistrationDate cannot be null.");
}
AddAndApplyEvent(new RegistrationCreated
{
AggregateRootId = id,
Person = person,
RegistrationTarget = registrationTarget,
RegistrationDate = registrationDate
});
}
private void IterateAndRegister(ILookup <RegistrationInfo, Type> lookup, Func <Type, bool> typePredicate,
RegistrationTarget target)
{
if (lookup == null || typePredicate == null)
{
return;
}
var serviceTypeCondition = TargetResolver.Resolve(target);
foreach (var group in lookup)
{
if (group.Key.Matches(RegistrationLifeTime.None))
{
continue;
}
var matchingTypes = group.Where(t => t != null)
.Where(typePredicate);
var lifetime = group.Key.LifeTime.ToContainerLifeTime();
var key = group.Key.Key;
foreach (Type t in matchingTypes)
{
var serviceType = t.GetInterfaces().First().IsGenericType ? t.GetInterfaces().First().GetGenericTypeDefinition() : t.GetInterfaces().First();
_container.Register(serviceType, t, lifestyle: lifetime);
}
}
}
private void IterateAndRegister(ILookup <RegistrationInfo, Type> lookup, Func <Type, bool> typePredicate,
RegistrationTarget target)
{
if (lookup == null || typePredicate == null)
{
return;
}
var serviceTypeCondition = TargetResolver.Resolve(target);
foreach (var group in lookup)
{
if (group.Key.Matches(RegistrationLifeTime.None))
{
continue;
}
var matchingTypes = group.Where(t => t != null)
.Where(typePredicate);
var lifetime = group.Key.LifeTime.ToContainerLifeTime();
var key = group.Key.Key;
_container.RegisterMany(matchingTypes, lifetime, serviceTypeCondition: serviceTypeCondition, serviceKey: ResolveKey(key));
}
}
public void ChangeRegistrationTarget(RegistrationTarget newRegistrationTarget)
{
AddAndApplyEvent(new RegistrationTargetChanged
{
AggregateRootId = Id,
NewRegistrationTarget = newRegistrationTarget
});
}
public IRegistrationContainer Register(Type concreteType, RegistrationTarget target,
RegistrationLifeTime registrationLifeTime = RegistrationLifeTime.Transient, string key = null, bool shouldReplace = false)
{
var serviceTypeCondition = TargetResolver.Resolve(target);
_container.RegisterMany(new[] { concreteType }, registrationLifeTime.ToContainerLifeTime(), serviceTypeCondition: serviceTypeCondition, serviceKey: ResolveKey(key), ifAlreadyRegistered: Map(shouldReplace));
return(this);
}
public IRegistrationContainer Register(Type concreteType, RegistrationTarget target,
RegistrationLifeTime registrationLifeTime = RegistrationLifeTime.Transient, string key = null, bool shouldReplace = false)
{
var serviceTypeCondition = TargetResolver.Resolve(target);
//_container.Register(concreteType);
//_container.Register( concreteType.UnderlyingSystemType, () => concreteType, registrationLifeTime.ToContainerLifeTime());
_container.Register(concreteType.GetType(), () => concreteType, registrationLifeTime.ToContainerLifeTime());
return(this);
}
public IRegistrationContainer BulkRegisterByMatchingEndName(ILookup <RegistrationInfo, Type> lookup, string matchingEndName,
RegistrationTarget target)
{
if (string.IsNullOrWhiteSpace(matchingEndName))
{
return(this);
}
var genericEndName = $"{matchingEndName}`1";
IterateAndRegister(lookup, t => t.Name.EndsWith(matchingEndName, StringComparison.OrdinalIgnoreCase) || t.Name.EndsWith(genericEndName, StringComparison.OrdinalIgnoreCase), target);
return(this);
}
public IRegistrationContainer BulkRegisterByPredicate(ILookup <RegistrationInfo, Type> lookup, Func <Type, bool> predicate, RegistrationTarget target)
{
IterateAndRegister(lookup, predicate, target);
return(this);
}
public IRegistrationContainer BulkRegisterByMatchingNamespaceWithChildren(ILookup <RegistrationInfo, Type> lookup, string matchingNamespace,
RegistrationTarget target)
{
IterateAndRegister(lookup, t => t.Namespace?.StartsWith(matchingNamespace, StringComparison.OrdinalIgnoreCase) ?? false, target);
return(this);
}
public IRegistrationContainer BulkRegisterByMatchingNamespace(ILookup <RegistrationInfo, Type> lookup, string matchingNamespace,
RegistrationTarget target)
{
IterateAndRegister(lookup, t => string.Equals(t.Namespace, matchingNamespace, StringComparison.OrdinalIgnoreCase), target);
return(this);
}
public IRegistrationContainer BulkRegisterByMatchingType(Type matchingType, ILookup <RegistrationInfo, Type> lookup, RegistrationTarget target)
{
IterateAndRegister(lookup, t => t.IsBasedOnGenericType(matchingType) || matchingType.IsAssignableFrom(t), target);
return(this);
}
public IRegistrationContainer BulkRegisterByMatchingType <TMatchingType>(ILookup <RegistrationInfo, Type> lookup, RegistrationTarget target)
{
return(BulkRegisterByMatchingType(typeof(TMatchingType), lookup, target));
}
public IRegistrationContainer Register <TConcrete>(RegistrationTarget target, RegistrationLifeTime registrationLifeTime = RegistrationLifeTime.Transient, string key = null, bool shouldReplace = false)
{
return(Register(typeof(TConcrete), target, registrationLifeTime, key, shouldReplace));
}
public static Func <Type, bool> Resolve(RegistrationTarget target)
{
return(TargetMap.ContainsKey(target) ? TargetMap[target] : TargetMap[RegistrationTarget.Interfaces]);
}
