private string GetConnectionName(IInjectionPoint injectionPoint)
{
return(injectionPoint.Qualifiers.OfType <EntityContextAttribute>()
.Select(x => x.ConnectionName)
.DefaultIfEmpty("Default")
.First());
}
public virtual DbContext GetContext(IInjectionPoint injectionPoint)
{
var connectionName = GetConnectionName(injectionPoint);
return(_contexts.GetOrAdd(connectionName, new CormoDbContext(connectionName,
_entityTypes.Select(x => GetEntityInfo(_manager, x)).ToArray())));
}
protected T GetCookieParam <T>(IInjectionPoint ip)
{
if (ip == null)
{
throw new InjectionException("CookieParam needs injection point");
}
var context = HttpContext.Current;
var converter = TypeDescriptor.GetConverter(typeof(T));
if (context == null || converter == null)
{
throw new UnsatisfiedDependencyException(ip);
}
var httpCookie = context.Request.Cookies.Get(GetCookieName(ip));
if (httpCookie == null)
{
return(GetDefaultValue <T>(ip));
}
var cookieValue = httpCookie.Value;
return((T)converter.ConvertFromString(cookieValue));
}
public IComponent GetComponent(IInjectionPoint injectionPoint)
{
var components = GetComponents(injectionPoint.ComponentType, injectionPoint.Qualifiers.ToArray()).ToArray();
ResolutionValidator.ValidateSingleResult(injectionPoint, components);
return(components.Single());
}
public UnsatisfiedDependencyException(IInjectionPoint inject) :
base(string.Format("Unsatisfied depdendency for {0}", inject))
{
Type = inject.ComponentType;
Qualifiers = inject.Qualifiers.ToArray();
InjectionPoint = inject;
}
protected T GetHeaderParam <T>(IInjectionPoint ip)
{
if (ip == null)
{
throw new InjectionException("HeaderParam needs injection point");
}
var context = HttpContext.Current;
var converter = TypeDescriptor.GetConverter(typeof(T));
if (context == null || converter == null)
{
throw new UnsatisfiedDependencyException(ip);
}
try
{
var header = context.Request.Headers.Get(GetHeaderName(ip));
if (header != null)
{
return((T)converter.ConvertFromString(header));
}
}
catch (Exception)
{
// TODO: LOG
}
return(GetDefaultValue <T>(ip));
}
private object GetReference(IInjectionPoint injectionPoint, IComponent component, ICreationalContext creationalContext, params Type[] proxyTypes)
{
var pushInjectionPoint = injectionPoint != null && injectionPoint.ComponentType != typeof(IInjectionPoint);
try
{
if (pushInjectionPoint)
{
_currentInjectionPoint.Push(injectionPoint);
}
if (proxyTypes.Any() && component.IsProxyRequired)
{
foreach (var proxyType in proxyTypes)
{
InjectionValidator.ValidateProxiable(proxyType, injectionPoint);
}
return(CormoProxyGenerator.CreateProxy(proxyTypes,
() =>
{
try
{
if (pushInjectionPoint)
{
_currentInjectionPoint.Push(injectionPoint);
}
return GetReference(injectionPoint, component, creationalContext, new Type[0]);
}
finally
{
if (pushInjectionPoint)
{
_currentInjectionPoint.Pop();
}
}
}));
}
var context = creationalContext as IWeldCreationalContext;
if (context != null)
{
var incompleteInstance = context.GetIncompleteInstance(component);
if (incompleteInstance != null)
{
return(incompleteInstance);
}
}
creationalContext = creationalContext.GetCreationalContext(component);
return(GetContext(component.Scope).Get(component, creationalContext));
}
finally
{
if (pushInjectionPoint)
{
_currentInjectionPoint.Pop();
}
}
}
public T GetValue <T>(IInjectionPoint injectionPoint, IInstance <IValueProvider> providers)
{
if (injectionPoint == null)
{
throw new InjectionException("Value needs injection point");
}
var converter = TypeDescriptor.GetConverter(typeof(T));
if (converter == null)
{
throw new UnsatisfiedDependencyException(injectionPoint);
}
var name = GetValueName(injectionPoint);
foreach (var provider in providers)
{
var value = provider.GetValue(name);
try
{
return((T)converter.ConvertFromString(value));
}
catch (Exception e)
{
// TODO log
}
}
return(GetDefaultValue <T>(injectionPoint));
}
public AmbiguousResolutionException(IInjectionPoint inject, IComponent[] registrations)
: base(ConstructMessage(inject, registrations))
{
InjectionPoint = inject;
Type = inject.ComponentType;
Qualifiers = inject.Qualifiers.ToArray();
Registrations = registrations;
}
public Instance(WeldComponentManager manager, IQualifier[] qualifiers, IWeldComponent[] components, ICreationalContext creationalContext)
{
_qualifiers = qualifiers;
_components = components;
_creationalContext = creationalContext;
_currentInjectionPoint = manager.GetService <CurrentInjectionPoint>();
_injectionPoint = _currentInjectionPoint.Peek();
}
public static void ValidateProxiable(Type type, IInjectionPoint injectionPoint)
{
var error = CheckProxiable(type);
if (error != null)
{
var message = Formatters.FormatUnproxiableType(injectionPoint, error);
throw new NonProxiableTypeException(type, message);
}
}
protected T GetDefaultValue <T>(IInjectionPoint ip)
{
var attrDefault = ip.Qualifiers.OfType <HeaderParamAttribute>().Select(x => x.Default).OfType <T>().ToArray();
if (attrDefault.Any())
{
return(attrDefault[0]);
}
return(default(T));
}
public static void ValidateSingleResult(IInjectionPoint injectionPoint, IComponent[] components)
{
if (components.Length > 1)
{
throw new AmbiguousResolutionException(injectionPoint, components.ToArray());
}
if (!components.Any())
{
throw new UnsatisfiedDependencyException(injectionPoint);
}
}
public object GetInjectableReference(IInjectionPoint injectionPoint, ICreationalContext creationalContext)
{
var proxyTypes = new [] { injectionPoint.ComponentType };
var weldIp = injectionPoint as IWeldInjetionPoint;
if (weldIp != null && weldIp.Unwraps)
{
proxyTypes = new Type[0];
}
return(GetReference(injectionPoint, injectionPoint.Component, creationalContext, proxyTypes));
}
protected string GetHeaderName(IInjectionPoint ip)
{
var attrName = ip.Qualifiers.OfType <HeaderParamAttribute>().Select(x => x.Name).SingleOrDefault();
if (string.IsNullOrEmpty(attrName))
{
var methodParam = ip as IMethodParameterInjectionPoint;
if (methodParam != null)
{
return(methodParam.ParameterInfo.Name);
}
return(ip.Member.Name);
}
return(attrName);
}
T GetQueryParam <T>(IInjectionPoint ip)
{
var context = HttpContext.Current;
var converter = TypeDescriptor.GetConverter(typeof(T));
if (context == null || converter == null)
{
throw new UnsatisfiedDependencyException(ip);
}
var name = GetQueryName(ip);
var value = context.Request.QueryString[name];
if (value == null)
{
return(default(T));
}
return((T)converter.ConvertFromString(value));
}
T GetRouteParam <T>(IInjectionPoint ip, HttpRequestMessage request)
{
if (ip == null)
{
throw new InjectionException("RouteParam needs injection point");
}
var converter = TypeDescriptor.GetConverter(typeof(T));
if (request == null || converter == null)
{
throw new UnsatisfiedDependencyException(ip);
}
var name = GetRouteName(ip);
var routeData = request.GetRouteData();
if (routeData == null)
{
throw new UnsatisfiedDependencyException(ip);
}
object value;
if (TryGetRouteValue(routeData, name, out value))
{
try
{
return((T)converter.ConvertFromString(value.ToString()));
}
catch (Exception e)
{
// TODO log
}
}
return(GetDefaultValue <T>(ip));
}
public static string FormatUnproxiableType(IInjectionPoint injectionPoint, string reason)
{
return(string.Format("Normal-scoped component must be proxyable, consider using IInstance<> instead. {0}Reason: {1}",
injectionPoint == null ? "" : "Injected at: " + injectionPoint + ". ",
reason));
}
public object GetReference(IInjectionPoint injectionPoint)
{
return(_componentManager.GetInjectableReference(injectionPoint, _creationalContext));
}
DbContext GetDbContext(DbContexts contexts, IInjectionPoint injectionPoint)
{
return(contexts.GetContext(injectionPoint));
}
public IDbSet <T> GetDbSet(DbContexts contexts, IInjectionPoint injectionPoint)
{
return(contexts.GetContext(injectionPoint).Set <T>());
}
public void Push(IInjectionPoint injectionPoint)
{
_injectionPoints.Value.Push(injectionPoint);
}
private static string ConstructMessage(IInjectionPoint inject, IEnumerable <IComponent> components)
{
return(string.Format("Ambiguous dependency for {0}. Possible dependencies [{1}]", inject,
string.Join(",", components)));
}
public static void ValidateProxiable(Type type, IInjectionPoint injectionPoint)
{
var error = _checkedProxyableTypes.GetOrAdd(type, _ =>
{
if (type.IsInterface /* || typeof (MulticastDelegate).IsAssignableFrom(type.BaseType) */)
{
return(null);
}
var builder = new StringBuilder();
if (type.IsValueType)
{
builder.Append("value type");
}
if (type.IsPrimitive)
{
builder.Append("primitive type");
}
if (type.IsSealed)
{
builder.Append("class is sealed");
}
if (!TypeUtils.HasAccessibleDefaultConstructor(type))
{
builder.Append("No public/protected parameterless constructor");
}
var sealedMembers = TypeUtils.GetSealedPublicMembers(type);
if (sealedMembers.Any())
{
builder.Append(
string.Format("These public members must be virtual: {0}",
string.Join(",/n", sealedMembers.Select(x => x.ToString()))));
}
var publicFields = TypeUtils.GetPublicFields(type);
if (publicFields.Any())
{
builder.Append(
string.Format("Must not have public fields: {0}",
string.Join(",/n", publicFields.Select(x => x.ToString()))));
}
if (builder.Length == 0)
{
return(null);
}
return(builder.ToString());
});
if (error != null)
{
var message = string.Format("Normal-scoped component must be proxyable, consider using IInstance<> instead. {0}Reason: {1}",
injectionPoint == null?"": "Injected at: " + injectionPoint + ".",
error);
throw new NonProxiableTypeException(type, message);
}
}
