Пример #1
0
 internal async Task <T> EvalOnSelectorAllAsync <T>(bool isPageCall, string selector, string script, object args)
 => ScriptsHelper.ParseEvaluateResult <T>(await _channel.EvalOnSelectorAllAsync(
                                              selector: selector,
                                              script: script,
                                              isFunction: script.IsJavascriptFunction(),
                                              arg: ScriptsHelper.SerializedArgument(args),
                                              isPage: isPageCall).ConfigureAwait(false));
Пример #2
0
 internal async Task <JsonElement?> EvalOnSelectorAllAsync(bool isPageCall, string selector, string script)
 => ScriptsHelper.ParseEvaluateResult <JsonElement?>(await _channel.EvalOnSelectorAllAsync(
                                                         selector: selector,
                                                         script: script,
                                                         isFunction: script.IsJavascriptFunction(),
                                                         arg: EvaluateArgument.Undefined,
                                                         isPage: isPageCall).ConfigureAwait(false));
Пример #3
0
 internal async Task <T> EvaluateAsync <T>(bool isPageCall, string script, object args)
 => ScriptsHelper.ParseEvaluateResult <T>(await _channel.EvaluateExpressionAsync(
                                              script: script,
                                              isFunction: script.IsJavascriptFunction(),
                                              arg: args,
                                              isPage: isPageCall,
                                              serializeArgument: true).ConfigureAwait(false));
Пример #4
0
        internal async Task CallAsync(Delegate binding)
        {
            try
            {
                const string taskResultPropertyName = "Result";
                var          methodParams           = binding.Method.GetParameters().Select(parameter => parameter.ParameterType).Skip(1).ToArray();
                var          args = new List <object>
                {
                    new BindingSource
                    {
                        Context = _initializer?.Frame?.Page?.Context,
                        Page    = _initializer?.Frame?.Page,
                        Frame   = _initializer?.Frame,
                    },
                };

                if (methodParams.Length == 1 && methodParams[0] == typeof(IJSHandle))
                {
                    args.Add(_initializer.Handle.Object);
                }
                else
                {
                    for (int i = 0; i < methodParams.Length; i++)
                    {
                        args.Add(ScriptsHelper.ParseEvaluateResult(_initializer.Args[i], methodParams[i]));
                    }
                }

                object result = binding.DynamicInvoke(args.ToArray());

                if (result is Task taskResult)
                {
                    await taskResult.ConfigureAwait(false);

                    if (taskResult.GetType().IsGenericType)
                    {
                        // the task is already awaited and therefore the call to property Result will not deadlock
                        result = taskResult.GetType().GetProperty(taskResultPropertyName).GetValue(taskResult);
                    }
                }

                await _channel.ResolveAsync(result).ConfigureAwait(false);
            }
            catch (TargetInvocationException ex)
            {
                await _channel.RejectAsync(ex.InnerException).ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                await _channel.RejectAsync(ex).ConfigureAwait(false);
            }
        }
Пример #5
0
 /// <inheritdoc />
 public async Task <T> EvalOnSelectorAllAsync <T>(string selector, string expression, object arg)
 => ScriptsHelper.ParseEvaluateResult <T>(await _channel.EvalOnSelectorAllAsync(
                                              selector: selector,
                                              script: expression,
                                              isFunction: expression.IsJavascriptFunction(),
                                              arg: arg.ToEvaluateArgument()).ConfigureAwait(false));
Пример #6
0
 /// <inheritdoc />
 public async Task <T> JsonValueAsync <T>() => ScriptsHelper.ParseEvaluateResult <T>(await _channel.JsonValueAsync().ConfigureAwait(false));
Пример #7
0
 /// <inheritdoc />
 public async Task <JsonElement?> EvaluateAsync(string expression, object arg)
 => ScriptsHelper.ParseEvaluateResult <JsonElement?>(await _channel.EvaluateExpressionAsync(
                                                         script: expression,
                                                         isFunction: expression.IsJavascriptFunction(),
                                                         arg: ScriptsHelper.SerializedArgument(arg)).ConfigureAwait(false));
Пример #8
0
 internal async Task <T> EvaluateAsync <T>(bool isPageCall, string script)
 => ScriptsHelper.ParseEvaluateResult <T>(await _channel.EvaluateExpressionAsync(
                                              script: script,
                                              isFunction: script.IsJavascriptFunction(),
                                              arg: EvaluateArgument.Undefined,
                                              isPage: isPageCall).ConfigureAwait(false));