コード例 #1
0
        protected override object ResolveParameterValue(ParameterInfo parameterInfo, IRepositoryMethodParameters parameters, out Exception exception)
        {
            if (parameterInfo.ParameterType.IsAssignableFrom(typeof(IRepositoryMethodParameters)) ||
                //legacy repository method definition
                parameterInfo.ParameterType.IsAssignableFrom(typeof(IDictionary <string, string>)) &&
                parameterInfo.Name.StartsWith(LegacyParameterNameStartWith, StringComparison.Ordinal))
            {
                exception = null;
                return(parameters);
            }

            return(base.ResolveParameterValue(parameterInfo, parameters, out exception));
        }
コード例 #2
0
        protected virtual RepositoryMethodResolveInfo ResolveRepositoryMethod(
            string methodName, IRepositoryMethodParameters parameters)
        {
            RepositoryMethodResolveInfo res = null;

            foreach (var strategy in RepositoryMethodResolveStrategies)
            {
                res = strategy.Resolve(methodName, parameters);
                if (res != null)
                {
                    return(res);
                }
            }

            throw new Exception($"'{methodName}' repository method hasn't been found for the specified set of parameters.");
        }
コード例 #3
0
        public CallMethodResult Execute(string methodName, IRepositoryMethodParameters parameters = null)
        {
            object methodResult;
            var    resolveInfo = ResolveRepositoryMethod(methodName, parameters);

            try
            {
                methodResult = resolveInfo.Method.Invoke(resolveInfo.Instance, resolveInfo.Parameters);

                if (methodResult is Task task)
                {
                    methodResult = TaskReflectionHelper.WaitForTask(task);
                }
            }
            catch (TargetInvocationException ex) when(ex.InnerException != null)
            {
                try
                {
                    throw ex.InnerException;
                }
                catch (AggregateException e)
                {
                    throw e.Flatten();
                }
            }

            if (typeof(CallMethodResult).IsAssignableFrom(resolveInfo.Method.ReturnType))
            {
                return(methodResult as CallMethodResult);
            }

            return(new CallMethodResult
            {
                Result = methodResult,
                ResultType = resolveInfo.Method.ReturnType,
                ResultIsHandled = false
            });
        }
コード例 #4
0
        protected virtual object ResolveParameterValue(ParameterInfo parameterInfo, IRepositoryMethodParameters parameters, out Exception exception)
        {
            exception = null;
            try
            {
                if (!parameters.ContainsKey(parameterInfo.Name))
                {
                    if (parameterInfo.HasDefaultValue)
                    {
                        return(parameterInfo.DefaultValue);
                    }

                    throw new Exception($"'{parameterInfo.Name}' parameter has not been defined.");
                }

                return(parameters[parameterInfo.Name].SpecflowConvert(parameterInfo.ParameterType));
            }
            catch (Exception ex)
            {
                exception = ex;
            }

            return(null);
        }
コード例 #5
0
        public RepositoryMethodResolveInfo Resolve(string methodName, IRepositoryMethodParameters parameters)
        {
            if (parameters == null)
            {
                parameters = new RepositoryMethodParameters();
            }

            var methods = TypeOfInstance.GetMethods(MethodSearchBindingFlags);

            if (TypeOfInstance.IsInterface)
            {
                methods = methods
                          .Union(TypeOfInstance.GetInterfaces().SelectMany(x => x.GetMethods(MethodSearchBindingFlags)))
                          .ToArray();
            }

            methods = FilterByParameters(FilterByMethodName(methods, methodName), parameters).ToArray();

            if (!methods.Any())
            {
                return(null);
            }

            if (methods.Distinct(new MethodParameterNamesEqualityComparer()).Count() != methods.Length)
            {
                throw new Exception(
                          $"'{TypeOfInstance.Name}' type has ambiguous definitions of '{methodName}' method with the same names of parameters.");
            }

            var exceptions = new List <Exception>();

            foreach (var method in methods)
            {
                var methodParams    = method.GetParameters();
                var paramValues     = new List <object>();
                var paramsPopulated = true;
                foreach (var methodParam in methodParams)
                {
                    var value = ResolveParameterValue(methodParam, parameters, out var ex);
                    if (ex != null)
                    {
                        exceptions.Add(new Exception(
                                           $"Resolving of '{method.Name}' method with {methodParams.Length} parameters has been failed.",
                                           ex));
                        paramsPopulated = false;
                        break;
                    }

                    paramValues.Add(value);
                }

                if (paramsPopulated)
                {
                    return(new RepositoryMethodResolveInfo
                    {
                        Method = method,
                        Instance = Instance,
                        Parameters = paramValues.ToArray()
                    });
                }
            }

            if (exceptions.Any())
            {
                throw new AggregateException(
                          $"Resolving of '{methodName}' method of '{typeof(TInstance).Name}' type has thrown errors. See inner exceptions for more details.",
                          exceptions);
            }

            return(null);
        }
コード例 #6
0
 protected virtual IEnumerable <MethodInfo> FilterByParameters(IEnumerable <MethodInfo> methods, IRepositoryMethodParameters parameters)
 {
     return(methods.Where(m =>
     {
         var p = m.GetParameters();
         return !p.Any() && !parameters.Any() ||
         p.Any() && !p.Select(x => x.Name).Except(parameters.Select(x => x.Key)).Any();
     }));
 }
コード例 #7
0
        protected override IEnumerable <MethodInfo> FilterByParameters(IEnumerable <MethodInfo> methods, IRepositoryMethodParameters parameters)
        {
            var callResultMethods = methods.Where(m => typeof(CallMethodResult).IsAssignableFrom(m.ReturnType)).ToArray();
            var genericMethods    = callResultMethods.Where(m =>
            {
                var p = m.GetParameters();
                return(p.Length == 1 && (typeof(IRepositoryMethodParameters).IsAssignableFrom(p[0].ParameterType) ||
                                         //legacy repository method definition
                                         typeof(IDictionary <string, string>).IsAssignableFrom(p[0].ParameterType) &&
                                         p[0].Name.StartsWith(LegacyParameterNameStartWith, StringComparison.Ordinal)));
            }).ToArray();

            return(genericMethods.Union(base.FilterByParameters(callResultMethods.Except(genericMethods), parameters)));
        }