Example #1
0
        public IConstructorParameters GenerateParameters(params object[] parameters)
        {
            ConstructorParameters constructor = new ConstructorParameters();

            foreach (object p in parameters)
            {
                constructor.Add(new ConstructorParameter()
                {
                    Type = TypeGetter.GetType(p), Value = p
                });
            }

            return(constructor);
        }
Example #2
0
        IConstructorParameter exec <T>(params object[] instances)
        {
            ConstructorParameters constructorParameters = new ConstructorParameters();

            foreach (object instance in instances)
            {
                constructorParameters.Add(new ConstructorParameter()
                {
                    Type = instance.GetType(), Value = instance
                });
            }

            IConstructorParameter result = new ConstructorParameterByTypeFinder().FindByType(constructorParameters, typeof(T));

            return(result);
        }
        IParameter[] exec(int parameters, params object[] instances)
        {
            ConstructorInfo ctor = typeof(Test1).GetConstructors().SingleOrDefault(x => x.GetParameters().Length == parameters);

            ConstructorParameters constructorParameters = new ConstructorParameters();

            foreach (object instance in instances)
            {
                constructorParameters.Add(new ConstructorParameter()
                {
                    Type = instance.GetType(), Value = instance
                });
            }

            IEnumerable <IParameter> generateParameters(ConstructorInfo info)
            {
                foreach (ParameterInfo parameterInfo in info.GetParameters())
                {
                    yield return(new ParameterBuilder()
                                 .AddType(parameterInfo.ParameterType)
                                 .AddDefaultValue(parameterInfo.DefaultValue)
                                 .HasDefaultValue(parameterInfo.HasDefaultValue)
                                 .Build());
                }
            }

            TypedMemberValueProvider       typedMemberValueProvider = new TypedMemberValueProvider();
            ConstructorParametersGenerator generator           = new ConstructorParametersGenerator(typedMemberValueProvider, new ConstructorParameterByTypeFinder(), new ServiceHasConstructorParametersChecker());
            IEnumerable <IParameter>       generatedParameters = generateParameters(ctor);

            foreach (IParameter parameter in generatedParameters)
            {
                Console.WriteLine($"{parameter.Type.FullName}:: {parameter.Value}");
            }

            IParameter[] result = generator.GenerateParameters(new Constructor()
            {
                Instance = ctor, Parameters = generatedParameters
            }, constructorParameters).ToArray();

            return(result);
        }
Example #4
0
        ConstructorInfo exec <T>(params object[] instances)
        {
            ConstructorParameters parameters = new ConstructorParameters();

            foreach (object instance in instances)
            {
                parameters.Add(new ConstructorParameter()
                {
                    Type  = instance.GetType(),
                    Value = instance
                });
            }

            ConstructorFinder finder = new ConstructorFinder();

            ConstructorInfo[]          allCtors  = typeof(T).GetConstructors();
            ConstructorListGenerator   generator = new ConstructorListGenerator(new ConstructorGenerator(new ParametersGenerator(new ParameterGenerator())));
            IEnumerable <IConstructor> ctors     = generator.GenerateList(allCtors);
            IConstructor ctor = finder.FindBy(ctors, parameters);

            return(ctor.Instance);
        }
 protected virtual void HandleAttribute(string name, string value)
 {
     ConstructorParameters.Add(name, value);
 }