想和代码谈谈

var str1 = "str1" + 9;
var str2 = "str2" + 9.ToString();

using System;
using System.Linq;
using System.Net.NetworkInformation;

namespace ConsulDemo.Extensions
{
    public static class PortHelper
    {
        /// <summary>
        /// 产生一个随机可用端口
        /// </summary> /// <param name="minPort"></param>
        /// <param name="maxPort"></param>
        /// <returns></returns>
        public static int GetRandAvailablePort(int minPort = 1024, int maxPort = 65535)
        {
            var rand = new Random();
            while (true)
            {
                var port = rand.Next(minPort, maxPort);
                if (!IsPortInUsed(port))
                    return port;
            }
        }


        /// <summary>
        /// 判断端口是否在使用中
        /// </summary>
        /// <param name="port"></param>
        /// <returns></returns>
        public static bool IsPortInUsed(int port) =>
            IPGlobalProperties.GetIPGlobalProperties().GetActiveTcpListeners().Any(p => p.Port == port) ||
            IPGlobalProperties.GetIPGlobalProperties().GetActiveUdpListeners().Any(p => p.Port == port) ||
            IPGlobalProperties.GetIPGlobalProperties().GetActiveTcpConnections().Any(conn => conn.LocalEndPoint.Port == port);
    }
}

public static IWebHostBuilder using ConsulDemo.Extensions;
using Microsoft.AspNetCore;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;

namespace ConsulDemo
{
    public class Program
    {
        public static void Main(string[] args)
        {
            CreateWebHostBuilder(args).Build().Run();
        }

        public static int CurrentPort { get; set; }

        public static IWebHostBuilder CreateWebHostBuilder(string[] args) => 
            WebHost.CreateDefaultBuilder(args)
            .UseStartup<Startup>()
            .UseUrls($"http://*:{CurrentPort = PortHelper.GetRandAvailablePort()}");
    }
}

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


    app.UseMvc();


    const string ip = "127.0.0.1";
    var port = Program.CurrentPort;
    var serviceID = $"ConsulDemo_{Environment.TickCount}";

    //Consul 客户端
    var client = new ConsulClient((obj) =>
    {
        obj.Address = new Uri("http://127.0.0.1:8500");
        obj.Datacenter = "dc1";
    });

    // 在生命周期开始时注册服务
    lifetime.ApplicationStarted.Register(() =>
    {
        var result = client.Agent.ServiceRegister(new AgentServiceRegistration
        {
            ID = serviceID,
            Name = "ConsulDemo",
            Address = ip,
            Port = port,
            Check = new AgentServiceCheck
            {
                DeregisterCriticalServiceAfter = TimeSpan.FromSeconds(5),
                Interval = TimeSpan.FromSeconds(5),
                HTTP = $"http://{ip}:{port}/api/values/0",
                Timeout = TimeSpan.FromSeconds(5)
            }
        });

        Console.WriteLine($"Consul-ServiceRegister:{result.Result.StatusCode} - {result.Result.RequestTime}");
    });

    // 在生命周期结束时反注册服务
    lifetime.ApplicationStopping.Register(() =>
    {
        var result = client.Agent.ServiceDeregister(serviceID);
        Console.WriteLine($"Consul-ServiceDeregister:{result.Result.StatusCode} - {result.Result.RequestTime}");
    });
}

using Consul;
using Newtonsoft.Json;
using System;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading.Tasks;

namespace ConsulTemplate
{
    public class RestTemplate
    {
        private readonly string _consulServerUrl;
        public RestTemplate(string consulServerUrl = "http://127.0.0.1:8500")
        {
            _consulServerUrl = consulServerUrl;
        }
        /// <summary>
        /// 获取服务的第一个实现地址
        /// </summary>
        /// <param name="serviceName"></param>
        /// <returns></returns>
        private async Task<string> ResolveRootUrlAsync(string serviceName)
        {
            using (var consulClient = new ConsulClient(c => c.Address = new Uri(_consulServerUrl)))
            {
                var services = (await consulClient.Agent.Services()).Response;

                Console.WriteLine("当前所有服务");
                foreach (var service in services)
                    Console.WriteLine($"Service:{service.Value.Service}Address:{service.Value.Address}Port:{service.Value.Port}");

                var agentServices = services.Where(s => s.Value.Service.Equals(serviceName, StringComparison.CurrentCultureIgnoreCase)).Select(s => s.Value).ToArray();

                

                //根据当前TickCount对服务器个数取模，“随机”取一个机器出来，避免“轮询”的负载均衡策略需要计数加锁问题
                var agentService = agentServices.ElementAt(Environment.TickCount % agentServices.Length);

                 Console.WriteLine($"随机选取 Service:{agentService.Service}Address:{agentService.Address}Port:{agentService.Port}");
                return agentService.Address + ":" + agentService.Port;
            }
        }

        /// <summary>
        /// 转化到实际接口地址
        /// </summary>
        /// <param name="url"></param>
        /// <returns></returns>
        private async Task<string> ResolveUrlAsync(string url)
        {
            var uri = new Uri(url);
            var serviceName = uri.Host;
            var realRootUrl = await ResolveRootUrlAsync(serviceName);
            return uri.Scheme + "://" + realRootUrl + uri.PathAndQuery;
        }
        public async Task<ResponseEntity<T>> GetForEntityAsync<T>(string url, HttpRequestHeaders requestHeaders = null)
        {
            using (var httpClient = new HttpClient())
            {
                var requestMsg = new HttpRequestMessage();
                if (requestHeaders != null)
                    foreach (var header in requestHeaders)
                        requestHeaders.Add(header.Key, header.Value);

                requestMsg.Method = HttpMethod.Get;
                requestMsg.RequestUri = new Uri(await ResolveUrlAsync(url));
                var result = await httpClient.SendAsync(requestMsg);
                var respEntity = new ResponseEntity<T>
                {
                    StatusCode = result.StatusCode
                };
                var bodyStr = await result.Content.ReadAsStringAsync();
                respEntity.Body = JsonConvert.DeserializeObject<T>(bodyStr);
                respEntity.Headers = respEntity.Headers;
                return respEntity;
            }
        }
    }
}

public class ResponseEntity<T>
{
    public HttpStatusCode StatusCode { get; set; }
    public T Body { get; set; }//返回的json反序列化出来的对象
    public HttpResponseHeaders Headers { get; set; }//响应的报文头
}

static void Main(string[] args)
{
    while (true)
    {
        Console.WriteLine("请求开始");
        var rest = new RestTemplate();
        var data = rest.GetForEntityAsync<DateTime>("http://ConsulDemo/api/Values").Result;
        Console.WriteLine(data.StatusCode);
        Console.WriteLine(string.Join(",", data.Body));
        Console.WriteLine("请求结束\r\n\r\n");
        Console.ReadKey();
    }
}