static MunqUseCase()
{
container = new IocContainer();
singleton = new Munq.LifetimeManagers.ContainerLifetime();
container.Register<IWebService>(
c => new WebService(
c.Resolve<IAuthenticator>(),
c.Resolve<IStockQuote>()));
container.Register<IAuthenticator>(
c => new Authenticator(
c.Resolve<ILogger>(),
c.Resolve<IErrorHandler>(),
c.Resolve<IDatabase>()));
container.Register<IStockQuote>(
c => new StockQuote(
c.Resolve<ILogger>(),
c.Resolve<IErrorHandler>(),
c.Resolve<IDatabase>()));
container.Register<IDatabase>(
c => new Database(
c.Resolve<ILogger>(),
c.Resolve<IErrorHandler>()));
container.Register<IErrorHandler>(
c => new ErrorHandler(c.Resolve<ILogger>()));
container.RegisterInstance<ILogger>(new Logger())
.WithLifetimeManager(singleton);
}
/// <summary>
/// Delays until this lifetime is complete
/// </summary>
/// <returns>an async task</returns>
public static async Task AwaitEndOfLifetime(this ILifetimeManager manager)
{
while (manager != null && manager.IsExpired == false)
{
await Task.Delay(10);
}
}
static MunqUseCase()
{
container = new IocContainer();
singleton = new Munq.LifetimeManagers.ContainerLifetime();
container.Register <IWebService>(
c => new WebService(
c.Resolve <IAuthenticator>(),
c.Resolve <IStockQuote>()));
container.Register <IAuthenticator>(
c => new Authenticator(
c.Resolve <ILogger>(),
c.Resolve <IErrorHandler>(),
c.Resolve <IDatabase>()));
container.Register <IStockQuote>(
c => new StockQuote(
c.Resolve <ILogger>(),
c.Resolve <IErrorHandler>(),
c.Resolve <IDatabase>()));
container.Register <IDatabase>(
c => new Database(
c.Resolve <ILogger>(),
c.Resolve <IErrorHandler>()));
container.Register <IErrorHandler>(
c => new ErrorHandler(c.Resolve <ILogger>()));
container.RegisterInstance <ILogger>(new Logger())
.WithLifetimeManager(singleton);
}
internal Registration(string name, Type type, Func<Container, object> factory)
{
LifetimeManager = null;
Factory = factory;
Id = Guid.NewGuid().ToString();
Name = name;
}
/// <summary>
/// Delays until this lifetime is complete
/// </summary>
/// <returns>an async task</returns>
public static Task ToTask(this ILifetimeManager manager)
{
var tcs = new TaskCompletionSource();
manager.OnDisposed(() => tcs.SetResult());
return(tcs.Task);
}
/// <summary>
/// Registers the specified object with its related lifetime manager, and the
/// construction parameters used by the lifetime manager.
/// </summary>
/// <param name="serviceType">Type of service to register</param>
/// <param name="serviceObjectType">Type of object implementing the service</param>
/// <param name="parameters">Object construction parameters</param>
/// <param name="properties">Object properties to inject</param>
/// <param name="ltManager">Lifetime manager object</param>
/// <param name="customContext"></param>
public void Register(Type serviceType, Type serviceObjectType,
InjectedParameterSettingsCollection parameters = null,
PropertySettingsCollection properties = null, ILifetimeManager ltManager = null,
object customContext = null)
{
if (serviceType == null)
{
throw new ArgumentNullException("serviceType");
}
if (serviceObjectType == null)
{
throw new ArgumentNullException("serviceObjectType");
}
if (_services.ContainsKey(serviceType))
{
throw new ServiceAlreadyRegisteredException(serviceType);
}
// --- Register the new mapping
_services[serviceType] = new ServiceMapping(
serviceType,
serviceObjectType,
ltManager ?? new PerCallLifetimeManager(),
parameters,
properties,
customContext);
// --- Reset lifetime managers
foreach (var mapping in _services.Values)
{
mapping.LifetimeManager.ResetState();
mapping.Resolved = false;
}
}
public CatRegistration(Type from, Type to, ILifetimeManager lifetimeManager, string name = null)
{
this.From = from;
this.To = to;
this.LifetimeManager = lifetimeManager;
this.Name = name;
}
public void Use(Func <IFsContainer, object> factoryFunc, ILifetimeManager lifetimeManager)
{
Guard.ArgumentNotNull(factoryFunc, nameof(factoryFunc));
_binding.FactoryFunc = factoryFunc;
_binding.Lifetime = lifetimeManager;
}
internal Registration(string name, Type type, Func <Container, object> factory)
{
LifetimeManager = null;
Factory = factory;
Id = Guid.NewGuid().ToString();
Name = name;
}
/// <summary>
/// Subscribes to this event such that the given handler will be called when the event fires. Notifications will stop
/// when the lifetime associated with the given lifetime manager is disposed.
/// </summary>
/// <param name="handler">the action to run when the event fires</param>
/// <param name="lifetimeManager">the lifetime manager that determines when to stop being notified</param>
public void SubscribeForLifetime(Action handler, ILifetimeManager lifetimeManager)
{
if (lifetimeManager.IsExpired == false)
{
subscribers.Add(handler, lifetimeManager);
lifetimeManager.OnDisposed(() => subscribers.Remove(handler));
}
}
public void RegisterType <TFrom, TTo>(ILifetimeManager lifetimeManager) where TTo : TFrom
{
this.ContainerDic.Add(typeof(TFrom).FullName, new RegisterInfo()
{
lifetimeManager = lifetimeManager,
Type = typeof(TTo)
});
}
/// <summary>
/// Registers the specified object with its related lifetime manager, and the
/// construction parameters used by the lifetime manager.
/// </summary>
/// <param name="serviceType">Type of service to register</param>
/// <param name="serviceObjectType">Type of object implementing the service</param>
/// <param name="parameters">Object construction parameters</param>
/// <param name="properties">Object properties to inject</param>
/// <param name="ltManager">Lifetime manager object</param>
/// <param name="customContext"></param>
public void Register(Type serviceType, Type serviceObjectType,
InjectedParameterSettingsCollection parameters = null,
PropertySettingsCollection properties = null, ILifetimeManager ltManager = null,
object customContext = null)
{
DefaultContainer.Register(serviceType, serviceObjectType, parameters, properties,
ltManager, customContext);
}
public TextHighlighter(string highlightClass, ILifetimeManager <Label> labels = null)
{
_container = new VisualContainer();
_container.style.flexDirection = FlexDirection.Row;
_labels = new ObjectList <Label>(
labels ?? ListPool.New(() => new Label())
);
_highlightClass = highlightClass;
}
/// <summary>
/// Registers type using name
/// </summary>
private IContainer RegisterType(Type t, Type c, string name, ILifetimeManager lifetimeManager, object[] args)
{
lifetimeManager.CstorArgs = args;
lifetimeManager.TargetType = c;
lifetimeManager.InterfaceType = t;
lock (_syncLock)
_typeMapping.Add(new Primitives.Tuple <string, Type>(name, t), lifetimeManager);
return(this);
}
/// <summary>
/// Subscribes to the given event for the given lifetime
/// </summary>
/// <param name="route">the event to subscribe to</param>
/// <param name="handler">the event handler</param>
/// <param name="lifetimeManager">defines the lifetime of the subscription</param>
public void Register(string route, Action <RoutedEvent <T> > handler, ILifetimeManager lifetimeManager)
{
GetOrAddRoutedEvent(route).SubscribeForLifetime(handler, lifetimeManager);
lifetimeManager.OnDisposed(() =>
{
routes.Remove(route);
});
}
public PassThroughLifetime(
ILifetimeManager <T> parent,
System.Action <T> onInstantiate,
System.Action <T> onRelease
)
{
_parent = parent;
_onInstantiate = onInstantiate;
_onRelease = onRelease;
}
public Registration(IDependencyResolver container, string name, Type regType, Type implType)
{
LifetimeManager = null;
Container = container;
Factory = null;
Name = name;
_regType = regType;
_implType = implType;
_key = String.Format("[{0}]:{1}", (name ?? "null"), implType.FullName);
}
public Registration(IDependencyResolver container, string name, Type regType, Type implType)
{
LifetimeManager = null;
Container = container;
Factory = null;
Name = name;
_regType = regType;
_implType = implType;
_key = String.Format("[{0}]:{1}", (name ?? "null"), implType.FullName);
}
public Registration(IDependencyResolver container, string name, Type type,
Func <IDependencyResolver, object> factory)
{
LifetimeManager = null;
Container = container;
Factory = factory;
Name = name;
_type = type;
_key = "[" + (name ?? "null") + "]:" + type.Name;
}
public Registration(IDependencyResolver container, string name, Type type,
Func<IDependencyResolver, object> factory)
{
LifetimeManager = null;
Container = container;
Factory = factory;
Name = name;
_type = type;
_key = "[" + (name ?? "null") + "]:" + type.Name;
}
public IBindingWithSyntax <T> Use <T>(ILifetimeManager lifetime)
{
Guard.ArgumentNotNull(lifetime, nameof(lifetime));
_binding.Concrete = typeof(T);
_binding.Lifetime = lifetime;
Guard.TypeIsAssignable(_binding.Service, _binding.Concrete);
return(new BindingConfigurationBuilder <T>(_binding.BindingConfiguration));
}
public ReuseList(System.Func <T> spawner)
{
_parent = new VisualContainer();
_entries = new List <T>();
_pool = ListPool.New(() =>
{
var entry = spawner();
_parent.Add(entry.Element);
return(entry);
}
);
}
public void Constructor_Exception_NullLifetimeManager()
{
INavigationTarget navigationTarget = new MockNavigationTarget();
IViewFactory viewFactory = MockViewFactory.WithPageAndViewModel;
ILifetimeManager lifetimeManager = null;
IStorageManager storageManager = new MockStorageManager();
var e = Assert.Throws <ArgumentNullException>(() => new NavigationManager(navigationTarget, viewFactory, lifetimeManager, storageManager));
Assert.Equal("Value cannot be null.\r\nParameter name: lifetimeManager", e.Message);
Assert.Equal("lifetimeManager", e.ParamName);
}
public async Task SetInterval(Action action, TimeSpan interval, ILifetimeManager lifetime)
{
var shouldRun = true;
lifetime.OnDisposed(() => shouldRun = false);
while (shouldRun)
{
await DelayAsync(interval);
action();
}
}
// *** Constructors ***
public NavigationManager(INavigationTarget navigationTarget, IViewFactory viewFactory, ILifetimeManager lifetimeManager, IStorageManager storageManager
#if !NETFX_CORE
, IFileSystem fileSystem
#endif
)
: this(navigationTarget, viewFactory, lifetimeManager, storageManager
#if !NETFX_CORE
, fileSystem
#endif
, new NavigationStackWithHome())
{
}
/// <summary>
/// Registers the specified object with its related lifetime manager, and the
/// construction parameters used by the lifetime manager.
/// </summary>
/// <param name="serviceType">Type of service to register</param>
/// <param name="ltManager">Lifetime manager object</param>
/// <param name="constructionParams">Instance construction parameters</param>
/// <param name="properties">Initial property values</param>
public void Register(Type serviceType, ILifetimeManager ltManager,
object[] constructionParams, PropertySettingsCollection properties = null)
{
if (_registry.ContainsKey(serviceType))
{
throw new ConfigurationErrorsException(
String.Format("'{0}' type already registered with DefaultServiceRegistry",
serviceType));
}
_registry[serviceType] = new Tuple<ILifetimeManager, object[], PropertySettingsCollection>(
ltManager, constructionParams, properties);
}
private bool TryResolve(out object result, Stack <Type> stack, Type type, string key, bool canThrow, bool returnNull = false)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
if (stack == null)
{
throw new ArgumentNullException(nameof(stack));
}
if (key == null)
{
key = string.Empty;
}
using (new DisposablePush(stack, type))
{
ILifetimeManager lifetimeManager = null;
using (_lock.UseReadLock())
{
if (_isDisposed)
{
throw new ObjectDisposedException(GetType().Name);
}
if (_maps.RegistrationMap.TryGetValue(type, out Dictionary <string, ILifetimeManager> registrations))
{
registrations.TryGetValue(key, out lifetimeManager);
}
}
if (lifetimeManager != null)
{
result = returnNull ? null : lifetimeManager.Resolve(this, stack);
return(true);
}
foreach (var handler in ResolutionHandlers)
{
if (handler.TryResolve(out result, this, stack, type, key, canThrow))
{
return(true);
}
}
}
result = null;
return(false);
}
public void TryAddKey(ILifetimeManager lifetimeManager, Type type)
{
if (lifetimeManager.IsScoped && !_scopedKeys.Contains(type))
{
_scopedKeys = _scopedKeys.ToList();
_scopedKeys.Add(type);
}
if (lifetimeManager.IsDisposable && !_disposableKeys.Contains(type))
{
_disposableKeys = _disposableKeys.ToList();
_disposableKeys.Add(type);
}
}
///<inheritdoc/>
public void RegisterType(Type tFrom, Type tTo, ILifetimeManager lifetimeManager = null, params object[] injectionMembers)
{
if (lifetimeManager == null)
{
lifetimeManager = new TransientLifetimeManager();
}
Func <Type, IResolver> valueFactory = _ => lifetimeManager.CreateResolver(tFrom, tTo);
lock (lockObject)
{
this.values.AddOrUpdate(tFrom, valueFactory, (k, o) => valueFactory(k));
}
}
/// <summary>
/// Delays until this lifetime is complete
/// </summary>
/// <returns>an async task</returns>
public static async Task AwaitEndOfLifetime(this ILifetimeManager manager)
{
while (manager != null && manager.IsExpired == false)
{
if (Time.CurrentTime != null)
{
await Time.CurrentTime.YieldAsync();
}
else
{
await Task.Yield();
}
}
}
/// <summary>
/// Creates a new instance with the specified parameters.
/// </summary>
public ServiceMapping(
Type serviceType,
Type serviceObjectType,
ILifetimeManager lifetimeManager,
InjectedParameterSettingsCollection constructionParameters,
PropertySettingsCollection properties,
object customContext)
{
ServiceType = serviceType;
ServiceObjectType = serviceObjectType;
LifetimeManager = lifetimeManager;
ConstructionParameters = constructionParameters;
Properties = properties;
CustomContext = customContext;
}
///<inheritdoc/>
public object ResolveOrRegisterType(Type tFrom, Type tTo, ILifetimeManager lifetimeManager = null, string name = null, params ParameterOverride[] overrides)
{
lock (lockObject)
{
var resolver = GetResolver(tFrom);
if (resolver != null)
{
return(resolver.Resolve(this, name, overrides));
}
RegisterType(tFrom, tTo, lifetimeManager);
return(Resolve(tFrom, name, overrides));
}
}
public void AddOrUpdate(Type type, string identifier, ILifetimeManager manager)
{
IDictionary<string, ILifetimeManager> qualifiedMap = new Dictionary<string, ILifetimeManager>();
if (this._map.ContainsKey(type)) {
qualifiedMap = this._map[type];
if (qualifiedMap.ContainsKey(identifier)) {
qualifiedMap[identifier] = manager;
} else {
qualifiedMap.Add(identifier, manager);
}
} else {
qualifiedMap.Add(identifier, manager);
this._map.Add(type, qualifiedMap);
}
}
public void Add(string name, Type type, ILifetimeManager ltm)
{
if (!_map.ContainsKey(type))
{
_map.Add(type, new Dictionary <string, ILifetimeManager>());
}
if (_map[type].ContainsKey(name))
{
_map[type][name] = ltm;
}
else
{
_map[type].Add(name, ltm);
}
}
public NavigationManager([Import(AllowDefault = true)]INavigationTarget navigationTarget, IViewFactory viewFactory, ILifetimeManager lifetimeManager, IStorageManager storageManager)
{
this.viewFactory = viewFactory;
this.storageManager = storageManager;
// Use a default INavigationTarget if not specified
if (navigationTarget != null)
this.navigationTarget = navigationTarget;
else
this.navigationTarget = new WindowNavigationTarget();
// Register with the LifetimeManager
lifetimeManager.Register(this);
}
// *** Constructors ***
public NavigationManager(INavigationTarget navigationTarget, IViewFactory viewFactory, ILifetimeManager lifetimeManager, IStorageManager storageManager)
: base(viewFactory)
{
this.storageManager = storageManager;
// Use a default INavigationTarget if not specified
if (navigationTarget != null)
this.navigationTarget = navigationTarget;
else
this.navigationTarget = new WindowNavigationTarget();
// Register with the LifetimeManager
lifetimeManager.Register(this);
}
public void Register(ILifetimeManager lifetimeManager, Type fromType, string key = null)
{
if (key == null)
{
key = string.Empty;
}
using (_lock.UseWriteLock())
{
if (_isDisposed)
{
throw new ObjectDisposedException(GetType().Name);
}
if (_maps.RegistrationMap.TryGetValue(fromType, out Dictionary <string, ILifetimeManager> registrations))
{
if (IncludeUnkeyedInResovleAll && registrations.ContainsKey(key) && key == string.Empty)
{
key = $"_unkeyed_{Interlocked.Increment(ref _keySeed)}";
}
var clone = _maps.RegistrationMap[fromType] = new Dictionary <string, ILifetimeManager>(registrations);
clone[key] = lifetimeManager;
}
else
{
_maps.RegistrationMap[fromType] = new Dictionary <string, ILifetimeManager>
{
{ key, lifetimeManager }
}
};
_maps.TryAddKey(lifetimeManager, fromType);
}
if (Log.IsEnabled(LogLevel.Debug))
{
if (string.IsNullOrWhiteSpace(key))
{
Log.Debug("Type: {0} - {1}", fromType.Name, lifetimeManager.Description);
}
else
{
Log.Debug("Type: {0} - Key: {1} - {2}", fromType.Name, key, lifetimeManager.Description);
}
}
}
private ILifetimeManager ResolveLifetime(ILifetimeManager lifetimeManager)
{
//if cstor isn't provided, try to resolve one with dependency attribute
if (lifetimeManager.Constructor == null && lifetimeManager.TargetType != null)
{
lifetimeManager.Constructor = TypeHelper.GetConstructor(lifetimeManager.TargetType,
typeof(DependencyAttribute));
}
//NOTE: resolve all parameters of provided constructor
if (lifetimeManager.Constructor != null)
{
lifetimeManager.CstorArgs =
lifetimeManager.Constructor.GetParameters().Select(p => Resolve(p.ParameterType)).ToArray();
}
return(lifetimeManager);
}
public Registration(IIocContainer container, string name, Type type, Func <IIocContainer, object> factory)
{
LifetimeManager = null;
Container = container;
Factory = factory;
Name = name;
_type = type;
_key = "[" + (name ?? "null") + "]:" + type.Name;
if (name == null)
{
LazyFactory = () => container.Resolve(_type);
}
else
{
LazyFactory = () => container.Resolve(Name, _type);
}
}
public void Register(Type i, Type c, ILifetimeManager lifetimeManager = null)
{
if (lifetimeManager == null)
{
lifetimeManager = new PerResolveLifetimeManager();
}
var dependencyModel = new DependencyModel
{
From = i,
To = c,
LifetimeManager = lifetimeManager.GetType(),
LifetimeManagerKey = lifetimeManager.GetKey(),
ResolvedType = DobbyInstanceService.GetInstance(c)
};
_registeredTypes.Add(dependencyModel);
lifetimeManager.Dispose();
}
protected NavigationManager(INavigationTarget navigationTarget, IViewFactory viewFactory, ILifetimeManager lifetimeManager, IStorageManager storageManager
#if !NETFX_CORE
, IFileSystem fileSystem
#endif
, INavigationStack navigationStack)
: base(viewFactory, navigationStack)
{
if (lifetimeManager == null)
throw new ArgumentNullException(nameof(lifetimeManager));
if (storageManager == null)
throw new ArgumentNullException(nameof(storageManager));
_storageManager = storageManager;
#if !NETFX_CORE
if (fileSystem == null)
throw new ArgumentNullException(nameof(fileSystem));
_fileSystem = fileSystem;
#endif
// Use a default INavigationTarget if not specified
if (navigationTarget != null)
_navigationTarget = navigationTarget;
else
#if NETFX_CORE
_navigationTarget = new WindowNavigationTarget();
#else
_navigationTarget = new NavigationViewNavigationTarget();
#endif
// Register with the LifetimeManager
lifetimeManager.Register(this);
}
public static void Configure(IocContainer container, ILifetimeManager lifetime)
{
CreateComponentMappedProperties
.AddRuleForIdentifyingComponents(
x => x.ReturnType().GetCustomAttributes(typeof(ValueTypeAttribute), false).Any());
var cs = ConfigurationManager.ConnectionStrings["Project1"].ConnectionString;
var configuration = ConfigurationBuilder.New(true)
.ForSql2008(cs)
.MapEntities(typeof (User).Assembly.GetTypes(), MatchEntities.WithIdProperty);
//Environment.UseReflectionOptimizer = false;
configuration.SetProperty(Environment.GenerateStatistics, "true");
configuration.SetProperty(Environment.BatchSize, "10");
configuration.SetProperty(Environment.ConnectionDriver,
typeof(ProfiledSql2008ClientDriver).AssemblyQualifiedName);
new SchemaUpdate(configuration).Execute(s => Debug.WriteLine(s), true);
{
//Set up some black magic that allows us to use Fac to create our entities
Fac.Default.Interceptors.Add(t => new MarkerInterceptor(t));
Fac.Default.TypesToImplement.Add(t => typeof (IMarkerInterface));
configuration.InterceptObjectInstantiation(container.Resolve<ISessionFactory>, Fac.New);
}
var sf = configuration.BuildSessionFactory();
NullabilityRules.AddNotNullAttribute<NotNullAttribute>();
//NhCodeFirst.UserTypes.SerializedUserType.Deserialize = JsonSerializer.DeserializeFromString;
//NhCodeFirst.UserTypes.SerializedUserType.Serialize = JsonSerializer.SerializeToString;
configuration.ExecuteAuxilliaryDatabaseScripts(sf);
container.RegisterInstance(sf);
container.Register(k => k.Resolve<ISessionFactory>().OpenSession()).WithLifetimeManager(lifetime);
}
// *** Private Methods ***
private TestableNavigationManager CreateNavigationManager(INavigationTarget navigationTarget = null, IViewFactory viewFactory = null, INavigationStack navigationStack = null, ILifetimeManager lifetimeManager = null, IStorageManager storageManager = null, bool navigationTargetIsNull = false)
{
if (navigationTarget == null && !navigationTargetIsNull)
navigationTarget = new MockNavigationTarget();
if (viewFactory == null)
viewFactory = MockViewFactory.WithPageAndViewModel;
if (navigationStack == null)
navigationStack = new MockNavigationStack();
if (lifetimeManager == null)
lifetimeManager = new MockLifetimeManager();
if (storageManager == null)
storageManager = new MockStorageManager();
TestableNavigationManager navigationManager = new TestableNavigationManager(navigationTarget, viewFactory, navigationStack, lifetimeManager, storageManager);
return navigationManager;
}
// *** Constructors ***
public TestableNavigationManager(INavigationTarget navigationTarget, IViewFactory viewFactory, INavigationStack navigationStack, ILifetimeManager lifetimeManager, IStorageManager storageManager)
: base(navigationTarget, viewFactory, lifetimeManager, storageManager, navigationStack)
{
}
public IRegistration WithLifetimeManager(ILifetimeManager manager)
{
LifetimeManager = manager;
return this;
}
/// <inheritdoc />
public IContainerFluent UsesDefaultLifetimeManagerOf(ILifetimeManager lifetimeManager)
{
DefaultLifetimeManager = lifetimeManager;
return this;
}
