public override IEnumerable <Expression> Express(ref PipelineBuilder builder)
{
#if NETSTANDARD1_0 || NETCOREAPP1_0
var typeInfo = builder.Type.GetTypeInfo();
#else
var typeInfo = builder.Type;
#endif
// Validate if Type could be created
if (typeInfo.IsInterface)
{
return(CannotConstructInterfaceExpr.Concat(builder.Express()));
}
if (typeInfo.IsAbstract)
{
return(CannotConstructAbstractClassExpr.Concat(builder.Express()));
}
if (typeInfo.IsSubclassOf(typeof(Delegate)))
{
return(CannotConstructDelegateExpr.Concat(builder.Express()));
}
if (typeof(string) == builder.Type)
{
return(TypeIsNotConstructableExpr.Concat(builder.Express()));
}
// Build expression as usual
return(base.Express(ref builder));
}
public override IEnumerable <Expression> Express(ref PipelineBuilder builder)
{
if (!builder.IsMapping)
{
return(builder.Express());
}
var requestedType = builder.Type;
if (null != builder.Registration)
{
// Explicit Registration
if (null == builder.Registration.Type)
{
return(builder.Express());
}
builder.Type = builder.Registration.Type;
}
else if (null != builder.TypeConverter)
{
builder.Type = builder.TypeConverter(builder.Type);
}
// If nothing to map or build required, just create it
if (builder.BuildRequired || requestedType == builder.Type)
{
return(builder.Express());
}
var type = builder.Type;
return(builder.Express((ref PipelineContext context) => context.Resolve(type)));
}
public override IEnumerable <Expression> Express(ref PipelineBuilder builder)
{
if (null != builder.SeedExpression)
{
return(builder.Express());
}
var expressions = builder.Express();
var selector = GetOrDefault(builder.Policies);
var members = selector.Invoke(builder.Type, builder.InjectionMembers);
return(expressions.Concat(ExpressionsFromSelection(builder.Type, members)));
}
public override IEnumerable <Expression> Express(ref PipelineBuilder builder)
{
// Skip if already have a resolver expression
if (null != builder.SeedExpression)
{
return(builder.Express());
}
var registration = builder.Registration as FactoryRegistration ??
builder.Factory as FactoryRegistration;
Debug.Assert(null != registration);
var factory = Expression.Constant(registration.Factory, typeof(Func <IUnityContainer, Type, string?, object?>));
var expression = Expression.Assign(PipelineContextExpression.Existing,
Expression.Invoke(factory, PipelineContextExpression.Container, PipelineContextExpression.Type, PipelineContextExpression.Name));
return(builder.Express(new[] { expression }));
}
public override IEnumerable <Expression> Express(ref PipelineBuilder builder)
{
var expressions = builder.Express();
return(builder.LifetimeManager switch
{
SynchronizedLifetimeManager manager => SynchronizedLifetimeExpression(manager, expressions),
PerResolveLifetimeManager _ => PerResolveLifetimeExpression(expressions),
_ => expressions
});
public override IEnumerable <Expression> Express(ref PipelineBuilder builder)
{
var expressions = builder.Express();
if (null != builder.SeedExpression)
{
return(expressions);
}
// Select ConstructorInfo
var selector = GetOrDefault(builder.Policies);
var selection = selector.Invoke(builder.Type, builder.InjectionMembers)
.FirstOrDefault();
// Select constructor for the Type
ConstructorInfo info;
object[]? resolvers = null;
switch (selection)
{
case ConstructorInfo memberInfo:
info = memberInfo;
break;
case MethodBase <ConstructorInfo> injectionMember:
info = injectionMember.MemberInfo(builder.Type);
resolvers = injectionMember.Data;
break;
case Exception exception:
return(new[] {
Expression.IfThen(NullEqualExisting, Expression.Throw(Expression.Constant(exception)))
}.Concat(expressions));
default:
return(NoConstructorExpr.Concat(expressions));
}
return(new[] { GetResolverExpression(info, resolvers, builder.LifetimeManager is PerResolveLifetimeManager) }.Concat(expressions));
}
public override IEnumerable <Expression> Express(ref PipelineBuilder builder)
{
var expressions = builder.Express();
var infoExpr = Expression.Condition(
Expression.Equal(Expression.Constant(null), PipelineContextExpression.Name),
Expression.Convert(PipelineContextExpression.Type, typeof(object)),
Expression.Convert(Expression.New(TupleConstructor, PipelineContextExpression.Type, PipelineContextExpression.Name), typeof(object)));
var filter = Expression.OrElse(
Expression.TypeIs(ExceptionExpr, typeof(InvalidRegistrationException)),
Expression.TypeIs(ExceptionExpr, typeof(CircularDependencyException)));
var tryBody = Expression.Block(expressions);
var catchBody = Expression.Block(tryBody.Type,
Expression.IfThen(filter, Expression.Call(ExceptionDataExpr, AddMethodInfo, Expression.Convert(CallNewGuidExpr, typeof(object)), infoExpr)),
Expression.Rethrow(tryBody.Type));
return(new Expression[]
{
Expression.Call(ValidateMethod, PipelineContextExpression.Parent, PipelineContextExpression.Type, PipelineContextExpression.Name),
Expression.TryCatch(tryBody, Expression.Catch(ExceptionExpr, catchBody))
});
}
public virtual IEnumerable <Expression> Express(ref PipelineBuilder builder) => builder.Express();
public override IEnumerable <Expression> Express(ref PipelineBuilder builder)
{
// Skip if already have a resolver expression
if (null != builder.SeedExpression)
{
return(builder.Express());
}
// Try to get resolver
Type?generic = null;
var resolver = builder.Policies?.Get(typeof(ResolveDelegate <PipelineContext>)) ??
builder.ContainerContext.Get(builder.Type, typeof(ResolveDelegate <PipelineContext>));
if (null == resolver)
{
#if NETCOREAPP1_0 || NETSTANDARD1_0
if (null != builder.Type && builder.Type.GetTypeInfo().IsGenericType)
#else
if (null != builder.Type && builder.Type.IsGenericType)
#endif
{
generic = builder.Type.GetGenericTypeDefinition();
resolver = builder.ContainerContext.Get(generic, typeof(ResolveDelegate <PipelineContext>));
}
}
// Create an expression from resolver
if (null != resolver)
{
return(builder.Express((ResolveDelegate <PipelineContext>)resolver));
}
// Try finding factory
TypeFactoryDelegate?factory = builder.Policies?.Get <TypeFactoryDelegate>();
#if NETCOREAPP1_0 || NETSTANDARD1_0
if (null != builder.Type && builder.Type.GetTypeInfo().IsGenericType)
#else
if (null != builder.Type && builder.Type.IsGenericType)
#endif
{
factory = (TypeFactoryDelegate?)builder.ContainerContext.Get(builder.Type.GetGenericTypeDefinition(),
typeof(TypeFactoryDelegate));
}
else if (null != builder.Type && builder.Type.IsArray)
{
if (builder.Type.GetArrayRank() == 1)
{
var resolve = ArrayResolver.Factory(builder.Type, builder.ContainerContext.Container);
return(builder.Express((ref PipelineContext context) => resolve(ref context)));
}
else
{
var message = $"Invalid array {builder.Type}. Only arrays of rank 1 are supported";
return(builder.Express((ref PipelineContext context) => throw new InvalidRegistrationException(message)));
}
}
Debug.Assert(null != builder.Type);
return(null != factory
? builder.Express(factory(builder.Type, builder.ContainerContext.Container))
: builder.Express());
}
