Pipeline

                options.FeignClientPipeline.Authorization(proxy =>
                {
                    return ("global", "asdasd");
                });

                options.FeignClientPipeline.Service("serviceId").UseBuildingRequest(context =>
                {
                    var fallbackFeignClient = context.FeignClient as IFallbackFeignClient<object>;
                    object fallback = fallbackFeignClient?.Fallback;
                    return Task.CompletedTask;
                });

                options.FeignClientPipeline.UseSendingRequest(context =>
                {
                    context.Terminate();  // 终止请求
                    return Task.CompletedTask;
                });

                options.FeignClientPipeline.UseFallbackRequest(context =>
                {
                    //服务发生降级时触发
                    object fallbackService = context.Fallback;
                    context.Terminate();//终止降级操作
                    return Task.CompletedTask;
                });

                options.FeignClientPipeline.UseInitializing(context =>
                {
                    //服务初始化时触发
                });

                options.FeignClientPipeline.UseDisposing(context =>
                {
                    //服务释放时触发
                });

                //添加授权
                options.FeignClientPipeline.Service("yun-platform-service-provider").Authorization(proxy =>
                {
                    return ("service", "asdasd");
                });

                options.FeignClientPipeline.UseReceivingResponse(context =>
                {
                    //响应数据时触发
                    return Task.CompletedTask;
                });

                options.FeignClientPipeline.UseReceivedResponse(context =>
                {
                    //响应数据后触发
                    return Task.CompletedTask;
                });

                //成功获取响应时触发,可以自己设置返回的Result
                options.FeignClientPipeline.UseReceivingResponse(async context =>
                {
                    if (!typeof(QueryResult).IsAssignableFrom(e.ResultType))
                    {
                        return;
                    }
                    if (context.ResultType == typeof(QueryResult))
                    {
                        context.Result = new QueryResult()
                        {
                            StatusCode = context.ResponseMessage.StatusCode
                        };
                        return;
                    }

                    if (context.ResultType.IsGenericType && context.ResultType.GetGenericTypeDefinition() == typeof(QueryResult<>))
                    {
                        QueryResult queryResult;
                        if (context.ResponseMessage.IsSuccessStatusCode)
                        {
                            string json = await context.ResponseMessage.Content.ReadAsStringAsync();
                            object data = Newtonsoft.Json.JsonConvert.DeserializeObject(json, e.ResultType.GetGenericArguments()[0]);
                            var constructor = context.ResultType.GetConstructor(new Type[] { typeof(object) });
                            queryResult = (QueryResult)constructor.Invoke(new object[] { data });
                        }
                        else
                        {
                            queryResult = (QueryResult)context.ResultType.GetConstructor(Type.EmptyTypes).Invoke(new object[0]);
                        }
                        queryResult.StatusCode = e.ResponseMessage.StatusCode;
                        context.Result = queryResult;
                    }

                });

                options.FeignClientPipeline.UseCancelRequest(context =>
                {
                    e.CancellationToken.Register((state) =>
                    {

                    }, sender);
                   return Task.CompletedTask;
                });

                options.FeignClientPipeline.UseErrorRequest(context =>
                {
                    Exception exception = e.Exception;
                    //e.ExceptionHandled = true;
                   return Task.CompletedTask;
                });