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]); }