/// <summary>Code contracts</summary> public bool TryGetAssociation(T key, out LifetimeBase val) { TurboContract.Ensures((TurboContract.Result <bool>() == true && TurboContract.ValueAtReturn <LifetimeBase>(out val) != null) || (TurboContract.Result <bool>() == false && TurboContract.ValueAtReturn <LifetimeBase>(out val) == null)); throw new NotImplementedException(); }
protected override bool TryAddAssociationInner(T key, LifetimeBase val) { Contract.Requires((object)key != null); Contract.Requires(val != null); throw new NotImplementedException(); }
protected override bool TryAddAssociationInner(T key, LifetimeBase val) { TurboContract.Requires(key != null, conditionString: "key != null"); TurboContract.Requires(val != null, conditionString: "val != null"); throw new NotImplementedException(); }
protected override bool TryGetAssociationInner(T key, out LifetimeBase val) { Contract.Requires((object)key != null); Contract.Ensures((Contract.Result <bool>() == true && Contract.ValueAtReturn <LifetimeBase>(out val) != null) || (Contract.Result <bool>() == false && Contract.ValueAtReturn <LifetimeBase>(out val) == null)); throw new NotImplementedException(); }
protected override bool TryGetAssociationInner(T key, out LifetimeBase val) { TurboContract.Requires(key != null, conditionString: "key != null"); TurboContract.Ensures((TurboContract.Result <bool>() == true && TurboContract.ValueAtReturn <LifetimeBase>(out val) != null) || (TurboContract.Result <bool>() == false && TurboContract.ValueAtReturn <LifetimeBase>(out val) == null)); throw new NotImplementedException(); }
/// <summary> /// Adds a new association to the container /// </summary> /// <param name="key">Key</param> /// <param name="val">Lifetime object container to add</param> protected sealed override void AddAssociationInner(TKey key, LifetimeBase val) { lock (_storage) { if (_storage.ContainsKey(key)) { throw new ItemAlreadyExistsException(string.Format("AssociationContainer already contains the association for the key ({0})", key)); } _storage.Add(key, val); } }
/// <summary> /// Attempts to add a new association to the container /// </summary> /// <param name="key">Key</param> /// <param name="val">Lifetime object container to add</param> /// <returns>True if AssociationContainer not contains lifetime container with the same key; overwise false</returns> protected sealed override bool TryAddAssociationInner(TKey key, LifetimeBase val) { lock (_storage) { if (_storage.ContainsKey(key)) { return(false); } _storage.Add(key, val); } return(true); }
private T TestContainer <T>(LifetimeBase container) { TestInjectionResolver resolver = new TestInjectionResolver(); Assert.AreEqual(typeof(T), container.OutputType); var instance = container.GetInstance(resolver); Assert.IsNotNull(instance); Assert.IsInstanceOfType(instance, typeof(T)); return((T)instance); }
/// <summary> /// Adds a new association to the container /// </summary> /// <param name="key">Key</param> /// <param name="val">Lifetime object container to add</param> protected sealed override void AddAssociationInner(TKey key, LifetimeBase val) { TurboContract.Requires(key != null, conditionString: "key != null"); TurboContract.Requires(val != null, conditionString: "val != null"); lock (_storage) { if (_storage.ContainsKey(key)) { throw new ItemAlreadyExistsException(string.Format("AssociationContainer already contains the association for the key ({0})", key)); } _storage.Add(key, val); } }
/// <summary> /// Attempts to add a new association to the container /// </summary> /// <param name="key">Key</param> /// <param name="val">Lifetime object container to add</param> /// <returns>True if AssociationContainer not contains lifetime container with the same key; overwise false</returns> protected bool TryAddAssociation(TKey key, LifetimeBase val) { TurboContract.Requires(key != null, conditionString: "key != null"); TurboContract.Requires(val != null, conditionString: "val != null"); TurboContract.Ensures(TurboContract.Result <bool>() == false || this.ContainsInner(key)); if (!IsGoodTypeForKey(key, val.OutputType)) { throw new AssociationBadKeyForTypeException(string.Format("Bad key ({0}) for the type ({1})", key, val.OutputType)); } CheckContainerState(true); return(TryAddAssociationInner(key, val)); }
/// <summary> /// Attempts to get the lifetime object container by its key /// </summary> /// <param name="key">Key</param> /// <param name="val">Associated lifetime container (null when key not exists)</param> /// <returns>True if the lifetime container for the speicifed key exists in AssociatnioContainer</returns> bool IAssociationSource <TKey> .TryGetAssociation(TKey key, out LifetimeBase val) { if (key == null) { throw new ArgumentNullException("key"); } if (_isDisposed) { val = null; return(false); } return(TryGetAssociationInner(key, out val)); }
/// <summary> /// Attempts to add a new association to the container /// </summary> /// <param name="key">Key</param> /// <param name="val">Lifetime object container to add</param> /// <returns>True if AssociationContainer not contains lifetime container with the same key; overwise false</returns> protected sealed override bool TryAddAssociationInner(TKey key, LifetimeBase val) { TurboContract.Requires(key != null, conditionString: "key != null"); TurboContract.Requires(val != null, conditionString: "val != null"); lock (_storage) { if (_storage.ContainsKey(key)) { return(false); } _storage.Add(key, val); } return(true); }
/// <summary> /// Gets the lifetime object container by its key /// </summary> /// <param name="key">Key</param> /// <returns>Lifetime container for the specified key</returns> LifetimeBase IAssociationSource <TKey> .GetAssociation(TKey key) { if (key == null) { throw new ArgumentNullException("key"); } if (_isDisposed) { throw new ObjectDisposedException(this.GetType().Name); } LifetimeBase res = null; if (!TryGetAssociationInner(key, out res)) { throw new KeyNotFoundException(string.Format("Key {0} not found in Association Container", key)); } return(res); }
/// <summary> /// Adds a new association to the container /// </summary> /// <param name="key">Key</param> /// <param name="val">Lifetime object container to add</param> protected void AddAssociation(TKey key, LifetimeBase val) { Contract.Requires(key != null); Contract.Requires(val != null); Contract.Ensures(this.ContainsInner(key)); if (key == null) { throw new ArgumentNullException("key"); } if (val == null) { throw new ArgumentNullException("val"); } if (!IsGoodTypeForKey(key, val.OutputType)) { throw new AssociationBadKeyForTypeException(string.Format("Bad key ({0}) for type ({1})", key, val.OutputType)); } CheckContainerState(true); AddAssociationInner(key, val); }
internal bool TryGetAssociation(TKey key, out LifetimeBase val) { return(_storage.TryGetValue(key, out val)); }
/// <summary> /// Attempts to get an association from the container by the specified key /// </summary> /// <param name="key">Key</param> /// <param name="val">Lifetime container for the specified key (in case of success)</param> /// <returns>True if the AssociationContainer contains the lifetime container for the specified key</returns> protected sealed override bool TryGetAssociationInner(TKey key, out LifetimeBase val) { TurboContract.Requires(key != null, conditionString: "key != null"); return(_storage.TryGetValue(key, out val)); }
/// <summary> /// Attempts to get an association from the container by the specified key. Should be implemented in derived type. /// </summary> /// <param name="key">Key</param> /// <param name="val">Lifetime container for the specified key (in case of success)</param> /// <returns>True if the AssociationContainer contains the lifetime container for the specified key</returns> protected abstract bool TryGetAssociationInner(TKey key, out LifetimeBase val);
/// <summary> /// Attempts to get an association from the container by the specified key /// </summary> /// <param name="key">Key</param> /// <param name="val">Lifetime container for the specified key (in case of success)</param> /// <returns>True if the AssociationContainer contains the lifetime container for the specified key</returns> protected sealed override bool TryGetAssociationInner(TKey key, out LifetimeBase val) { return(_storage.TryGetValue(key, out val)); }
/// <summary> /// Attempts to add a new association to the container. Should be implemented in derived type. /// </summary> /// <param name="key">Key</param> /// <param name="val">Lifetime object container to add</param> /// <returns>True if AssociationContainer not contains lifetime container with the same key; overwise false</returns> protected abstract bool TryAddAssociationInner(TKey key, LifetimeBase val);
/// <summary> /// Adds a new association to the container. Should be implemented in derived type. /// </summary> /// <param name="key">Key</param> /// <param name="val">Lifetime object container to add</param> protected abstract void AddAssociationInner(TKey key, LifetimeBase val);
/// <summary> /// Adds a range of types with attributes to the container /// </summary> /// <typeparam name="TAttr">The type of the attribute that is used to mark a type (should be derived from LocatorTargetObjectAttribute)</typeparam> /// <param name="typeSource">The sequence of all types to scan and add to the container</param> /// <param name="attrCmpPredicate">Predicate that allows to filter out non relevant types (can be null)</param> /// <param name="keyGenerator">Function to create a key by the type and attribute</param> /// <param name="modeOver">Overrides the instantiation mode from attribute</param> /// <param name="multiAttr">Allows processing of multiple attributes on the same type</param> /// <param name="combineIfPossible">Allows to combine instances of the same type with different keys</param> protected void AddTypeRangeWithStrictAttrPlain <TAttr>(IEnumerable <Type> typeSource, Func <TAttr, bool> attrCmpPredicate, Func <Type, TAttr, TKey> keyGenerator, OverrideObjectInstantiationMode modeOver = OverrideObjectInstantiationMode.None, bool multiAttr = true, bool combineIfPossible = true) where TAttr : LocatorTargetObjectAttribute { Contract.Requires <ArgumentNullException>(typeSource != null); Contract.Requires <ArgumentNullException>(keyGenerator != null); Type curAnalizeType = null; LifetimeBase singletonLf = null; LifetimeBase deferedSingletonLf = null; LifetimeBase perThreadLf = null; ScanTypeRangeWithStrictAttr <TAttr>(typeSource, attrCmpPredicate, (tp, attr) => { if (tp != curAnalizeType) { curAnalizeType = tp; singletonLf = null; deferedSingletonLf = null; perThreadLf = null; } var key = keyGenerator(tp, attr); ObjectInstantiationMode instMode = TransformInstMode(attr.Mode, modeOver); if (combineIfPossible) { switch (instMode) { case ObjectInstantiationMode.Singleton: if (singletonLf == null) { singletonLf = ProduceResolveInfo(key, tp, LifetimeFactories.Singleton); } AddAssociation(key, singletonLf); break; case ObjectInstantiationMode.DeferedSingleton: if (deferedSingletonLf == null) { deferedSingletonLf = ProduceResolveInfo(key, tp, LifetimeFactories.DeferedSingleton); } AddAssociation(key, deferedSingletonLf); break; case ObjectInstantiationMode.PerThread: if (perThreadLf == null) { perThreadLf = ProduceResolveInfo(key, tp, LifetimeFactories.PerThread); } AddAssociation(key, perThreadLf); break; default: AddAssociation(key, tp, LifetimeFactories.GetLifetimeFactory(instMode)); break; } } else { AddAssociation(key, tp, LifetimeFactories.GetLifetimeFactory(instMode)); } }, multiAttr); }
/// <summary> /// Removes the association from the container for the specified key /// </summary> /// <param name="key">Key</param> /// <returns>True if the association was presented in container</returns> protected sealed override bool RemoveAssociationInner(TKey key) { LifetimeBase tmp = null; return(_storage.TryRemove(key, out tmp)); }
/// <summary> /// Attempts to get the lifetime object container by its key /// </summary> /// <param name="key">Key</param> /// <param name="val">Associated lifetime container (null when key not exists)</param> /// <returns>True if the lifetime container for the speicifed key exists in AssociatnioContainer</returns> bool IAssociationSource <TKey> .TryGetAssociation(TKey key, out LifetimeBase val) { return(_storage.TryGetValue(key, out val)); }