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()); }