.NET 程序设计语言

using Microsoft.IdentityModel.JsonWebTokens;
using Microsoft.IdentityModel.Tokens;
using System;
using System.Collections.Generic;
using System.IdentityModel.Tokens.Jwt;
using System.Linq;
using System.Security.Claims;
using System.Text;
using System.Threading.Tasks;

namespace JwtDemo
{
    //nuget Microsoft.IdentityModel.Tokens
    // nuget Microsoft.IdentityModel.JsonWebTokens
    public class AccessToken
    {
        public string Token { get; set; }
        public DateTime Expiration { get; set; }
        public bool Success { get; set; }
    }

    public class UserModel
    {
        public string UserName { get; set; }
        public string Password { get; set; }
    }
    public class JwtService
    {
        private string secretKey = "72Q+x7x088CyZx7445LsQz2CUHInC4piAIrDevGBdVs="; // 替换为你的实际密钥
        //string keyStr = "72Q+x7x088CyZx7445LsQz2CUHInC4piAIrDevGBdVs=";
        //public JwtService(IConfiguration configuration)
        //{
        //    keyStr = configuration.GetValue<string>("SecretKey");
        //}

        public string GenerateJwtToken(string username)
        {
            var tokenHandler = new JwtSecurityTokenHandler();
            var key = Encoding.UTF8.GetBytes(secretKey);

            var tokenDescriptor = new SecurityTokenDescriptor
            {
                Subject = new ClaimsIdentity(new Claim[]
                {
                new Claim(ClaimTypes.Name, username)
                }),
                Expires = DateTime.UtcNow.AddHours(1), // Token 有效期为1小时
                SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
            };

            var token = tokenHandler.CreateToken(tokenDescriptor);
            return tokenHandler.WriteToken(token);
        }

        public bool ValidateJwtToken(string token)
        {
            var tokenHandler = new JwtSecurityTokenHandler();
            var key = Encoding.UTF8.GetBytes(secretKey);

            var validationParameters = new TokenValidationParameters
            {
                ValidateIssuerSigningKey = true,
                IssuerSigningKey = new SymmetricSecurityKey(key),
                ValidateIssuer = false,
                ValidateAudience = false,
                ValidateLifetime = true
            };

            try
            {
                SecurityToken validatedToken;
                ClaimsPrincipal principal = tokenHandler.ValidateToken(token, validationParameters, out validatedToken);
                return true; // Token is valid
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Token validation failed: {ex.Message}");
                return false; // Token validation failed
            }
        }


        public async Task<AccessToken> GenerateTokenAsync(UserModel userModel)
        {

            if (userModel.UserName == "admin" && userModel.Password == "P@ssw0rd!")
            {
                var claims = new[]
                {
                    new Claim(Microsoft.IdentityModel.JsonWebTokens.JwtRegisteredClaimNames.Sub,"luo_sd@hotmail.com"),
                    new Claim(Microsoft.IdentityModel.JsonWebTokens.JwtRegisteredClaimNames.Jti,Guid.NewGuid().ToString()),
                    new Claim(Microsoft.IdentityModel.JsonWebTokens.JwtRegisteredClaimNames.UniqueName,"admin")
                };
                var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(secretKey));
                var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256Signature
                    );
                var token = new JwtSecurityToken("localhost", "localhost", claims,
                    expires: DateTime.Now.AddMinutes(10), signingCredentials: creds);

                return new AccessToken
                {
                    Token = new JwtSecurityTokenHandler().WriteToken(token),
                    Expiration = token.ValidTo,
                    Success = true
                };
            }
            return new AccessToken
            {
                Success = false
            };
        }

  

        public bool ValidateToken(string token)
        {
            var tokenHandler = new JwtSecurityTokenHandler();
            var validationParameters = GetValidationParameters();

            try
            {
                SecurityToken validatedToken;
                var claimsPrincipal = tokenHandler.ValidateToken(token, validationParameters, out validatedToken);
                return true; // Token is valid
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Token validation failed: {ex.Message}");
                return false; // Token validation failed
            }
        }

        private TokenValidationParameters GetValidationParameters()
        {
            return new TokenValidationParameters
            {
                ValidateIssuer = true, // 此处设置为true时需要指定一个Issuer
                ValidIssuer= "localhost",
                ValidateAudience = false, // You may need to change audience validation according to your requirements
                ValidateLifetime = true,
                ValidateIssuerSigningKey = true,
                IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(secretKey))
            };
        }
    }
}

namespace JwtDemo
{
    internal class Program
    {
        static void Main(string[] args)
        {
            string keyStr = "72Q+x7x088CyZx7445LsQz2CUHInC4piAIrDevGBdVs=";
            var userModel = new UserModel() { UserName="admin",Password= "P@ssw0rd!" };
            var jwtService = new JwtService();
            var token = jwtService.GenerateTokenAsync(userModel).GetAwaiter().GetResult();
            Console.WriteLine(token.Token);
            var isOk = jwtService.ValidateToken(token.Token);


            // 生成一个 JWT Token
            string username = "alice";
            string accessToken = jwtService.GenerateJwtToken(username);
            Console.WriteLine($"Generated JWT Token: {token}");

            // 验证 JWT Token
            bool isValid = jwtService.ValidateJwtToken(accessToken);
            Console.WriteLine($"Token validation result: {isValid}");



            Console.WriteLine($"{isValid} press any key to exit！");
            Console.ReadKey();
             
        }
    }
}

var cca = ConfidentialClientApplicationBuilder
    .Create(ConfigurationManager.AppSettings["appId"])
    .WithClientSecret(ConfigurationManager.AppSettings["clientSecret"])
    .WithTenantId(ConfigurationManager.AppSettings["tenantId"])
    //仅在 21V 版本中，添加下一行代码
    .WithAuthority(AzureCloudInstance.AzureChina, ConfigurationManager.AppSettings["tenantId"])
    .Build();
 var ewsScopes = new string[] { "https://partner.outlook.cn/.default" };
 var authResult = await
cca.AcquireTokenForClient(ewsScopes).ExecuteAsync();

var ewsClient = new ExchangeService();
ewsClient.Url = new Uri("https://partner.outlook.cn/EWS/Exchange.asmx");
ewsClient.Credentials = new OAuthCredentials(authResult.AccessToken);
ewsClient.ImpersonatedUserId = new ImpersonatedUserId(ConnectingIdType.SmtpAddress, "user@abc.com");  

var token = "eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiIsIng1dCI6IkFwSWhPRlV2NmsxOXlGN2VQdy1mb1VaTnlhWSJ9.eyJuYW1laWQiOiIxNDVjMzZmNS1mNzA3LTRkMjYtODQ0Ni0wMTFiZTcwNWJiNmJAd2x5bmMuY29tIiwidmVyIjoiRXhjaGFuZ2UuQ2FsbGJhY2suVjEiLCJhcHBjdHhzZW5kZXIiOiJodHRwczovL2F0cC5seW5jbXAuY29tL2luZGV4Lmh0bWxAd2x5bmMuY29tIiwiYXBwY3R4Ijoie1wic210cFwiOlwia2RAd2x5bmMuY29tXCIsXCJzY29wZVwiOlwiUGFyZW50SXRlbUlkOkFBTWtBR1ZrTXpRek5qTXpMV1ZpTURBdE5ERTVZUzFoTVRZNExUWTNNV1F5TkdReU1UTmpPQUJHQUFBQUFBRHBiUjRMNllZNVQ0QlhDaHZ4SXB5ZUJ3Q2FhNEN5R1R5QlNJRkhTbHVhYU5uVEFBQUFBQUVNQUFDYWE0Q3lHVHlCU0lGSFNsdWFhTm5UQUFBUlJRQ3JBQUE9XCJ9IiwiaXNzIjoiMDAwMDAwMDItMDAwMC0wZmYxLWNlMDAtMDAwMDAwMDAwMDAwQHdseW5jLmNvbSIsImF1ZCI6IjAwMDAwMDAyLTAwMDAtMGZmMS1jZTAwLTAwMDAwMDAwMDAwMC9tYWlsLndseW5jLmNvbUB3bHluYy5jb20iLCJleHAiOjE3MDg0OTM3OTcsIm5iZiI6MTcwODQ5MzQ5N30.J8dtGkxEHuwz0UzFi0IEdZpAWaUVgipj-NYFSAGOBNtdxX9sccbBStouiCHekMQTOEFuY7UoEd13QfcH5aG1khJBLchI_LCiFjPuVbfks8QVROSv0_ooG6VixOB4EM7IUyWQU8ay0ehaVldM7CHGqDAOcIJdCnQZrRIlqDwYEpTACEPR9l9XIRruW4jvPnLT1bYAbMAT3rJw1p_r-hjVvap2kz51YfgqhSkDPm3d6k_99gQlhvMVzlqt02CwEcEBXiA6fUgLiou6qk-IbQJ8cgQUEfGryt7DKmg-UdTK2sDPh-2kpcsNp58vQ6xwI0eb5JNvG2VZv4W_rGCQ02K6WQ";

var itemId = "AAMkAGVkMzQzNjMzLWViMDAtNDE5YS1hMTY4LTY3MWQyNGQyMTNjOABGAAAAAADpbR4L6YY5T4BXChvxIpyeBwCaa4CyGTyBSIFHSluaaNnTAAAAAAEMAACaa4CyGTyBSIFHSluaaNnTAAARRQCrAAA=";



ExchangeService service = new ExchangeService(ExchangeVersion.Exchange2013_SP1);

//var Credentials = new OAuthCredentials(token);
//service.Credentials = Credentials;
service.Url = new Uri("https://mail.wlync.com/ews/exchange.asmx");
service.HttpHeaders.Add("Authorization", "Bearer" +token);

var item = Item.Bind(service, itemId);

using Microsoft.Exchange.WebServices.Data;
using Microsoft.Identity.Client;
using System;
using System.Configuration;

namespace EwsOAuth
{
    class Program
    {
        static async System.Threading.Tasks.Task Main(string[] args)
        {
            // Using Microsoft.Identity.Client 4.22.0
            var cca = ConfidentialClientApplicationBuilder
                .Create(ConfigurationManager.AppSettings["appId"])
                .WithClientSecret(ConfigurationManager.AppSettings["clientSecret"])
                .WithTenantId(ConfigurationManager.AppSettings["tenantId"])
                // Use the next line of code only in a 21V environment
                .WithAuthority(AzureCloudInstance.AzureChina, ConfigurationManager.AppSettings["tenantId"])
                .Build();

            //the permission scope required for EWS access
            var ewsScopes = new string[] { "https://partner.outlook.cn/.default" };
            try
            {
                //make the token request
                var authResult = await cca.AcquireTokenForClient(ewsScopes).ExecuteAsync();

                // Configure the ExchangeService with the access token
                var ewsClient = new ExchangeService();
                ewsClient.Url = new Uri("https://partner.outlook.cn/EWS/Exchange.asmx");
                ewsClient.Credentials = new OAuthCredentials(authResult.AccessToken);
                ewsClient.ImpersonatedUserId = new ImpersonatedUserId(ConnectingIdType.SmtpAddress, "S02@ms10.online");

                //Include x-anchormailbox header
                ewsClient.HttpHeaders.Add("X-AnchorMailbox", "S02@ms10.online");
                // Make an EWS call                             
                DateTime endDate = DateTime.Now;
                DateTime startDate = endDate.AddDays(-30);
                CalendarFolder calendar = CalendarFolder.Bind(ewsClient, WellKnownFolderName.Calendar, new PropertySet());
                CalendarView cView = new CalendarView(startDate, endDate);
                cView.PropertySet = new PropertySet(AppointmentSchema.Subject, AppointmentSchema.Start, AppointmentSchema.End);

                FindItemsResults<Appointment> appointments = calendar.FindAppointments(cView);
                Console.WriteLine("\nThe first " + " appointments on your calendar from " + startDate.Date.ToShortDateString() +

             " to " + endDate.Date.ToShortDateString() + " are: \n");
                foreach (Appointment a in appointments)
                {
                    Console.Write("Subject: " + a.Subject.ToString() + " ");
                    Console.Write("Start: " + a.Start.ToString() + " ");
                    Console.Write("End: " + a.End.ToString());
                    Console.WriteLine();
                }
            }
            catch (MsalException ex)
            {
                Console.WriteLine($"Error acquiring access token: {ex}");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error: {ex}");
            }
            if (System.Diagnostics.Debugger.IsAttached)
            {
                Console.WriteLine("Hit any key to exit...");
                Console.ReadKey();
            }
        }
    }
}

public class Startup
{
    public static IConfiguration Configuration;

    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }

    public void ConfigureServices(IServiceCollection services)
    {
        var clientConfiguration = Configuration.GetSection("RabbitMq");
        var exchangeConfiguration = Configuration.GetSection("RabbitMqExchange");
        services.AddRabbitMqClient(clientConfiguration)
            .AddExchange("ExchangeName", isConsuming: true, exchangeConfiguration);
    }

    public void Configure(IApplicationBuilder app, IHostingEnvironment env)
    {
    }
}

{
 "RabbitMqExchange": {
    "Type": "direct",
    "Queues": [
      {
        "Name": "queue.name.as.routing.key"
      }
    ]
  }
}

services.AddRabbitMqClient(clientConfiguration)
    .AddExchange("ExchangeName", isConsuming: true, exchangeConfiguration);

services.AddRabbitMqClient(clientConfiguration)
    .AddConsumptionExchange("ConsumptionExchange", exchangeConfiguration);

// And the other method.

services.AddRabbitMqClient(clientConfiguration)
    .AddProductionExchange("ProductionExchange", exchangeConfiguration);

var exchangeOptions = new RabbitMqExchangeOptions
{
    Type = "topic",
    Durable = true,
    AutoDelete = true,
    Arguments = null,
    RequeueFailedMessages = true,
    DeadLetterExchange = "default.dlx.exchange",
    Queues = new List<RabbitMqQueueOptions>
    {
        new RabbitMqQueueOptions
        {
            Name = "MyQueueName",
            Durable = true,
            AutoDelete = false,
            Exclusive = false,
            Arguments = null,
            RoutingKeys = new HashSet<string> { "routing.key" }
        }
    }
};
services.AddRabbitMqClient(clientConfiguration)
     .AddExchange("ExchangeName", isConsuming: true, exchangeOptions);

var exchangeOptions = new RabbitMqExchangeOptions
{
    Queues = new List<RabbitMqQueueOptions>
    {
        new RabbitMqQueueOptions
        {
            Name = "MyQueueName",
            RoutingKeys = new HashSet<string> { "routing.key" }
        }
    }
};
services.AddRabbitMqClient(clientConfiguration)
    .AddProductionExchange("ProductionExchange", exchangeOptions);

// Or the other method.

services.AddRabbitMqClient(clientConfiguration)
    .AddConsumptionExchange("ConsumptionExchange", exchangeConfiguration);

// Program.cs

using WorkerService1;

IHost host = Host.CreateDefaultBuilder(args)
    .UseWindowsService(options =>
    {
        options.ServiceName = "CPU Load Logger";
    })
    .ConfigureServices(services =>
    {
        services.AddHostedService<Worker>();
    })
    .Build();

await host.RunAsync();

//Worker.cs

using Microsoft.Extensions.Logging;
using System.Diagnostics;

namespace WorkerService1
{
    public class Worker : BackgroundService
    {
        private readonly ILogger<Worker> _logger;
        private readonly string logPath;
        private StreamWriter cpuLogger = null!;
        public Worker(ILogger<Worker> logger, IConfiguration config)
        {
            _logger = logger;
            logPath = Path.Combine(
                config.GetValue<string>("LogPath") ??
                System.AppContext.BaseDirectory!,
                "cpu.log");
        }
        // 服務啟動時
        public override async Task StartAsync(CancellationToken stoppingToken)
        {
            cpuLogger = new StreamWriter(logPath, true);
            _logger.LogInformation("Service started");
            Log("Service started");
            // 基底類別 BackgroundService 在 StartAsync() 呼叫 ExecuteAsync、
            // 在 StopAsync() 時呼叫 stoppingToken.Cancel() 優雅結束
            await base.StartAsync(stoppingToken);
        }

        // 服務停止時
        public override async Task StopAsync(CancellationToken stoppingToken)
        {
            _logger.LogInformation("Service stopped");
            Log("Service stopped");
            cpuLogger.Dispose();
            cpuLogger = null!;
            await base.StopAsync(stoppingToken);
        }

        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            try
            {
                while (!stoppingToken.IsCancellationRequested)
                {
                    ThreadPool.QueueUserWorkItem(
                        (obj) =>
                        {
                            try
                            {
                                var cancelToken = (CancellationToken)obj!;
                                if (!stoppingToken.IsCancellationRequested)
                                {
                                    Log($"CPU: {GetCpuLoad()}%");
                                    _logger.LogInformation($"Logging CPU load");
                                }
                            }
                            catch (Exception ex)
                            {
                                _logger.LogError(ex.ToString());
                                throw;
                            }
                        }, stoppingToken);
                    await Task.Delay(5000, stoppingToken);
                }
            }
            catch (OperationCanceledException)
            {
                // When the stopping token is canceled, for example, a call made from services.msc,
                // we shouldn't exit with a non-zero exit code. In other words, this is expected...
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "{Message}", ex.Message);

                // Terminates this process and returns an exit code to the operating system.
                // This is required to avoid the 'BackgroundServiceExceptionBehavior', which
                // performs one of two scenarios:
                // 1. When set to "Ignore": will do nothing at all, errors cause zombie services.
                // 2. When set to "StopHost": will cleanly stop the host, and log errors.
                //
                // In order for the Windows Service Management system to leverage configured
                // recovery options, we need to terminate the process with a non-zero exit code.
                Environment.Exit(1);
            }
        }

        void Log(string message)
        {
            if (cpuLogger == null) return;
            cpuLogger.WriteLine($"{DateTime.Now:yyyy-MM-dd HH:mm:ss} {message}");
            cpuLogger.Flush();
        }

        int GetCpuLoad()
        {
            using (var p = new Process())
            {
                p.StartInfo.FileName = "wmic.exe";
                p.StartInfo.Arguments = "cpu get loadpercentage";
                p.StartInfo.UseShellExecute = false;
                p.StartInfo.RedirectStandardOutput = true;
                p.Start();
                int load = -1;
                var m = System.Text.RegularExpressions.Regex.Match(
                    p.StandardOutput.ReadToEnd(), @"\d+");
                if (m.Success) load = int.Parse(m.Value);
                p.WaitForExit();
                return load;
            }
        }
    }
}

public class Worker : BackgroundService
    {
        private readonly ILogger<Worker> _logger;
        private readonly RecallWorker _recallWorker;

        private MailboxGrpcServiceImplement _mailboxGrpcService;
        private Server _server;

        public Worker(ILogger<Worker> logger, RecallWorker mailRecallWorker, MailboxGrpcServiceImplement mailboxGrpcServiceImplement)
        {
            _logger = logger;
            _mailboxGrpcService = mailboxGrpcServiceImplement;
            _recallWorker = mailRecallWorker;
        }

        public override Task StartAsync(CancellationToken cancellationToken)
        {
            string keyPath = Path.Combine(AppContext.BaseDirectory, "cert/exatp.wlync.com.key");
            string certificatePath = Path.Combine(AppContext.BaseDirectory, "cert/exatp.wlync.com.crt");
            var key = File.ReadAllText(keyPath);
            var cert = File.ReadAllText(certificatePath);
            var keyPair = new KeyCertificatePair(cert, key);
            var credentials = new SslServerCredentials(new List<KeyCertificatePair> { keyPair });
            _server = new Server
            {
                Services = { BindService(_mailboxGrpcService) },
                Ports = { new ServerPort("0.0.0.0", 5001, credentials),
                new ServerPort("0.0.0.0", 5000, ServerCredentials.Insecure)}
            };

            _server.Start();
            _logger.LogInformation($"gRPC server is runing at http://0.0.0.0:{5000}, https://0.0.0.0:{5001} port");
            return base.StartAsync(cancellationToken);
        }

        public override Task StopAsync(CancellationToken cancellationToken)
        {
            _server?.ShutdownAsync().Wait();
            return base.StopAsync(cancellationToken);
        }


        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            while (!stoppingToken.IsCancellationRequested)
            {
                if (!WorkerStatus.MailRecallWorkerStatus)
                {
                    _recallWorker.Start();
                }
                await Task.Delay(1000 * 60, stoppingToken);
            }
        }

Task myTask = Task.Run(() =>
{
    // 异步任务的代码
});

// 异步任务开始后，状态变为Running
if (myTask.Status == TaskStatus.Running)
{
    // 异步任务已经开始
}

// 异步任务结束后，状态变为RanToCompletion
myTask.ContinueWith(task =>
{
    // 异步任务已经结束
});

using System.DirectoryServices;
using System.Threading.Tasks;
using System.Threading;

async Task ConnectWithTimeoutAsync(string server, TimeSpan timeout)
{
    using var cts = new CancellationTokenSource(timeout);
    try
    {
        var task = Task.Run(() =>
        {
            var de = new DirectoryEntry("LDAP://" + server);
            // 尝试建立连接
            var obj = de.NativeObject;
            return de;
        }, cts.Token);

        return await task;
    }
    catch (OperationCanceledException)
    {
        // 处理超时
        Console.WriteLine("LDAP connection timed out.");
        return null;
    }
}

// 使用示例
var result = await ConnectWithTimeoutAsync("ldap.example.com", TimeSpan.FromSeconds(10));
if (result == null)
{
    // 处理超时情况
}

public static object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {
            string size = "0 KB";

            if (value != null)
            {
                double byteCount;
                if (value.GetType().Name == "Single")
                {
                    byteCount = double.Parse(value.ToString());
                }
                else
                {
                    byteCount = (double)value;
                }
                

                if (byteCount >= 1073741824)
                    size = String.Format("{0:##.##}", byteCount / 1073741824) + " GB";
                else if (byteCount >= 1048576)
                    size = String.Format("{0:##.##}", byteCount / 1048576) + " MB";
                else if (byteCount >= 1024)
                    size = String.Format("{0:##.##}", byteCount / 1024) + " KB";
                else if (byteCount > 0 && byteCount < 1024)
                    size = "1 KB";    //Bytes are unimportant ;)            

            }

            return size;
        }