/// <summary>
/// The get.
/// </summary>
/// <param name="serviceType">Type of the service.</param>
/// <param name="name">The name.</param>
/// <returns>
/// Resolved Type Reference.
/// </returns>
public static object TryGet(Type serviceType, string name = null)
{
Type service = serviceType;
if (Bindings.ContainsKey(service))
{
IBindingInfo binding = Resolve(serviceType, name);
if (binding != null)
{
try
{
object instance = binding.GetInstance();
if (instance != null)
{
return(instance);
}
}
catch
{
return(null);
}
}
}
return(null);
}
/// <summary>
/// Gets the instance.
/// </summary>
/// <param name="dependencyInfo">The binding info.</param>
/// <returns>
/// Instance of Dependency Object.
/// </returns>
/// <author>Anwar</author>
/// <date>11/10/2011</date>
public object GetInstance(IBindingInfo dependencyInfo)
{
object instance = null;
HttpContextBase context = contextFunc();
if (context != null && context.Session != null)
{
Dictionary <string, object> instanceCache = context.Session[IocConstants.LifetimeManagerKey] as Dictionary <string, object>
??
new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase);
if (instanceCache.ContainsKey(dependencyInfo.UniqueID))
{
instance = instanceCache[dependencyInfo.UniqueID];
}
else
{
instance = dependencyInfo.Instance();
instanceCache.Add(dependencyInfo.UniqueID, instance);
}
context.Session[IocConstants.LifetimeManagerKey] = instanceCache;
}
return(instance);
}
public ISchemaBuilder AddBinding(IBindingInfo binding)
{
if (binding == null)
{
throw new ArgumentNullException(nameof(binding));
}
if (!binding.IsValid())
{
// TODO : resources
throw new ArgumentException(
"binding is not valid",
nameof(binding));
}
if (!_bindingCompiler.CanHandle(binding))
{
// TODO : resources
throw new ArgumentException(
"cannot handle binding",
nameof(binding));
}
_bindingCompiler.AddBinding(binding);
return(this);
}
/// <summary>
/// The get.
/// </summary>
/// <param name="serviceType">Type of the service.</param>
/// <param name="name">The name.</param>
/// <returns>
/// Resolved Type Reference.
/// </returns>
public static object Get(Type serviceType, string name = null)
{
Type service = serviceType;
if (!Bindings.ContainsKey(service))
{
throw new ActivationException(
string.Format("No registration for type {0} could be found.", service.FullName));
}
IBindingInfo binding = Resolve(service, name);
if (binding == null)
{
throw new ActivationException(
string.Format("No registration for type {0} could be found.", service.FullName));
}
try
{
object instance = binding.GetInstance();
if (instance == null)
{
throw new ActivationException(
string.Format("The registered delegate for type {0} returned null.", service.FullName));
}
return(instance);
}
catch (Exception exception)
{
throw new ActivationException("Cannot Resolve type " + service.FullName, exception);
}
}
/// <summary>
/// The get.
/// </summary>
/// <typeparam name="TType">The type of the type.</typeparam>
/// <param name="name">The name.</param>
/// <returns>
/// Resolved Type Reference.
/// </returns>
public static TType TryGet <TType>(string name = null)
{
Type service = typeof(TType);
if (Bindings.ContainsKey(service))
{
IBindingInfo binding = Resolve <TType>(name);
if (binding != null)
{
try
{
object instance = binding.GetInstance();
if (instance != null)
{
return((TType)instance);
}
}
catch
{
return(default(TType));
}
}
}
return(default(TType));
}
/// -------------------------------------------------------------------------------------------------
/// <summary>
/// Removes the type from DI.
/// </summary>
/// <param name="service">
/// The service.
/// </param>
/// <param name="name">
/// The name.
/// </param>
/// -------------------------------------------------------------------------------------------------
public static void Remove(Type service, string name = null)
{
IBindingInfo existingBinding = Resolve(service, name);
if (existingBinding != null)
{
existingBinding.ReleaseInstance();
Bindings.Remove(service, existingBinding);
}
}
public void ReleaseInstance(IBindingInfo dependencyInfo)
{
if (this.CachedInstance != null)
{
IDisposable disposable = this.CachedInstance as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
}
/// <summary>
/// Binds the specified type.
/// </summary>
/// <param name="service">The service.</param>
/// <param name="name">The name.</param>
/// <returns>
/// Binding Info as a <see cref="IBindingInfo{T}"/>.
/// </returns>
public static IBindingInfo <object> Bind(Type service, string name = null)
{
IBindingInfo existingBinding = Resolve(service, name);
if (existingBinding == null)
{
BindingInfo <object> binding = new BindingInfo <object>(service, name);
Bindings.Add(service, binding);
existingBinding = binding;
}
return((IBindingInfo <object>)existingBinding);
}
/// <summary>
/// Binds the specified <typeparamref name="TType"/>.
/// </summary>
/// <typeparam name="TType">The type of the type.</typeparam>
/// <param name="name">The name.</param>
/// <returns>
/// Binding Info as a <see cref="IBindingInfo{T}"/>.
/// </returns>
public static IBindingInfo <TType> Bind <TType>(string name = null)
{
Type service = typeof(TType);
IBindingInfo existingBinding = Resolve <TType>(name);
if (existingBinding == null)
{
BindingInfo <TType> binding = new BindingInfo <TType>(name);
Bindings.Add(service, binding);
existingBinding = binding;
}
return((IBindingInfo <TType>)existingBinding);
}
public void AddBinding(IBindingInfo binding)
{
if (binding == null)
{
throw new ArgumentNullException(nameof(binding));
}
if (!CanHandle(binding))
{
throw new ArgumentException(
"The specified binding cannot be handled.",
nameof(binding));
}
_bindings.Add(binding);
}
public static void BindInstance(Type serviceType, Type implmentedType, string name, ILifetime lifetime, int?order = null)
{
MethodInfo bindInstanceMethod = MakeGenericBindMethod(serviceType);
MethodInfo implementInstanceMethod = MakeGenericToMethod(serviceType, implmentedType);
MethodCallExpression methodCallExpression = Expression.Call(bindInstanceMethod, new Expression[] { Expression.Constant(name, typeof(string)) });
Func <IBindingInfo> binder = Expression.Lambda <Func <IBindingInfo> >(methodCallExpression).Compile();
IBindingInfo binding = binder();
MethodInfo containsMethod = MakeGenericContainsMethod(serviceType);
MethodCallExpression containsCallExpression = Expression.Call(containsMethod, new Expression[] { Expression.Constant(name, typeof(string)) });
Func <bool> containsFunc = Expression.Lambda <Func <bool> >(containsCallExpression).Compile();
if (containsFunc())
{
if (order == null)
{
OrderAttribute priorityAttribute = implmentedType.GetCustomAttribute <OrderAttribute>();
int priority = priorityAttribute != null ? priorityAttribute.Value : int.MaxValue;
if (binding.Order.HasValue && priority < binding.Order.Value)
{
return;
}
binding.Order = priority;
}
else
{
binding.Order = order;
}
}
MethodCallExpression implementCallExpression = Expression.Call(Expression.Constant(binding), implementInstanceMethod);
Func <IBindingInfo> implementer = Expression.Lambda <Func <IBindingInfo> >(implementCallExpression).Compile();
binding = implementer();
binding.LifetimeManager = lifetime;
}
/// -------------------------------------------------------------------------------------------------
/// <summary>
/// Gets the instance.
/// </summary>
/// <param name="dependencyInfo">
/// Information describing the dependency.
/// </param>
/// <returns>
/// Instance of Dependency Object.
/// </returns>
/// -------------------------------------------------------------------------------------------------
public object GetInstance(IBindingInfo dependencyInfo)
{
if (Instances.Value.ContainsKey(dependencyInfo.Instance))
{
return(Instances.Value[dependencyInfo.Instance]);
}
lock (SyncLock.Value)
{
if (Instances.Value.ContainsKey(dependencyInfo.Instance))
{
return(Instances.Value[dependencyInfo.Instance]);
}
object instance = dependencyInfo.Instance();
Instances.Value.Add(dependencyInfo.Instance, instance);
return(instance);
}
}
/// <summary>
/// Dispose the instance if exists.
/// </summary>
/// <param name="dependencyInfo">The binding info.</param>
/// <author>Anwar</author>
/// <date>11/9/2011</date>
public void ReleaseInstance(IBindingInfo dependencyInfo)
{
HttpContextBase context = contextFunc();
if (context != null)
{
object instance = context.Items[dependencyInfo.UniqueID];
if (instance != null)
{
IDisposable disposable = instance as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
context.Items.Remove(dependencyInfo.UniqueID);
}
}
}
/// -------------------------------------------------------------------------------------------------
/// <summary>
/// Dispose the instance if exists.
/// </summary>
/// <param name="dependencyInfo">
/// Information describing the dependency.
/// </param>
/// -------------------------------------------------------------------------------------------------
public void ReleaseInstance(IBindingInfo dependencyInfo)
{
lock (SyncLock.Value)
{
if (Instances.Value.ContainsKey(dependencyInfo.Instance))
{
object instance = Instances.Value[dependencyInfo.Instance];
if (instance != null)
{
IDisposable disposable = instance as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
Instances.Value.Remove(dependencyInfo.Instance);
}
}
}
/// <summary>
/// Gets the instance.
/// </summary>
/// <param name="dependencyInfo">The binding info.</param>
/// <returns>
/// Instance of Dependency Object.
/// </returns>
/// <author>Anwar</author>
/// <date>11/9/2011</date>
public object GetInstance(IBindingInfo dependencyInfo)
{
object instance = null;
HttpContextBase context = contextFunc();
if (context != null)
{
instance = context.Items[dependencyInfo.UniqueID];
if (instance == null)
{
instance = dependencyInfo.Instance();
context.Items[dependencyInfo.UniqueID] = instance;
}
else
{
instance = null;
}
}
return(instance);
}
public ISchemaBuilder AddBinding(IBindingInfo binding)
{
if (binding == null)
{
throw new ArgumentNullException(nameof(binding));
}
if (!binding.IsValid())
{
throw new ArgumentException(
TypeResources.SchemaBuilder_Binding_Invalid,
nameof(binding));
}
if (!_bindingCompiler.CanHandle(binding))
{
throw new ArgumentException(
TypeResources.SchemaBuilder_Binding_CannotBeHandled,
nameof(binding));
}
_bindingCompiler.AddBinding(binding);
return(this);
}
public bool CanHandle(IBindingInfo binding)
{
return(binding != null &&
_supportedBindings.Contains(binding.GetType()));
}
private static void TestTwoWayBindingInfo(IBindingInfo<ModelTestClass, ControlTestClass, string, string> binding, ModelTestClass model, ControlTestClass control, ref int modelCount, ref int controlCount)
{
Assert.Equal(BindingMode.TwoWay, binding.Direction);
Assert.Equal("First", control.Text);
Assert.Equal(1, controlCount);
Assert.Equal(0, modelCount);
model.Text = 2.ToText();
Assert.Equal(1, modelCount);
Assert.Equal(2, controlCount);
Assert.Equal("Second", control.Text);
binding.Model = null;
model.Text = 3.ToText();
Assert.Equal(2, modelCount);
binding.Model = model;
Assert.Equal("Third", control.Text);
Assert.Equal(3, controlCount);
control.Text = "Forth";
Assert.Equal(4, controlCount);
Assert.Equal(3, modelCount);
Assert.Equal("Forth", model.Text);
}
private static void TestOneWayToSourceBindingInfo(IBindingInfo<ModelTestClass, ControlTestClass, string, string> binding, ModelTestClass model, ControlTestClass control, int[] modelCounts, int[] controlCounts)
{
Assert.Equal(BindingMode.OneWayToSource, binding.Direction);
Assert.Equal("First", model.Text);
Assert.Equal(0, controlCounts[0]);
Assert.Equal(1, modelCounts[0]);
control.Text = 2.ToText();
Assert.Equal(2, modelCounts[0]);
Assert.Equal(1, controlCounts[0]);
Assert.Equal("Second", model.Text);
binding.Model = null;
control.Text = 3.ToText();
Assert.Equal(2, controlCounts[0]);
binding.Model = model;
Assert.Equal("Third", model.Text);
Assert.Equal(3, modelCounts[0]);
Assert.Equal(2, controlCounts[0]);
model.Text = "Forth";
Assert.Equal(4, modelCounts[0]);
Assert.Equal(2, controlCounts[0]);
}
public object GetInstance(IBindingInfo dependencyInfo)
{
object instance = dependencyInfo.Instance();
return(instance);
}
public object GetInstance(IBindingInfo dependencyInfo)
{
return(this.CachedInstance ?? (this.CachedInstance = dependencyInfo.Instance()));
}
/// <summary>
/// Dispose the instance if exists.
/// </summary>
/// <param name="dependencyInfo">The binding info.</param>
/// <author>Anwar</author>
/// <date>11/10/2011</date>
public void ReleaseInstance(IBindingInfo dependencyInfo)
{
// Do Nothing
}
