1 {
 2   "GrpcService": {
 3     "IP": "localhost",
 4     "Port": "5031"
 5   },
 6   "HealthService": {
 7     "Name": "GrpcService",
 8     "IP": "localhost",
 9     "Port": "5021"
10   },
11   "ConsulService": {
12     "IP": "localhost",
13     "Port": "8500"
14   },
15   "Logging": {
16     "LogLevel": {
17       "Default": "Information",
18       "Microsoft": "Warning",
19       "Microsoft.Hosting.Lifetime": "Information"
20     }
21   },
22   "AllowedHosts": "*"
23 }

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Threading.Tasks;
 5 
 6 namespace Snai.GrpcService.Hosting.Consul.Entity
 7 {
 8     public class HealthService
 9     {
10         public string Name { get; set; }
11         public string IP { get; set; }
12         public int Port { get; set; }
13 
14     }
15 }

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Threading.Tasks;
 5 
 6 namespace Snai.GrpcService.Hosting.Consul.Entity
 7 {
 8     public class ConsulService
 9     {
10         public string IP { get; set; }
11         public int Port { get; set; }
12     }
13 }

 1 using Consul;
 2 using Microsoft.AspNetCore.Builder;
 3 using Microsoft.Extensions.Hosting;
 4 using Microsoft.Extensions.Options;
 5 using Snai.GrpcService.Hosting.Consul.Entity;
 6 using System;
 7 using System.Collections.Generic;
 8 using System.Linq;
 9 using System.Threading.Tasks;
10 
11 namespace Snai.GrpcService.Hosting.Consul
12 {
13     public static class AppRregister
14     {
15         // 服务注册
16         public static IApplicationBuilder RegisterConsul(this IApplicationBuilder app, IHostApplicationLifetime lifetime, IOptions<HealthService> healthService, IOptions<ConsulService> consulService)
17         {
18             var consulClient = new ConsulClient(cfg => cfg.Address = new Uri($"http://{consulService.Value.IP}:{consulService.Value.Port}"));//请求注册的 Consul 地址
19             var httpCheck = new AgentServiceCheck()
20             {
21                 DeregisterCriticalServiceAfter = TimeSpan.FromSeconds(5),//服务启动多久后注册
22                 Interval = TimeSpan.FromSeconds(10),//健康检查时间间隔，或者称为心跳间隔
23                 HTTP = $"http://{healthService.Value.IP}:{healthService.Value.Port}/health",//健康检查地址
24                 Timeout = TimeSpan.FromSeconds(5)
25             };
26 
27             // Register service with consul
28             var registration = new AgentServiceRegistration()
29             {
30                 Checks = new[] { httpCheck },
31                 ID = healthService.Value.Name + "_" + healthService.Value.Port,
32                 Name = healthService.Value.Name,
33                 Address = healthService.Value.IP,
34                 Port = healthService.Value.Port,
35                 Tags = new[] { $"urlprefix-/{healthService.Value.Name}" }//添加 urlprefix-/servicename 格式的 tag 标签，以便 Fabio 识别
36             };
37 
38             consulClient.Agent.ServiceRegister(registration).Wait();//服务启动时注册，内部实现其实就是使用 Consul API 进行注册（HttpClient发起）
39             lifetime.ApplicationStopping.Register(() =>
40             {
41                 consulClient.Agent.ServiceDeregister(registration.ID).Wait();//服务停止时取消注册
42             });
43 
44             return app;
45         }
46     }
47 }

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Threading.Tasks;
 5 using Microsoft.AspNetCore.Builder;
 6 using Microsoft.AspNetCore.Hosting;
 7 using Microsoft.AspNetCore.Http;
 8 using Microsoft.AspNetCore.HttpsPolicy;
 9 using Microsoft.Extensions.Configuration;
10 using Microsoft.Extensions.DependencyInjection;
11 using Microsoft.Extensions.Hosting;
12 using Microsoft.Extensions.Options;
13 using Snai.GrpcService.Hosting.Consul;
14 using Snai.GrpcService.Hosting.Consul.Entity;
15 
16 namespace Snai.GrpcService.Hosting
17 {
18     public class Startup
19     {
20         public Startup(IConfiguration configuration)
21         {
22             Configuration = configuration;
23         }
24 
25         public IConfiguration Configuration { get; }
26 
27         // This method gets called by the runtime. Use this method to add services to the container.
28         public void ConfigureServices(IServiceCollection services)
29         {
30             //注册全局配置
31             services.AddOptions();
32             services.Configure<Impl.Entity.GrpcService>(Configuration.GetSection(nameof(Impl.Entity.GrpcService)));
33             services.Configure<HealthService>(Configuration.GetSection(nameof(HealthService)));
34             services.Configure<ConsulService>(Configuration.GetSection(nameof(ConsulService)));
35 
36             //注册Rpc服务
37             services.AddSingleton<IRpcConfig, RpcConfig>();
38         }
39 
40         // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
41         public void Configure(IApplicationBuilder app, IWebHostEnvironment env, IHostApplicationLifetime lifetime, IOptions<HealthService> healthService, IOptions<ConsulService> consulService, IRpcConfig rpc)
42         {
43             if (env.IsDevelopment())
44             {
45                 app.UseDeveloperExceptionPage();
46             }
47 
48             // 添加健康检查路由地址
49             app.Map("/health", HealthMap);
50 
51             // 服务注册
52             app.RegisterConsul(lifetime, healthService, consulService);
53 
54             // 启动Rpc服务
55             rpc.Start();
56         }
57 
58         private static void HealthMap(IApplicationBuilder app)
59         {
60             app.Run(async context =>
61             {
62                 await context.Response.WriteAsync("OK");
63             });
64         }
65     }
66 }

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Threading.Tasks;
 5 using Microsoft.AspNetCore.Hosting;
 6 using Microsoft.Extensions.Configuration;
 7 using Microsoft.Extensions.Hosting;
 8 using Microsoft.Extensions.Logging;
 9 
10 namespace Snai.GrpcService.Hosting
11 {
12     public class Program
13     {
14         public static void Main(string[] args)
15         {
16             CreateHostBuilder(args).Build().Run();
17         }
18 
19         public static IHostBuilder CreateHostBuilder(string[] args) =>
20             Host.CreateDefaultBuilder(args)
21                 .ConfigureWebHostDefaults(webBuilder =>
22                 {
23                     webBuilder.UseUrls("http://localhost:5021");
24                     webBuilder.UseStartup<Startup>();
25                 });
26     }
27 }

syntax = "proto3";

package Snai.GrpcService.Protocol;

service MsgService{
  rpc GetSum(GetMsgNumRequest) returns (GetMsgSumReply){}
}

message GetMsgNumRequest {
  int32 Num1 = 1;
  int32 Num2 = 2;
}

message GetMsgSumReply {
  int32 Sum = 1;
}

1   <ItemGroup>
2     <Protobuf Include="Protos/*.proto" OutputDir="%(RelativeDir)" CompileOutputs="false" />
3   </ItemGroup>

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Text;
 4 
 5 namespace Snai.GrpcService.Impl.Entity
 6 {
 7     public class GrpcService
 8     {
 9         public string IP { get; set; }
10         public int Port { get; set; }
11     }
12 }

 1 using Grpc.Core;
 2 using Snai.GrpcService.Protocol;
 3 using System;
 4 using System.Collections.Generic;
 5 using System.Text;
 6 using System.Threading.Tasks;
 7 
 8 namespace Snai.GrpcService.Impl.RpcService
 9 {
10     public class MsgServiceImpl:MsgService.MsgServiceBase
11     {
12         public override Task<GetMsgSumReply> GetSum(GetMsgNumRequest request, ServerCallContext context)
13         {
14             var result = new GetMsgSumReply();
15 
16             result.Sum = request.Num1 + request.Num2;
17 
18             Console.WriteLine(request.Num1 + "+" + request.Num2 + "=" + result.Sum);
19 
20             return Task.FromResult(result);
21         }
22     }
23 }

1 using System;
2 
3 namespace Snai.GrpcService.Impl
4 {
5     public interface IRpcConfig
6     {
7         void Start();
8     }
9 }

 1 using Grpc.Core;
 2 using Microsoft.Extensions.Options;
 3 using Snai.GrpcService.Impl.RpcService;
 4 using Snai.GrpcService.Protocol;
 5 using System;
 6 using System.Collections.Generic;
 7 using System.Text;
 8 
 9 namespace Snai.GrpcService.Impl
10 {
11     public class RpcConfig : IRpcConfig
12     {
13         private static Server _server;
14         private static IOptions<Entity.GrpcService> _grpcSettings;
15 
16         public RpcConfig(IOptions<Entity.GrpcService> grpcSettings)
17         {
18             _grpcSettings = grpcSettings;
19         }
20         public void Start()
21         {
22             _server = new Server
23             {
24                 Services = { MsgService.BindService(new MsgServiceImpl()) },
25                 Ports = { new ServerPort(_grpcSettings.Value.IP, _grpcSettings.Value.Port, ServerCredentials.Insecure) }
26             };
27             _server.Start();
28 
29             Console.WriteLine($"Grpc ServerListening On Port {_grpcSettings.Value.Port}");
30         }
31     }
32 }

consul agent -server -datacenter=grpc-consul -bootstrap -data-dir ./data -ui -node=grpc-consul1 -bind 本机IP -client=0.0.0.0

  1 using System;
  2 using System.Collections.Generic;
  3 using System.Net.Http;
  4 using System.Text;
  5 using System.Threading.Tasks;
  6 
  7 /// <summary>
  8 /// 参考 pudefu https://www.cnblogs.com/pudefu/p/7581956.html ，在此表示感谢
  9 /// </summary>
 10 namespace Snai.GrpcClient.Utils
 11 {
 12     public class HttpHelper
 13     {
 14         /// <summary>
 15         /// 同步GET请求
 16         /// </summary>
 17         /// <param name="url"></param>
 18         /// <param name="headers"></param>
 19         /// <param name="timeout">请求响应超时时间，单位/s(默认100秒)</param>
 20         /// <returns></returns>
 21         public static string HttpGet(string url, Dictionary<string, string> headers = null, int timeout = 0)
 22         {
 23             using (HttpClient client = new HttpClient())
 24             {
 25                 if (headers != null)
 26                 {
 27                     foreach (KeyValuePair<string, string> header in headers)
 28                     {
 29                         client.DefaultRequestHeaders.Add(header.Key, header.Value);
 30                     }
 31                 }
 32                 if (timeout > 0)
 33                 {
 34                     client.Timeout = new TimeSpan(0, 0, timeout);
 35                 }
 36                 Byte[] resultBytes = client.GetByteArrayAsync(url).Result;
 37                 return Encoding.UTF8.GetString(resultBytes);
 38             }
 39         }
 40 
 41         /// <summary>
 42         /// 异步GET请求
 43         /// </summary>
 44         /// <param name="url"></param>
 45         /// <param name="headers"></param>
 46         /// <param name="timeout">请求响应超时时间，单位/s(默认100秒)</param>
 47         /// <returns></returns>
 48         public static async Task<string> HttpGetAsync(string url, Dictionary<string, string> headers = null, int timeout = 0)
 49         {
 50             using (HttpClient client = new HttpClient())
 51             {
 52                 if (headers != null)
 53                 {
 54                     foreach (KeyValuePair<string, string> header in headers)
 55                     {
 56                         client.DefaultRequestHeaders.Add(header.Key, header.Value);
 57                     }
 58                 }
 59                 if (timeout > 0)
 60                 {
 61                     client.Timeout = new TimeSpan(0, 0, timeout);
 62                 }
 63                 Byte[] resultBytes = await client.GetByteArrayAsync(url);
 64                 return Encoding.Default.GetString(resultBytes);
 65             }
 66         }
 67 
 68 
 69         /// <summary>
 70         /// 同步POST请求
 71         /// </summary>
 72         /// <param name="url"></param>
 73         /// <param name="postData"></param>
 74         /// <param name="headers"></param>
 75         /// <param name="contentType"></param>
 76         /// <param name="timeout">请求响应超时时间，单位/s(默认100秒)</param>
 77         /// <param name="encoding">默认UTF8</param>
 78         /// <returns></returns>
 79         public static string HttpPost(string url, string postData, Dictionary<string, string> headers = null, string contentType = null, int timeout = 0, Encoding encoding = null)
 80         {
 81             using (HttpClient client = new HttpClient())
 82             {
 83                 if (headers != null)
 84                 {
 85                     foreach (KeyValuePair<string, string> header in headers)
 86                     {
 87                         client.DefaultRequestHeaders.Add(header.Key, header.Value);
 88                     }
 89                 }
 90                 if (timeout > 0)
 91                 {
 92                     client.Timeout = new TimeSpan(0, 0, timeout);
 93                 }
 94                 using (HttpContent content = new StringContent(postData ?? "", encoding ?? Encoding.UTF8))
 95                 {
 96                     if (contentType != null)
 97                     {
 98                         content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue(contentType);
 99                     }
100                     using (HttpResponseMessage responseMessage = client.PostAsync(url, content).Result)
101                     {
102                         Byte[] resultBytes = responseMessage.Content.ReadAsByteArrayAsync().Result;
103                         return Encoding.UTF8.GetString(resultBytes);
104                     }
105                 }
106             }
107         }
108 
109         /// <summary>
110         /// 异步POST请求
111         /// </summary>
112         /// <param name="url"></param>
113         /// <param name="postData"></param>
114         /// <param name="headers"></param>
115         /// <param name="contentType"></param>
116         /// <param name="timeout">请求响应超时时间，单位/s(默认100秒)</param>
117         /// <param name="encoding">默认UTF8</param>
118         /// <returns></returns>
119         public static async Task<string> HttpPostAsync(string url, string postData, Dictionary<string, string> headers = null, string contentType = null, int timeout = 0, Encoding encoding = null)
120         {
121             using (HttpClient client = new HttpClient())
122             {
123                 if (headers != null)
124                 {
125                     foreach (KeyValuePair<string, string> header in headers)
126                     {
127                         client.DefaultRequestHeaders.Add(header.Key, header.Value);
128                     }
129                 }
130                 if (timeout > 0)
131                 {
132                     client.Timeout = new TimeSpan(0, 0, timeout);
133                 }
134                 using (HttpContent content = new StringContent(postData ?? "", encoding ?? Encoding.UTF8))
135                 {
136                     if (contentType != null)
137                     {
138                         content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue(contentType);
139                     }
140                     using (HttpResponseMessage responseMessage = await client.PostAsync(url, content))
141                     {
142                         Byte[] resultBytes = await responseMessage.Content.ReadAsByteArrayAsync();
143                         return Encoding.UTF8.GetString(resultBytes);
144                     }
145                 }
146             }
147         }
148     }
149 }

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Text;
 4 
 5 namespace Snai.GrpcClient.Consul.Entity
 6 {
 7     public class HealthCheck
 8     {
 9         public string Node { get; set; }
10         public string CheckID { get; set; }
11         public string Name { get; set; }
12         public string Status { get; set; }
13         public string Notes { get; set; }
14         public string Output { get; set; }
15         public string ServiceID { get; set; }
16         public string ServiceName { get; set; }
17         public string[] ServiceTags { get; set; }
18         public dynamic Definition { get; set; }
19         public int CreateIndex { get; set; }
20         public int ModifyIndex { get; set; }
21     }
22 }

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Text;
 4 
 5 namespace Snai.GrpcClient.Framework.Entity
 6 {
 7     public class ConsulService
 8     {
 9         public string IP { get; set; }
10         public int Port { get; set; }
11     }
12 }

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Text;
 4 
 5 namespace Snai.GrpcClient.Framework.Entity
 6 {
 7     public class GrpcServiceSettings
 8     {
 9         public List<GrpcService> GrpcServices { get; set; }
10     }
11     public class GrpcService
12     {
13         public string ServiceName { get; set; }
14         public string ServiceID { get; set; }
15         public string IP { get; set; }
16         public int Port { get; set; }
17         public int Weight { get; set; }
18     }
19 }

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Text;
 4 
 5 namespace Snai.GrpcClient.Consul
 6 {
 7     public interface IAppFind
 8     {
 9         IEnumerable<string> FindConsul(string ServiceName);
10     }
11 }

 1 using Microsoft.Extensions.Options;
 2 using Newtonsoft.Json;
 3 using Snai.GrpcClient.Consul.Entity;
 4 using Snai.GrpcClient.Framework.Entity;
 5 using Snai.GrpcClient.Utils;
 6 using System;
 7 using System.Collections.Generic;
 8 using System.Linq;
 9 using System.Text;
10 
11 namespace Snai.GrpcClient.Consul
12 {
13     /// <summary>
14     /// 服务发现
15     /// (服务和健康信息)http://localhost:8500/v1/health/service/GrpcService
16     /// (健康信息)http://localhost:8500/v1/health/checks/GrpcService
17     /// </summary>
18     public class AppFind : IAppFind
19     {
20         private static IOptions<GrpcServiceSettings> _grpcSettings;
21         private static IOptions<ConsulService> _consulSettings;
22         public AppFind(IOptions<GrpcServiceSettings> grpcSettings, IOptions<ConsulService> consulSettings)
23         {
24             _grpcSettings = grpcSettings;
25             _consulSettings = consulSettings;
26         }
27         public IEnumerable<string> FindConsul(string ServiceName)
28         {
29             Dictionary<string, string> headers = new Dictionary<string, string>();
30 
31             var consul = _consulSettings.Value;
32             string findUrl = $"http://{consul.IP}:{consul.Port}/v1/health/checks/{ServiceName}";
33 
34             string findResult = HttpHelper.HttpGet(findUrl, headers, 5);
35             if (findResult.Equals(""))
36             {
37                 var grpcServices = _grpcSettings.Value.GrpcServices;
38                 return grpcServices.Where(g => g.ServiceName.Equals(ServiceName, StringComparison.CurrentCultureIgnoreCase)).Select(s => s.ServiceID);
39             }
40 
41             var findCheck = JsonConvert.DeserializeObject<List<HealthCheck>>(findResult);
42 
43             return findCheck.Where(g => g.Status.Equals("passing", StringComparison.CurrentCultureIgnoreCase)).Select(g => g.ServiceID);
44         }
45     }
46 }

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Text;
 4 
 5 namespace Snai.GrpcClient.LoadBalance
 6 {
 7     public interface ILoadBalance
 8     {
 9         string GetGrpcService(string ServiceName);
10     }
11 }

 1 using Microsoft.Extensions.Options;
 2 using Snai.GrpcClient.Consul;
 3 using Snai.GrpcClient.Framework.Entity;
 4 using System;
 5 using System.Collections.Generic;
 6 using System.Linq;
 7 using System.Text;
 8 
 9 namespace Snai.GrpcClient.LoadBalance
10 {
11     /// <summary>
12     /// 权重轮询
13     /// </summary>
14     public class WeightRoundBalance: ILoadBalance
15     {
16         int Balance;
17         IOptions<GrpcServiceSettings> GrpcSettings;
18         IAppFind AppFind;
19 
20         public WeightRoundBalance(IOptions<GrpcServiceSettings> grpcSettings, IAppFind appFind)
21         {
22             Balance = 0;
23             GrpcSettings = grpcSettings;
24             AppFind = appFind;
25         }
26 
27         public string GetGrpcService(string ServiceName)
28         {
29             var grpcServices = GrpcSettings.Value.GrpcServices;
30 
31             var healthServiceID = AppFind.FindConsul(ServiceName);
32 
33             if (grpcServices == null || grpcServices.Count() == 0 || healthServiceID == null || healthServiceID.Count() == 0)
34             {
35                 return "";
36             }
37 
38             //健康的服务
39             var healthServices = new List<Framework.Entity.GrpcService>();
40 
41             foreach (var service in grpcServices)
42             {
43                 foreach (var health in healthServiceID)
44                 {
45                     if (service.ServiceID.Equals(health, StringComparison.CurrentCultureIgnoreCase))
46                     {
47                         healthServices.Add(service);
48                         break;
49                     }
50                 }
51             }
52 
53             if (healthServices == null || healthServices.Count() == 0)
54             {
55                 return "";
56             }
57 
58             //加权轮询
59             var services = new List<string>();
60 
61             foreach (var service in healthServices)
62             {
63                 services.AddRange(Enumerable.Repeat(service.IP + ":" + service.Port, service.Weight));
64             }
65 
66             var servicesArray = services.ToArray();
67 
68             Balance = Balance % servicesArray.Length;
69             var grpcUrl = servicesArray[Balance];
70             Balance = Balance + 1;
71 
72             return grpcUrl;
73         }
74     }
75 }

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Text;
 4 
 5 namespace Snai.GrpcClient.RpcClient
 6 {
 7     public interface IMsgClient
 8     {
 9         void GetSum(int num1, int num2);
10     }
11 }

 1 using Grpc.Core;
 2 using Snai.GrpcClient.LoadBalance;
 3 using Snai.GrpcService.Protocol;
 4 using System;
 5 using System.Collections.Generic;
 6 using System.Text;
 7 
 8 namespace Snai.GrpcClient.RpcClient
 9 {
10     public class MsgClient:IMsgClient
11     {
12         ILoadBalance LoadBalance;
13         Channel GrpcChannel;
14         MsgService.MsgServiceClient GrpcClient;
15 
16         public MsgClient(ILoadBalance loadBalance)
17         {
18             LoadBalance = loadBalance;
19 
20             var grpcUrl = LoadBalance.GetGrpcService("GrpcService");
21 
22             if (!grpcUrl.Equals(""))
23             {
24                 Console.WriteLine($"Grpc Service:{grpcUrl}");
25 
26                 GrpcChannel = new Channel(grpcUrl, ChannelCredentials.Insecure);
27                 GrpcClient = new MsgService.MsgServiceClient(GrpcChannel);
28             }
29         }
30 
31         public void GetSum(int num1, int num2)
32         {
33             if (GrpcClient != null)
34             {
35                 GetMsgSumReply msgSum = GrpcClient.GetSum(new GetMsgNumRequest
36                 {
37                     Num1 = num1,
38                     Num2 = num2
39                 });
40 
41                 Console.WriteLine("Grpc Client Call GetSum():" + msgSum.Sum);
42             }
43             else
44             {
45                 Console.WriteLine("所有负载都挂掉了！");
46             }
47         }
48     }
49 }

 1 using Microsoft.Extensions.Configuration;
 2 using Microsoft.Extensions.DependencyInjection;
 3 using Snai.GrpcClient.Consul;
 4 using Snai.GrpcClient.Framework.Entity;
 5 using Snai.GrpcClient.LoadBalance;
 6 using Snai.GrpcClient.RpcClient;
 7 using System;
 8 using System.Collections.Generic;
 9 using System.IO;
10 using System.Text;
11 
12 namespace Snai.GrpcClient.Framework
13 {
14     /// <summary>
15     /// IServiceCollection 依赖注入生命周期
16     /// AddTransient 每次都是全新的
17     /// AddScoped    在一个范围之内只有同一个实例(同一个线程,同一个浏览器请求只有一个实例)
18     /// AddSingleton 单例
19     /// </summary>
20     public static class DependencyInitialize
21     {
22         /// <summary>
23         /// 注册对象
24         /// </summary>
25         /// <param name="services">The services.</param>
26         /*
27          * IAppFind AppFind;
28          * 构造函数注入使用 IAppFind appFind
29          * AppFind = appFind;
30          */
31         public static void AddImplement(this IServiceCollection services)
32         {
33             //添加 json 文件路径
34             var builder = new ConfigurationBuilder().SetBasePath(Directory.GetCurrentDirectory()).AddJsonFile("appsettings.json");
35             //创建配置根对象
36             var configurationRoot = builder.Build();
37 
38             //注册全局配置
39             services.AddConfigImplement(configurationRoot);
40 
41             //注册服务发现
42             services.AddScoped<IAppFind, AppFind>();
43 
44             //注册负载均衡
45             if (configurationRoot["LoadBalancer"].Equals("WeightRound", StringComparison.CurrentCultureIgnoreCase))
46             {
47                 services.AddSingleton<ILoadBalance, WeightRoundBalance>();
48             }
49 
50             //注册Rpc客户端
51             services.AddTransient<IMsgClient, MsgClient>();
52         }
53 
54         /// <summary>
55         /// 注册全局配置
56         /// </summary>
57         /// <param name="services">The services.</param>
58         /// <param name="configurationRoot">The configurationRoot.</param>
59         /*  
60          *  IOptions<GrpcServiceSettings> GrpcSettings;
61          *  构造函数注入使用 IOptions<GrpcServiceSettings> grpcSettings
62          *  GrpcSettings = grpcSettings;
63          */
64         public static void AddConfigImplement(this IServiceCollection services, IConfigurationRoot configurationRoot)
65         {
66             //注册配置对象
67             services.AddOptions();
68             services.Configure<GrpcServiceSettings>(configurationRoot.GetSection(nameof(GrpcServiceSettings)));
69             services.Configure<ConsulService>(configurationRoot.GetSection(nameof(ConsulService)));
70         }
71     }
72 }

 1 {
 2   "GrpcServiceSettings": {
 3     "GrpcServices": [
 4       {
 5         "ServiceName": "GrpcService",
 6         "ServiceID": "GrpcService_5021",
 7         "IP": "localhost",
 8         "Port": "5031",
 9         "Weight": "2"
10       },
11       {
12         "ServiceName": "GrpcService",
13         "ServiceID": "GrpcService_5022",
14         "IP": "localhost",
15         "Port": "5032",
16         "Weight": "1"
17       }
18     ]
19   },
20   "LoadBalancer": "WeightRound",
21   "ConsulService": {
22     "IP": "localhost",
23     "Port": "8500"
24   }
25 }

 1 using Microsoft.Extensions.DependencyInjection;
 2 using Snai.GrpcClient.Framework;
 3 using Snai.GrpcClient.RpcClient;
 4 using System;
 5 
 6 namespace Snai.GrpcClient
 7 {
 8     class Program
 9     {
10         static void Main(string[] args)
11         {
12             IServiceCollection service = new ServiceCollection();
13 
14             //注册对象
15             service.AddImplement();
16 
17             //注入使用对象
18             var provider = service.BuildServiceProvider();
19 
20             string exeArg = string.Empty;
21             Console.WriteLine("Grpc调用!");
22             Console.WriteLine("-c\t调用Grpc服务;");
23             Console.WriteLine("-q\t退出服务;");
24 
25             while (true)
26             {
27                 exeArg = Console.ReadKey().KeyChar.ToString();
28                 Console.WriteLine();
29 
30                 if (exeArg.ToLower().Equals("c", StringComparison.CurrentCultureIgnoreCase))
31                 {
32                     //调用服务
33                     var rpcClient = provider.GetService<IMsgClient>();
34                     rpcClient.GetSum(10, 2);
35                 }
36                 else if (exeArg.ToLower().Equals("q", StringComparison.CurrentCultureIgnoreCase))
37                 {
38                     break;
39                 }
40                 else
41                 {
42                     Console.WriteLine("参数异常!");
43                 }
44             }
45         }
46     }
47 }

public static class AppBuilderExtensions
    {
        public static IApplicationBuilder RegisterConsul(this IApplicationBuilder app,IApplicationLifetime lifetime,ServiceEntity serviceEntity)
        {
            var consulClient = new ConsulClient(x => x.Address = new Uri($"http://{serviceEntity.ConsulIP}:{serviceEntity.ConsulPort}"));//请求注册的Consul地址
            var httpCheck = new AgentServiceCheck()
            {
                DeregisterCriticalServiceAfter=TimeSpan.FromSeconds(5),//服务启动多久后注册
                Interval=TimeSpan.FromSeconds(10),//健康检查时间间隔，或者成为心跳间隔
                HTTP=$"http://{serviceEntity.IP}:{serviceEntity.Port}/api/health",//健康检查地址
                Timeout=TimeSpan.FromSeconds(5)
            };

            //Register service with consul
            var registration = new AgentServiceRegistration()
            {
                Checks = new[] {httpCheck},
                ID=Guid.NewGuid().ToString(),
                Name=serviceEntity.ServiceName,
                Address=serviceEntity.IP,
                Port=serviceEntity.Port,
                Tags = new[] { $"urlprefix-/{serviceEntity.ServiceName}"} //添加urlprefix-/servicename格式的tag标签，以便Fabio识别
            };

            consulClient.Agent.ServiceRegister(registration).Wait();//服务启动时注册，内部实现其实就是使用Consul API进行注册（HttpClient发起)
            lifetime.ApplicationStopping.Register(() =>
            {
                consulClient.Agent.ServiceDeregister(registration.ID).Wait();//服务停止时取消注册
            });

            return app;
        }
    }

    public class ServiceEntity
    {
        public string IP { get; set; }
        public int Port { get; set; }
        public string ServiceName { get; set; }
        public string ConsulIP { get; set; }
        public int ConsulPort { get; set; }
    }

public void Configure(IApplicationBuilder app, IHostingEnvironment env, IApplicationLifetime lifetime)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            #region Consul 服务注册
            ServiceEntity serviceEntity = new ServiceEntity
            {
                IP = "127.0.0.1",   //服务运行地址
                Port = Convert.ToInt32(Configuration["Consul:ServicePort"]), //服务运行端口
                ServiceName = Configuration["Consul:Name"], //服务标识,Ocelot中会用到
                ConsulIP = Configuration["Consul:IP"], //Consul运行地址
                ConsulPort = Convert.ToInt32(Configuration["Consul:Port"])  //Consul运行端口（默认8500）
            };
            app.RegisterConsul(lifetime, serviceEntity);
            #endregion

            app.UseIdentityServer();
            //app.UseAuthentication();
            app.UseStaticFiles();
            app.UseMvcWithDefaultRoute();
        }

{
  "Service": {
    "Name": "MI.Service",
    "Port": "7001",
    "DocName": "Account Service",
    "Version": "v1",
    "Title": "Account Service API"
  },
  "Identity": {
    "IP": "localhost",
    "Port": "7000",
    "Scheme": "Bearer"
  },
  "ConnectionStrings": {
    "SqlConnection": "server=.;uid=sa;pwd=sa;database=MI"
  },
  "Consul": {
    "Name": "MI.Service.Account",
    "ServiceProt": "7001",
    "IP": "localhost",
    "Port": "8500"
  }
}

[Route("api/Health")]
    public class HealthController : Controller
    {
        [HttpGet]
        public IActionResult Get() => Ok("ok");
    }

public class MiUserController : Controller
    {
        public MIContext _context;
        public MiUserController(MIContext _context)
        {
            this._context = _context;
        }


        public string Index()
        {
            return "Successful";
        }

        。。。。。。
}

public void ConfigureServices(IServiceCollection services)
        {
            //services.AddMvc();
            services.AddOcelot(Configuration)
                .AddConsul();
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IHostingEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseOcelot();

            //app.UseMvc();  
        }

{
  "ReRoutes": [
    {
      "UseServiceDiscovery": true, //启用服务发现
      "DownstreamPathTemplate": "/Account/{url}", //下游转发路由
      "DownstreamScheme": "http", //标识头
      "ServiceName": "MI.Service.Account", //服务注册标识
      "LoadBalancer": "RoundRobin", //服务均衡：轮询
      "UpstreamPathTemplate": "/Account/{url}", //上游请求路由
      "UpstreamHttpMethod": [ "Get", "Post" ], //请求的方法类型
      "ReRoutesCaseSensitive": false //不区分大小写
    },
    {
      "UseServiceDiscovery": true,
      "DownstreamPathTemplate": "/Identity/{url}",
      "DownstreamScheme": "http",
      "ServiceName": "MI.Service.IdentityServer",
      "LoadBalancer": "RoundRobin",
      "UpstreamPathTemplate": "/Identity/{url}",
      "UpstreamHttpMethod": [ "Get", "Post" ],
      "ReRoutesCaseSensitive": false
    }
  ],
  "GlobalConfiguration": {
    //"BaseUrl": "http://localhost:7003",
    "ServiceDiscoveryProvider": {
      "Host": "127.0.0.1", // Consul Service IP
      "Port": 8500, // Consul Service Port
      "Type": "PollConsul",
      "PollingInterval": 100 //健康检查时间端
    }
  }
}

public static IWebHost BuildWebHost(string[] args) =>
            WebHost.CreateDefaultBuilder(args)
                .UseStartup<Startup>()
                .ConfigureAppConfiguration((hostingContext,builder)=> {
                    builder.AddJsonFile("consul.json");
                })
                .Build();