public static IEnumerable<ApiResource> GetApiResources()
{
    return new List<ApiResource> {
        new ApiResource("api1", "我的 API")
    };
}

public static IEnumerable<Client> GetClients()
{
    return new List<Client>
            {
                new Client
                {
                    ClientId = "client",

                    // 没有交互性用户，使用 clientid/secret 实现认证。
                    AllowedGrantTypes = GrantTypes.ClientCredentials,

                    // 用于认证的密码
                    ClientSecrets =
                    {
                        new Secret("secret".Sha256())
                    },
                    // 客户端有权访问的范围（Scopes）
                    AllowedScopes = { "api1" }
                }
            };
}

public void ConfigureServices(IServiceCollection services)
{
    
    services.AddControllers();
    // 使用内存存储，密钥，客户端和资源来配置身份服务器。
    services.AddIdentityServer().AddDeveloperSigningCredential()
            .AddInMemoryApiResources(Config.GetApiResources())
            .AddInMemoryClients(Config.GetClients());

}

[Route("identity")]
[Authorize()]
public class IdentityController : ControllerBase
{
    [HttpGet()]
    public IActionResult Get()
    {
        return new JsonResult(from c in User.Claims select new { c.Type, c.Value });
    }
}

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

    app.UseHttpsRedirection();

    app.UseRouting();
    app.UseAuthentication();
    app.UseAuthorization();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllers();
    });


}

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers();
    services.AddAuthentication(IdentityServerAuthenticationDefaults.AuthenticationScheme)
        .AddIdentityServerAuthentication(IdentityServerAuthenticationDefaults.AuthenticationScheme
        , jwtOptions =>
        {
            jwtOptions.RequireHttpsMetadata = false;
            jwtOptions.Authority = "http://localhost:5000";
            jwtOptions.ApiName = "api1";
        });
}

static async System.Threading.Tasks.Task Main(string[] args)
{


    var client = new HttpClient();
    var tokenClient = new TokenClient(client, new TokenClientOptions
    {
        Address = "http://localhost:5000/connect/token",
        ClientId = "client",
        ClientSecret = "secret"
    });
    var response = await tokenClient.RequestClientCredentialsTokenAsync("api1");

    Console.WriteLine(response.AccessToken);
    client.SetBearerToken(response.AccessToken);
    string resStr = await client.GetStringAsync("http://localhost:5001/identity");
    Console.WriteLine(resStr);
    Console.ReadLine();
}

public static List<TestUser> GetUsers()
{
    return new List<TestUser>()
        {
        new TestUser
        {
        SubjectId="1",
        Username="爱丽丝",
        Password="password"
        },
        new TestUser
        {
        SubjectId="2",
        Username="博德",
        Password="password"
        }
        };
}

public void ConfigureServices(IServiceCollection services)
{

    services.AddControllers();
    // 使用内存存储，密钥，客户端和资源来配置身份服务器。
    services.AddIdentityServer().AddDeveloperSigningCredential()
            .AddInMemoryApiResources(Config.GetApiResources())
            .AddInMemoryClients(Config.GetClients())
                .AddTestUsers(Config.GetUsers()); 

}

new Client
{
    ClientId = "ro.client",

    // 没有交互性用户，使用 clientid/secret 实现认证。
    AllowedGrantTypes = GrantTypes.ResourceOwnerPassword,

    // 用于认证的密码
    ClientSecrets =
    {
        new Secret("secret".Sha256())
    },
    // 客户端有权访问的范围（Scopes）
    AllowedScopes = { "api1" }
}

using (var client = new HttpClient())
{
    var tokenClient = new TokenClient(client, new TokenClientOptions
    {
        Address = "http://localhost:5000/connect/token",
        ClientId = "ro.client",
        ClientSecret = "secret"
    });
    var response = await tokenClient.RequestPasswordTokenAsync("爱丽丝", "password", "api1");

    Console.WriteLine(response.AccessToken);
    client.SetBearerToken(response.AccessToken);
    string resStr = await client.GetStringAsync("http://localhost:5001/identity");
    Console.WriteLine(resStr);
    Console.ReadLine();
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using IdentityServer4.Quickstart.UI;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

namespace IdentityServer4DotNet.ClientAuth.Ids4s
{
    public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllersWithViews();

            // configures IIS out-of-proc settings (see https://github.com/aspnet/AspNetCore/issues/14882)
            services.Configure<IISOptions>(iis =>
            {
                iis.AuthenticationDisplayName = "Windows";
                iis.AutomaticAuthentication = false;
            });

            // configures IIS in-proc settings
            services.Configure<IISServerOptions>(iis =>
            {
                iis.AuthenticationDisplayName = "Windows";
                iis.AutomaticAuthentication = false;
            });

            var builder = services.AddIdentityServer(options =>
            {
                options.Events.RaiseErrorEvents = true;
                options.Events.RaiseInformationEvents = true;
                options.Events.RaiseFailureEvents = true;
                options.Events.RaiseSuccessEvents = true;
            })
                .AddTestUsers(TestUsers.Users);

            // in-memory, code config
            builder.AddInMemoryIdentityResources(Config.Ids);
            builder.AddInMemoryApiResources(Config.Apis);
            builder.AddInMemoryClients(Config.Clients);

            // or in-memory, json config
            //builder.AddInMemoryIdentityResources(Configuration.GetSection("IdentityResources"));
            //builder.AddInMemoryApiResources(Configuration.GetSection("ApiResources"));
            //builder.AddInMemoryClients(Configuration.GetSection("clients"));

            // not recommended for production - you need to store your key material somewhere secure
            builder.AddDeveloperSigningCredential();

        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            else
            {
                app.UseExceptionHandler("/Home/Error");
            }
            app.UseStaticFiles();

            app.UseRouting();

            app.UseIdentityServer();
            app.UseAuthorization();

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllerRoute(
                    name: "default",
                    pattern: "{controller=Home}/{action=Index}/{id?}");
            });
        }
    }
}

   // mvc client, authorization code
new Client
{
    ClientId = "mvc client",
    ClientName = "ASP.NET Core MVC Client",

    AllowedGrantTypes = GrantTypes.CodeAndClientCredentials,
    ClientSecrets = { new Secret("mvc secret".Sha256()) },

    RedirectUris = { "http://localhost:5002/signin-oidc" },

    FrontChannelLogoutUri = "http://localhost:5002/signout-oidc",
    PostLogoutRedirectUris = { "http://localhost:5002/signout-callback-oidc" },

    AlwaysIncludeUserClaimsInIdToken = true,

    AllowOfflineAccess = true, // offline_access
    AccessTokenLifetime = 60, // 60 seconds

    AllowedScopes =
    {
        "api1",
        IdentityServerConstants.StandardScopes.OpenId,
        IdentityServerConstants.StandardScopes.Email,
        IdentityServerConstants.StandardScopes.Address,
        IdentityServerConstants.StandardScopes.Phone,
        IdentityServerConstants.StandardScopes.Profile
    }
},

using System;
using System.Collections.Generic;
using System.IdentityModel.Tokens.Jwt;
using System.Linq;
using System.Threading.Tasks;
using IdentityModel;
using Microsoft.AspNetCore.Authentication.Cookies;
using Microsoft.AspNetCore.Authentication.OpenIdConnect;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

namespace IdentityServer4DotNet.ClientAuth.MVCClient
{
    public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.Configure<CookiePolicyOptions>(options =>
            {
                // This lambda determines whether user consent for non-essential cookies is needed for a given request.
                options.CheckConsentNeeded = context => true;
                options.MinimumSameSitePolicy = SameSiteMode.None;
            });

            services.AddControllersWithViews();
            JwtSecurityTokenHandler.DefaultInboundClaimTypeMap.Clear();

            services.AddAuthentication(options =>
            {
                options.DefaultScheme = CookieAuthenticationDefaults.AuthenticationScheme;
                options.DefaultChallengeScheme = OpenIdConnectDefaults.AuthenticationScheme;
            })
                .AddCookie(CookieAuthenticationDefaults.AuthenticationScheme)
                .AddOpenIdConnect(OpenIdConnectDefaults.AuthenticationScheme, options =>
                {
                    options.SignInScheme = CookieAuthenticationDefaults.AuthenticationScheme;
                    options.Authority = "http://localhost:5000";
                    options.RequireHttpsMetadata = false;
                    options.ClientId = "mvc client";
                    options.ClientSecret = "mvc secret";
                    options.SaveTokens = true;
                    options.ResponseType = "code";

                    options.Scope.Clear();
                    options.Scope.Add("api1");
                    options.Scope.Add(OidcConstants.StandardScopes.OpenId);
                    options.Scope.Add(OidcConstants.StandardScopes.Profile);
                    options.Scope.Add(OidcConstants.StandardScopes.Email);
                    options.Scope.Add(OidcConstants.StandardScopes.Phone);
                    options.Scope.Add(OidcConstants.StandardScopes.Address);
                    options.Scope.Add(OidcConstants.StandardScopes.OfflineAccess);
                });
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            else
            {
                app.UseExceptionHandler("/Home/Error");
            }
           
            app.UseStaticFiles();

            app.UseRouting();
            app.UseAuthentication();
            app.UseAuthorization();
            app.UseCookiePolicy();
            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllerRoute(
                    name: "default",
                    pattern: "{controller=Home}/{action=Index}/{id?}");
            });
        }
    }
}

services.AddAuthentication()
.AddGoogle(options =>
{
    options.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme;

    // register your IdentityServer with Google at https://console.developers.google.com
    // enable the Google+ API
    // set the redirect URI to http://localhost:5000/signin-google
    options.ClientId = "629456249245-4vf1gvlltllq592coo46hrc8ofqa8cg6.apps.googleusercontent.com";
    options.ClientSecret = "XhUa6NODSIGOtSPBuGrTeeeW";
});

// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers();
    services.AddSingleton<ISchedulerFactory, StdSchedulerFactory>();//注册ISchedulerFactory的实例。
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Quartz;

namespace QuartzNet.Web.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class ValuesController : ControllerBase
    {
        private readonly ISchedulerFactory _schedulerFactory;
        private IScheduler _scheduler;
        public ValuesController(ISchedulerFactory schedulerFactory)
        {
            this._schedulerFactory = schedulerFactory;
        }
        [HttpGet]
        public async Task<string[]> Get()
        {
            //1、通过调度工厂获得调度器
            _scheduler = await _schedulerFactory.GetScheduler();
            //2、开启调度器
            await _scheduler.Start();
            //3、创建一个触发器
            var trigger = TriggerBuilder.Create()
                            .WithSimpleSchedule(x => x.WithIntervalInSeconds(2).RepeatForever())//每两秒执行一次
                            .Build();
            //4、创建任务
            var jobDetail = JobBuilder.Create<MyJob>()
                            .WithIdentity("job", "group")
                            .Build();
            //5、将触发器和任务器绑定到调度器中
            await _scheduler.ScheduleJob(jobDetail, trigger);
            return await Task.FromResult(new string[] { "value1", "value2" });
        }
    }
}

using Quartz;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace QuartzNet.Web
{
    public class MyJob : IJob//创建IJob的实现类，并实现Excute方法。
    {
        public Task Execute(IJobExecutionContext context)
        {
            return Task.Run(() =>
            {
                using (StreamWriter sw = new StreamWriter(@"error.log", true, Encoding.UTF8))
                {
                    sw.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH-mm-ss"));
                }
            });
        }
    }
}

2020-04-17 11-55-45
2020-04-17 11-55-47
2020-04-17 11-55-49
2020-04-17 11-55-51
2020-04-17 11-55-53
2020-04-17 11-55-55

var trigger3 = TriggerBuilder.Create()
                       .WithSimpleSchedule(x =>x.WithIntervalInSeconds(2).RepeatForever())//间隔2秒 一直执行
                       .UsingJobData("key1", 321)  //通过在Trigger中添加参数值
                       .UsingJobData("key2", "123")
                       .WithIdentity("trigger2", "group1")
                       .Build();

IJobDetail job = JobBuilder.Create<MyJob>()
                               .UsingJobData("key1", 123)//通过Job添加参数值
                               .UsingJobData("key2", "123")
                               .WithIdentity("job1", "group1")
                               .Build();

public class MyJob : IJob
    {
        public Task Execute(IJobExecutionContext context)
        {
            var jobData = context.JobDetail.JobDataMap;//获取Job中的参数

            var triggerData = context.Trigger.JobDataMap;//获取Trigger中的参数

            var data = context.MergedJobDataMap;//获取Job和Trigger中合并的参数

            var value1= jobData.GetInt("key1");
            var value2= jobData.GetString("key2");

            var dateString = DateTime.Now.ToString("yyyy-MM-dd HH-mm-ss");return Task.Run(() =>
            {
                using (StreamWriter sw = new StreamWriter(@"error.log", true, Encoding.UTF8))
                {
                    sw.WriteLine(dateString);
                }
            });
        }
    }

[PersistJobDataAfterExecution]//更新JobDetail的JobDataMap的存储副本，以便下一次执行这个任务接收更新的值而不是原始存储的值
    public class MyJob : IJob
    {
        public Task Execute(IJobExecutionContext context)
        {
            var jobData = context.JobDetail.JobDataMap;
            var triggerData = context.Trigger.JobDataMap;
            var data = context.MergedJobDataMap;

            var value1 = jobData.GetInt("key1");
            var value2 = jobData.GetString("key2");
            var value3 = data.GetString("key2");

            var dateString = DateTime.Now.ToString("yyyy-MM-dd HH-mm-ss");
            Random random = new Random();

            jobData["key1"] = random.Next(1, 20);//这里面给key赋值，下次再进来执行的时候，获取的值为更新的值，而不是原始值
            jobData["key2"] = dateString;

            return Task.Run(() =>
            {
                using (StreamWriter sw = new StreamWriter(@"C:\Users\Administrator\Desktop\error.log", true, Encoding.UTF8))
                {
                    sw.WriteLine($"{dateString} value1:{value1} value2:{value2}");
                }
                //context.Scheduler.DeleteJob(context.JobDetail.Key);
                //context.Scheduler.Shutdown();
            });
        }
    }

public void ConfigureServices(IServiceCollection services)
{
            services.AddQuartz(typeof(QuartzJob));

           //........
}


public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
    QuartzService.StartJobs<QuartzJob>();
    //........
}

public class HostedService : IHostedService
    {
        private JobManager _jobManager;
        public HostedService( JobManager jobManager)
        {
            _jobManager = jobManager;
        }

        public Task StartAsync(CancellationToken cancellationToken)
        {
            return Task.Factory.StartNew(async () =>
            {
                await _jobManager.Start();
            }, cancellationToken);
        }

        public Task StopAsync(CancellationToken cancellationToken)
        {
            return Task.Factory.StartNew(async () =>
            {
                await _jobManager.Stop();
            }, cancellationToken);
        }
    }

string ip = Configuration["ip"];//部署到不同服务器的时候不能写成127.0.0.1或者0.0.0.0，因为这是让服务消费者调用的地址
int port = int.Parse(Configuration["port"]);//获取服务端口
var client = new ConsulClient(ConfigurationOverview); //回调获取
var result = client.Agent.ServiceRegister(new AgentServiceRegistration()
{
    ID = "ServerNameFirst" + Guid.NewGuid(),//服务编号保证不重复
    Name = "MsgServer",//服务的名称
    Address = ip,//服务ip地址
    Port = port,//服务端口
    Check = new AgentServiceCheck //健康检查
    {
        DeregisterCriticalServiceAfter = TimeSpan.FromSeconds(5),//服务启动多久后反注册
        Interval = TimeSpan.FromSeconds(10),//健康检查时间间隔，或者称为心跳间隔（定时检查服务是否健康）
        HTTP = $"http://{ip}:{port}/api/Health",//健康检查地址
        Timeout = TimeSpan.FromSeconds(5)//服务的注册时间
    }
});

private static void ConfigurationOverview(ConsulClientConfiguration obj)
{
    //consul的地址
    obj.Address = new Uri("http://192.168.1.37:8500");
    //数据中心命名
    obj.Datacenter = "dc1";
}

static List<string> Urls = new List<string>();

static void Main(string[] args)
{
    Console.WriteLine("开始输出当前所有服务地址");
    Catalog_Nodes().GetAwaiter().GetResult();
    //Console.WriteLine(HelloConsul().GetAwaiter().GetResult());
    Console.WriteLine("开始随机请求一个地址服务地址");
    int index = new Random().Next(Urls.Count);
    string url = Urls[index];
    
    Console.WriteLine("请求的随机地址：" + url);
    HttpClient client = new HttpClient();
    var result = client.GetAsync(url).Result;
    //string result = HttpClientHelpClass.PostResponse(url, param, out string statusCode);
    Console.WriteLine("返回状态：" + result.StatusCode);
    Console.WriteLine("返回结果：" + result.Content);
    Console.ReadLine();
}
public static async Task Catalog_Nodes()
{
    var client = new ConsulClient(ConfigurationOverview);
    var nodeList = await client.Agent.Services();
    var url = nodeList.Response.Values;

    foreach (var item in url)
    {
        string Address = item.Address;
        int port = item.Port;
        string name = item.Service;
        Console.WriteLine($"地址：{Address}:{port},name：{name}");
        Urls.Add($"http://{Address}:{port}/weatherforecast");
    }
}

private static void ConfigurationOverview(ConsulClientConfiguration obj)
{
    //consul的地址
    obj.Address = new Uri("http://192.168.1.37:8500");
    //数据中心命名
    obj.Datacenter = "dc1";
}