Rick 's BLOG https://www.rickw.cn/ Rick 's BLOG zh-cn redcheek@gmail.com <![CDATA[C#实现WebApi接口数据传输加密方案]]> 如果项目要上线到公网中，那么我们就需要考虑安全问题；
即便是在内网使用，安全问题也同样不能忽视。
如果没有一套安全方案，那么我们的服务很有可能会被攻击。

]]> 如果项目要上线到公网中，那么我们就需要考虑安全问题；
即便是在内网使用，安全问题也同样不能忽视。
如果没有一套安全方案，那么我们的服务很有可能会被攻击。

安全方案主要有加签名进行数据效验、传输数据加密等。

1、加签SHA256


public static string GetSHA256Hash(string input)
{
using (SHA256 sha256Hash = SHA256.Create())
{
byte[] bytes = sha256Hash.ComputeHash(Encoding.UTF8.GetBytes(input));
StringBuilder builder = new StringBuilder();
for (int i = 0; i < bytes.Length; i++)
{
builder.Append(bytes[i].ToString("x2"));
}
return builder.ToString();
}
}


2、RSA加密/解密


private readonly RSA _privateKeyRsaProvider;
private readonly RSA _publicKeyRsaProvider;
private readonly Encoding _encoding;
/// <param name="encoding">编码类型</param>
/// <param name="privateKey">私钥</param>
/// <param name="publicKey">公钥</param>
public RSAHelper(Encoding encoding, string privateKey, string publicKey = null)
{
_encoding = encoding;
if (!string.IsNullOrEmpty(privateKey))
{
_privateKeyRsaProvider = CreateRsaProviderFromPrivateKey(privateKey);
}
if (!string.IsNullOrEmpty(publicKey))
{
_publicKeyRsaProvider = CreateRsaProviderFromPublicKey(publicKey);
}
}
//解密
public string Decrypt(string cipherText)
{
if (_privateKeyRsaProvider == null)
{
throw new Exception("_privateKeyRsaProvider is null");
}
return Encoding.UTF8.GetString(_privateKeyRsaProvider.Decrypt(Convert.FromBase64String(cipherText), RSAEncryptionPadding.Pkcs1));
}
//加密
public string Encrypt(string text)
{
if (_publicKeyRsaProvider == null)
{
throw new Exception("_publicKeyRsaProvider is null");
}
return Convert.ToBase64String(_publicKeyRsaProvider.Encrypt(Encoding.UTF8.GetBytes(text), RSAEncryptionPadding.Pkcs1));
}


3、AES加密/解密


/// <summary>
/// 加密不带偏移量
/// </summary>
/// <param name="input"></param>
/// <param name="key">秘钥</param>
/// <returns></returns>
public static string EncryptByAES(string input, string key)
{
if (string.IsNullOrWhiteSpace(input))
{
return input;
}
using (RijndaelManaged rijndaelManaged = new RijndaelManaged())
{
rijndaelManaged.Mode = CipherMode.ECB;
rijndaelManaged.Padding = PaddingMode.PKCS7;
rijndaelManaged.FeedbackSize = 128;
byte[] data3 = Enumerable.Range(0, key.Length / 2).Select(x => Byte.Parse(key.Substring(x * 2, 2), NumberStyles.HexNumber)).ToArray();
rijndaelManaged.Key = data3;
ICryptoTransform encryptor = rijndaelManaged.CreateEncryptor(rijndaelManaged.Key, rijndaelManaged.IV);
using (MemoryStream msEncrypt = new MemoryStream())
{
using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                        {
using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
{
swEncrypt.Write(input);
}
byte[] bytes = msEncrypt.ToArray();
//return Convert.ToBase64String(bytes);
return HexConvert.byteToHexStr(bytes);
}
}
}
}

/// <summary>
/// 返回解密后的字符串
/// </summary>
/// <param name="input"></param>
/// <param name="key">秘钥</param>
/// <returns></returns>
public static string DecryptByAES(string input, string key)
{
if (string.IsNullOrWhiteSpace(input))
{
return input;
}
//var buffer = Convert.FromBase64String(input);
var buffer = HexConvert.strToToHexByte(input);
using (RijndaelManaged rijndaelManaged = new RijndaelManaged())
{
rijndaelManaged.Mode = CipherMode.ECB;
rijndaelManaged.Padding = PaddingMode.PKCS7;
rijndaelManaged.FeedbackSize = 128;
byte[] data3 = Enumerable.Range(0, key.Length / 2).Select(x => Byte.Parse(key.Substring(x * 2, 2), NumberStyles.HexNumber)).ToArray();
rijndaelManaged.Key = data3;
ICryptoTransform decryptor = rijndaelManaged.CreateDecryptor(rijndaelManaged.Key, rijndaelManaged.IV);
using (MemoryStream msEncrypt = new MemoryStream(buffer))
{
using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, decryptor, CryptoStreamMode.Read))
{
using (StreamReader srEncrypt = new StreamReader(csEncrypt))
{
return srEncrypt.ReadToEnd();
}
}
}
}
}


4、数据转换


//字符串转换为字节数组
byte[] originalBytes = System.Text.Encoding.UTF8.GetBytes(originalText);

// 进行Base64编码
string base64Encoded = Convert.ToBase64String(originalBytes);

// 进行Base64解码
byte[] base64DecodedBytes = Convert.FromBase64String(base64Encoded);

//字节数组转字符串
string base64DecodedText = System.Text.Encoding.UTF8.GetString(base64DecodedBytes);

//16进制转base64字符串
byte[] enterpriseCode_ = HexConvert.strToToHexByte(data.enterpriseCode);
string enterpriseCode = Convert.ToBase64String(enterpriseCode_);

/// <summary> 
/// 字节数组转16进制字符串 
/// </summary> 
/// <param name="byteArray"></param> 
/// <returns></returns> 
public static string byteToHexStr2(byte[] byteArray)
{
string hexString = BitConverter.ToString(byteArray);
return hexString.Replace("-", "");
}

/// <summary> 
/// 字符串转16进制字节数组 
/// </summary> 
/// <param name="hexString"></param> 
/// <returns></returns> 
public static byte[] strToToHexByte(string hexString)
{
hexString = hexString.Replace(" ", "");
if ((hexString.Length % 2) != 0)
hexString += " ";
byte[] returnBytes = new byte[hexString.Length / 2];
for (int i = 0; i < returnBytes.Length; i++)
returnBytes[i] = Convert.ToByte(hexString.Substring(i * 2, 2), 16);
return returnBytes;
}
]]> https://www.rickw.cn/blogview/339 C# .Net编程 rick 2024-12-23 12:48:57 <![CDATA[C# 中实现几种幻灯片中的窗口特效]]>
  • 淡入淡出
  • 变大变小
  • 缓升缓降

    ]]>
  • 淡入淡出
  • 变大变小
  • 缓升缓降


    实现的代码片段参考如下：

    淡入淡出
    [复制到剪贴板]

    public Form1()
            {
                    InitializeComponent();
                    Opacity = 0;
                    timer1.Interval = 10;
                    timer1.Start();
            }
       private     void timer1_Tick(object sender, EventArgs e)
            {

                if (    isShow)
                {
                    if (    Height < height)
                    {
                            Height += 1;
                    }
                    else
                    {
                            timer1.Stop();
                    }
                }
                else
                {
                    if (    ClientSize.Height > 0)
                    {
                            Height -= 1;
                    }
                    else
                    {
                            timer1.Stop();
                            Close();
                    }
                }
            } 



    变大变小
    [复制到剪贴板]

    public Form2()
            {
                    InitializeComponent();
                    height = Height;

                    Size = new Size(Width, 0);
                    timer1.Interval = 10;
                    timer1.Start();
            }
     
     private     void timer1_Tick(object sender, EventArgs e)
            {

                if (    isShow)
                {
                    if (    Height < height)
                    {
                            Height += 1;
                    }
                    else
                    {
                            timer1.Stop();
                    }
                }
                else
                {
                    if (    ClientSize.Height > 0)
                    {
                            Height -= 1;
                    }
                    else
                    {
                            timer1.Stop();
                            Close();
                    }
                }
            } 



    缓升缓降
    [复制到剪贴板]

    public Form3()
            {
                    InitializeComponent();
                    timer1.Interval = 10;
            }
            private     void Form3_Load(object sender, EventArgs e)
            {
                    Location = new Point(screenRect.Width - Width, screenRect.Height);
                    timer1.Start();
            }
     private     void timer1_Tick(object sender, EventArgs e)
            {
                if (    isShow)
                {
                    if (    Location.Y > screenRect.Height-Height)
                    {
                            Location = new Point(Location.X, Location.Y - 1);
                    }
                    else
                    {
                            timer1.Stop();
                    }
                }
                else
                {
                    if (    Location.Y < screenRect.Height )
                    {
                            Location = new Point(Location.X, Location.Y + 1);
                    }
                    else
                    {
                            timer1.Stop();
                            Close();
                    }
                }

            } 

    ]]> https://www.rickw.cn/blogview/332 C# .Net编程 rick 2024-01-05 21:33:35 <![CDATA[C#中byte[]字节数组复制的5种常用方法]]>
    1、for循环实现复制
    较为原始的遍历写法，不太推荐

    ]]>
    1、for循环实现复制
    较为原始的遍历写法，不太推荐

    byte[] data = new byte[]{0,1,2,3,4,5,6,7,8,9};

    byte[] data1 = new byte[data.length];

    for(int i=0;i<data1.length;i++)
    {
            data1[i] = data[i];
    }
    2、Arrary.Copy实现复制
    在CLR处理机制中最灵活，最强大,可装箱，拆箱复制，可加宽CLR基元类型，可内部判断实现了IFarmattable接口的兼容转换，当然这种强大方式必然会带来一定的性能损失。还有个CopyTo也是一样的。

    byte[] data = new byte[]{0,1,2,3,4,5,6,7,8,9};
    byte[] data1 = new byte[data.length];
    Array.Copy(data,data1,data.length);//源数据data，目标数据data1，复制长度data.length
    3、Clone实现复制
    Clone会创建新数组，分配内存，不宜用在需要保持高刷新率下的场景

     byte[] data = new byte[]{0,1,2,3,4,5,6,7,8,9};
     byte[] data1;
     data1 = (byte[])data .Clone()
    4、Buffer.BlockCopy实现复制
    则从本质上以字节为复制单位，这在底层语言C，C++的处理优势上，同理，效率之高可以理解。当然如果对性能要求不高，Copy足矣，毕竟在上千次复制下，三者基本没消耗多少时间。使用时可根据项目需求斟酌选择！

     byte[] srcArray = new byte[] { 0x01, 0x02, 0x03, 0x04 };
     byte[] dstArray = new byte[srcArray.Length];
     Buffer.BlockCopy(srcArray, 0, dstArray, 0, srcArray.Length);
     //源数据srcArray ， 起始位置0，目标数组dstArray ，开始位置0，多少长度 srcArray.Length
    5、Array.ConstrainedCopy 实现复制
    对复制要求严格，只能是同类型或者源数组类型是目标类型的派生元素类型，不执行装箱，拆箱，向下转换。

     byte[] srcArray = new byte[] { 0x01, 0x02, 0x03, 0x04 };
     byte[] dstArray = new byte[srcArray.Length];
     Array.ConstrainedCopy(srcArray, 0, dstArray, 0, srcArray.Length);
     //源数据srcArray ， 起始位置0，目标数组dstArray ，开始位置0，多少长度 srcArray.Length]]>     https://www.rickw.cn/blogview/324 C# .Net编程 rick 2023-12-27 11:17:44     <![CDATA[C# 使用 HttpClient错误？SocketException：现有连接被远程主机强行关闭]]>
    System.AggregateException
      HResult = 0x80131500
      Message =发生一个或多个错误。
    ]]>
    System.AggregateException
      HResult = 0x80131500
      Message =发生一个或多个错误。
      来源= System.Private.CoreLib
      堆栈跟踪：
       在System.Threading.Tasks.Task`1.GetResultCore（Boolean waitCompletionNotification）
      
    内部例外1：
    HttpRequestException：无法建立SSL连接，请参阅内部异常。

    内部例外2：
    IOException：无法从传输连接中读取数据：现有连接被远程主机强行关闭。

    内部例外3：
    SocketException：现有连接被远程主机强行关闭
    [复制到剪贴板]


    class Program
    {
        static     void Main(string[] args)
        {
            var     url = "https://google.com";
            var (    statusCode, html) = requestString(url);
                Console.WriteLine("%d %s", statusCode, html);
        }

        static     CookieContainer cc = new CookieContainer();

        static     HttpClientHandler handler = new HttpClientHandler { AllowAutoRedirect = false, CookieContainer = cc };

        public static     async Task<(int statusCode, string content)> requestStringAsync(string url)
        {
                ServicePointManager.ServerCertificateValidationCallback += (sender, cert, chain, sslPolicyErrors) => true;
                ServicePointManager.SecurityProtocol |= SecurityProtocolType.Tls | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12;
                                                                             // | SecurityProtocolType.Ssl3;
                using (var request = new HttpRequestMessage { RequestUri = new Uri(url), Method = HttpMethod.Get })
                using (var client = new HttpClient(handler))
            {
                var     response = await client.SendAsync(request); // Error (actual line)
             
                    var statusCode = (int)response.StatusCode;
                var     content = await response.Content.ReadAsStringAsync();
                return (    statusCode, content);
            }
        }

        public static (    int statusCode, string content) requestString(string url)
        {
            return     requestStringAsync(url).Result;
        }
    } 



    按上面调整 ServicePointManager 后在 .net framework环境中就可以正常运行了。

    在.Net Core的环境中还可能发生问题。

    .Net Core中可以使用以下机制之一来配置进程以使用较旧的HttpClientHandler：

    从代码中，使用AppContext类：

    AppContext.SetSwitch("System.Net.Http.UseSocketsHttpHandler", false);

    也可以通过配置文件来设置AppContext开关。

    可以通过环境变量DOTNET_SYSTEM_NET_HTTP_USESOCKETSHTTPHANDLER实现相同的目的。
    要选择退出，请将值设置为false或0。]]>     https://www.rickw.cn/blogview/317 C# .Net编程 rick 2023-12-22 00:17:40     <![CDATA[C#屏幕截图，指定区域截图，窗口截图的实现]]> 指定区域截图，只需要将屏幕图片按区域裁剪即可。
    指定窗口截图，先获取窗口的位置和大小，然后转化为指定区域截图了。
    如果是制作指定窗口的录屏程序时，需要注意实时跟踪窗口的位置和大小（窗口位置和大小可能会调整变化）。
    其它的就没有特别的了。
    ]]>     指定区域截图，只需要将屏幕图片按区域裁剪即可。
    指定窗口截图，先获取窗口的位置和大小，然后转化为指定区域截图了。
    如果是制作指定窗口的录屏程序时，需要注意实时跟踪窗口的位置和大小（窗口位置和大小可能会调整变化）。
    其它的就没有特别的了。

    例子代码：
    [复制到剪贴板]

    using System;
    using System.Drawing;
    using System.Runtime.InteropServices;

    class     Program
    {
        [    DllImport("user32.dll")]
        static     extern IntPtr GetForegroundWindow();

        [    DllImport("user32.dll")]
        [return:     MarshalAs(UnmanagedType.Bool)]
        static     extern bool GetWindowRect(IntPtr hWnd, out RECT lpRect);

        [    StructLayout(LayoutKind.Sequential)]
        public     struct RECT
            {
            public     int Left;
            public     int Top;
            public     int Right;
            public     int Bottom;
        }

        static     void Main()
        {
            try
            {
                    // 获取活动窗口句柄
                    IntPtr hWnd = GetForegroundWindow();

                    // 获取窗口位置和大小
                    RECT windowRect;
                    GetWindowRect(hWnd, out windowRect);

                    // 创建Bitmap对象
                    using (Bitmap bmp = new Bitmap(windowRect.Right - windowRect.Left, windowRect.Bottom - windowRect.Top))
                {
                        // 创建Graphics对象
                        using (Graphics g = Graphics.FromImage(bmp))
                    {
                            // 将窗口内容绘制到Bitmap中
                        // 这里可以直接指定位置和大小进行图片截取拷贝
                            g.CopyFromScreen(new Point(windowRect.Left, windowRect.Top), Point.Empty, bmp.Size);
                    }

                        // 保存屏幕截图（可根据需要进行保存）
                        bmp.Save("screenshot.png");
                    
                        Console.WriteLine("屏幕截图已保存成功。");
                }
            }
            catch (    Exception ex)
            {
                    Console.WriteLine("发生异常：" + ex.Message);
            }
        }
    } 

    ]]>     https://www.rickw.cn/blogview/316 C# .Net编程 rick 2023-12-21 12:11:46     <![CDATA[C#同步代码中调用async异步方法.Result等待导致阻塞死锁deadlock的问题]]> 导致死锁的例子代码：
    public static async Task<string> GetWebPageAsync(string uri)
    {
      //这里的 client 是全局初始化的 HttpClient 对象
        return  = await client.GetStringAsync(uri);
    }

    public void Button1_Click(object sender, EventArg e)
    {
      var webTask = GetWebPageAsync("_get_url_");
      textBox1.Text = webTask.Result;
    }

    ]]>     导致死锁的例子代码：
    public static async Task<string> GetWebPageAsync(string uri)
    {
      //这里的 client 是全局初始化的 HttpClient 对象
        return  = await client.GetStringAsync(uri);
    }

    public void Button1_Click(object sender, EventArg e)
    {
      var webTask = GetWebPageAsync("_get_url_");
      textBox1.Text = webTask.Result;
    }



    阻止死锁的两种办法：


    一、使用 ConfigureAwait(false)
    public static async Task<string> GetWebPageAsync(string uri)
    {
      //这里的 client 是全局初始化的 HttpClient 对象
        return  = await client.GetStringAsync(uri).ConfigureAwait(false);
    }


    默认情况下，当您使用async/await时，它将在开始请求的原始线程上继续运行(状态机)。但是，如果当前另一个长时间运行的进程已经接管了该线程，那么你就不得不等待它完成。要避免这个问题，可以使用ConfigureAwait的方法和false参数。当你用这个方法的时候，这将告诉Task它可以在任何可用的线程上恢复自己继续运行，而不是等待最初创建它的线程。这将加快响应速度并避免许多死锁。

    但是，当使用此方法后，线程同步上下文将丢失，从而转变成异步操作，如果在之后继续操作界面元素等，会提示线程不安全。


    二、使用 异步Async 方法进行调用：
    public async void Button1_Click(object sender, EventArg e)
    {
      var webTask = GetWebPageAsync("_get_url_");
      textBox1.Text = webTask.Result;
    }

    ]]>     https://www.rickw.cn/blogview/310 C# .Net编程 rick 2023-12-17 11:34:09     <![CDATA[解决C#编译问题 CS 1617：/langversion的选项“10”无效]]> 和VS版本有关，如果你使用的是VS2019，那么关闭项目，用文本打开csproj文件，将<LangVersion>10.0</LangVersion>改为<LangVersion>9.0</LangVersion>

    或者升级使用VS 2022打开项目进行编译。
    ]]>     导致死锁的例子代码：
    public static async Task<string> GetWebPageAsync(string uri)
    {
      //这里的 client 是全局初始化的 HttpClient 对象
        return  = await client.GetStringAsync(uri);
    }

    public void Button1_Click(object sender, EventArg e)
    {
      var webTask = GetWebPageAsync("_get_url_");
      textBox1.Text = webTask.Result;
    }



    阻止死锁的两种办法：


    一、使用 ConfigureAwait(false)
    public static async Task<string> GetWebPageAsync(string uri)
    {
      //这里的 client 是全局初始化的 HttpClient 对象
        return  = await client.GetStringAsync(uri).ConfigureAwait(false);
    }


    默认情况下，当您使用async/await时，它将在开始请求的原始线程上继续运行(状态机)。但是，如果当前另一个长时间运行的进程已经接管了该线程，那么你就不得不等待它完成。要避免这个问题，可以使用ConfigureAwait的方法和false参数。当你用这个方法的时候，这将告诉Task它可以在任何可用的线程上恢复自己继续运行，而不是等待最初创建它的线程。这将加快响应速度并避免许多死锁。

    但是，当使用此方法后，线程同步上下文将丢失，从而转变成异步操作，如果在之后继续操作界面元素等，会提示线程不安全。


    二、使用 异步Async 方法进行调用：
    public async void Button1_Click(object sender, EventArg e)
    {
      var webTask = GetWebPageAsync("_get_url_");
      textBox1.Text = webTask.Result;
    }

    ]]>     https://www.rickw.cn/blogview/300 C# .Net编程 rick 2023-12-10 11:58:25     <![CDATA[Jurassic [C# .Net JavaScript引擎]限制脚本执行时间，防止死循环]]>
    [复制到剪贴板]

    try {}
    finally {
        while (    true);} 


    [复制到剪贴板]

     while (true);  


    这样一个无限循环的js代码在 ScriptEngine.Execute(String code)的调用中将永远不会返回。
    ]]>
    [复制到剪贴板]

    try {}
    finally {
        while (    true);} 


    [复制到剪贴板]

     while (true);  


    这样一个无限循环的js代码在 ScriptEngine.Execute(String code)的调用中将永远不会返回。

    Jurassic没有本身没有实现限制脚本执行时间的功能。由于Jurassic将JavaScript方法编译为IL代码，没有简单的方式来实现超时功能而不影响性能。但是，我们可以在执行脚本的线程中调用Thread.Abort()引发ThreadAbortException来终止脚本的执行。

    一种实现方式：


    在新线程中执行 ScriptEngine.Execute()，在当前线程中进行等待并计时。当新线程在规定的时间内未完成，则在当前线程中调用
    thread.Abort()来终止新线程，并抛出一个超时的异常(TimeOutException)。


    用于限制脚本执行时间的Helper类（ScriptTimeoutHelper）


    [复制到剪贴板]

    using System;
    using System.Runtime.ExceptionServices;
    using System.Threading;
    using System.Threading.Tasks;

    namespace     JurassicTimeoutHelper
    {
            /// <summary>
        /// Allows to limit execution time of a Jurassic Script by internally using the
        /// technique of aborting a thread.
        /// </summary>
            public class ScriptTimeoutHelper
            {
            private     HandlerState currentState;

            public     ScriptTimeoutHelper()
            {
            }

                /// <summary>
            /// Runs the specified <see cref="Action"/> in the current thread,
            /// applying the given timeout.
            /// When the handler times out, a <see cref="ThreadAbortException"/> is
            /// raised in the current thread to break. However, this is managed
            /// internally so it does not affect the caller of this method (i.e. it is
            /// ensured that a <see cref="ThreadAbortException"/> does not flow through
            /// this method or raised after this method returns).
            /// </summary>
            /// <exception cref="TimeoutException">Thrown when the handler times 
            /// out.</exception>
            /// <param name="handler"></param>
            /// <param name="timeout"></param>
                public void RunWithTimeout(Action handler, int timeout)
            {
                if (    currentState != null)
                    throw new     InvalidOperationException(
                        $    "Cannot recursively call {nameof(RunWithTimeout)}.");
                if (    handler == null)
                    throw new     ArgumentException(nameof(handler));

                    // Throw the TimeoutException immediately when the timeout is 0.
                    if (timeout == 0)
                    throw new     TimeoutException();

                    ExceptionDispatchInfo caughtException = null;

                    using (var state = currentState =
                    new     HandlerState(Thread.CurrentThread))
                {
                        /* Start a monitoring task that may abort the current thread after
                     * the specified time limit.
                     * Note that the task will start immediately. Therefore we need to
                     * ensure the task does not abort the thread until we entered the
                     * try clause; otherwise the ThreadAbortException might fly through
                     * the caller of this method. To ensure this, the monitoring task
                     * waits until we release the semaphore the first time before
                     * actually waiting for the specified time.
                    */
                        using (var monitoringTask = Task.Run(async () =>
                            await RunMonitoringTask(state, timeout)))
                    {
                        try
                        {
                                bool waitForAbortException;
                            try
                            {
                                    // Allow the monitoring task to begin by releasing the
                                // semaphore the first time.
                                // Do this in a finally block to ensure if this thread
                                // is aborted by other code, the semaphore is still
                                // released.
                                    try { }
                                finally
                                {
                                        state.WaitSemaphore.Release();
                                }

                                    // Execute the handler.
                                    handler();
                            }
                            catch (    Exception ex) when (!(ex is ThreadAbortException))
                            {
                                    /* Need to catch all exceptions (except our own
                                 * ThreadAbortException) because we may wait for a
                                 * ThreadAbortException to be thrown which is not
                                 * possible in a finally handler.
                                 */
                                    caughtException = ExceptionDispatchInfo.Capture(ex);
                            }
                            finally
                            {
                                    /* Indicate that the handler is completed, and check
                                 * if we need to wait for the ThreadAbortException.
                                 * This is done in a finally handler to ensure when
                                 * other code wants to abort this thread, the thread
                                 * actually will abort as expected but we still can
                                 * notify the monitoring task that we already returned.
                                 */
                                    lock (state)
                                {
                                        state.IsExited = true;
                                        waitForAbortException =
                                            state.AbortState == AbortState.IsAborting;

                                    if (    state.AbortState == AbortState.None)
                                    {
                                            // If the monitoring task did not do anything
                                        // yet, allow it to complete immediately.
                                            state.WaitSemaphore.Release();
                                    }
                                }
                            }

                            if (    waitForAbortException)
                            {
                                    /* The monitoring task indicated that it will abort our
                                 * thread (but the ThreadAbortException did not yet
                                 * occur), so we need to wait for the
                                 * ThreadAbortException.
                                 * This wait is needed because otherwise we may return
                                 * too early (and in the finally block we wait for the
                                 * monitoring task, causing a deadlock).
                                 */
                                    Thread.Sleep(Timeout.Infinite);
                            }
                        }
                        catch (    ThreadAbortException ex)
                                when (ex.ExceptionState == state)
                        {
                                // Reset the abort.
                                Thread.ResetAbort();

                                // Indicate that the timeout has been exceeded.
                                throw new TimeoutException();
                        }
                        finally
                        {
                                // Wait for the monitoring task to complete.
                                monitoringTask.Wait();
                                currentState = null;
                        }
                    }
                }

                    // Check if we need to rethrow a caught exception (preserving the
                // original stacktrace).
                    if (caughtException != null)
                        caughtException.Throw();
            }

            private     async Task RunMonitoringTask(HandlerState state, int timeout)
            {
                    // Wait until the handler thread entered the try-block.
                // Use a synchronous wait because we expect this to be a very short
                // period of time.
                    state.WaitSemaphore.Wait();

                    // Now asynchronously wait until the specified time has passed or the
                // semaphore has been released. In the latter case there is no need to
                // call AbortExecution().
                    bool completed = await state.WaitSemaphore.WaitAsync(timeout);

                    // Abort the handler thread.
                    if (!completed)
                        AbortExecution(state);
            }

            private     void AbortExecution(HandlerState state)
            {
                    bool canAbort;
                    lock (state)
                {
                    if (    state.IsExited)
                    {
                            // The handler has already exited.
                            return;
                    }

                        // Check if we can call Thread.Abort() or if the handler thread is
                    // currently in a critical section and needs to abort himself when
                    // leaving the critical section.
                        canAbort = !state.IsCriticalSection;
                        state.AbortState = canAbort ? AbortState.IsAborting
                            : AbortState.ShouldAbort;
                }
                if (    canAbort)
                {
                        /* The handler thread is not in a critical section so we can
                     * directly abort it.
                     * This needs to be done outside of the lock because Abort() could
                     * block if the  thread is currently in a finally handler (and
                     * trying to lock on the state object), which could lead to a
                     * deadlock.
                     */
                        state.HandlerThread.Abort(state);
                }
            }

                /// <summary>
            /// Notifies this class that the handler thread is entering a critical
            /// section in which aborting the thread could corrupt the system's state.
            /// This means aborting the thread will be deferred until leaving the
            /// critical section.
            /// Note that you must call <see cref="ExitCriticalSection"/> in a
            /// <c>finally</c> block once the thread left the critical section.
            /// </summary>
                public void EnterCriticalSection()
            {
                if (    currentState == null)
                    throw new     InvalidOperationException();

                    bool waitForAbortException;
                    lock (currentState)
                {
                    if (    Thread.CurrentThread != currentState.HandlerThread
                            || currentState.IsCriticalSection)
                        throw new     InvalidOperationException();

                        currentState.IsCriticalSection = true;
                        waitForAbortException =
                            currentState.AbortState == AbortState.IsAborting;
                }
                if (    waitForAbortException)
                {
                        // The monitoring task indicated that it will abort our thread, so
                    // we need to wait for the ThreadAbortException.
                        Thread.Sleep(Timeout.Infinite);
                }
            }

            public     void ExitCriticalSection()
            {
                if (    currentState == null)
                    throw new     InvalidOperationException();

                    bool shouldAbort;
                    lock (currentState)
                {
                    if (    Thread.CurrentThread != currentState.HandlerThread
                            || !currentState.IsCriticalSection)
                        throw new     InvalidOperationException();

                        currentState.IsCriticalSection = false;
                        shouldAbort = currentState.AbortState == AbortState.ShouldAbort;
                }
                if (    shouldAbort)
                {
                        // The monitoring task indicated that it wanted to abort our
                    // thread while we were in a critical section, so we need to abort
                    // ourselves.
                        Thread.CurrentThread.Abort(currentState);
                }
            }

            private     enum AbortState
                {
                    /// <summary>
                /// Indicates that the monitoring task has not yet done any action.
                /// </summary>
                    None = 0,

                    /// <summary>
                /// Indicates that the monitoring task is about to abort the handler
                /// thread.
                /// </summary>
                    IsAborting = 1,

                    /// <summary>
                /// Indicates that the monitoring task wanted to abort the handler
                /// thread but the handler thread was in a critical section, and needs
                /// to abort itself when leaving the critical section.
                /// </summary>
                    ShouldAbort = 2
                }

            private class     HandlerState : IDisposable
                {

                public     Thread HandlerThread { get; }

                public     SemaphoreSlim WaitSemaphore { get; } = new SemaphoreSlim(0);

                public     bool IsCriticalSection { get; set; }

                    /// <summary>
                /// Indicates if the handler is already completed (so there's no need
                /// to abort the thread).
                /// This flag is set by the handler thread.
                /// </summary>
                    public bool IsExited { get; set; }

                    /// <summary>
                /// Indicates that the wait task wanted to abort the handler thread but
                /// the handler thread was in a critical section, and needs to abort
                /// itself when leaving the critical section.
                /// This flag is set by the wait task.
                /// </summary>
                    public AbortState AbortState { get; set; }


                public     HandlerState(Thread handlerThread)
                {
                        this.HandlerThread = handlerThread;
                }

                ~    HandlerState()
                {
                        Dispose(false);
                }

                public     void Dispose()
                {
                        Dispose(true);
                        GC.SuppressFinalize(this);
                }

                protected     void Dispose(bool disposing)
                {
                    if (    disposing)
                    {
                            WaitSemaphore.Dispose();
                    }
                }
            }
        }
    } 



    原来执行javascpript的方式如下：
    [复制到剪贴板]

    var engine = new ScriptEngine();
    var     compiledScript = engine.Compile(new StringScriptSource(
            "while (true) ;"));
    compiledScript.Execute(); 



    改进后新的执行javascpript的方式如下：


    [复制到剪贴板]

    var timeoutHelper = new ScriptTimeoutHelper();
    var     engine = new ScriptEngine();
    var     compiledScript = engine.Compile(new StringScriptSource(
            "while (true) ;"));
    try{
    timeoutHelper.RunWithTimeout(() => compiledScript.Execute(), 1000);
    }
    catch(    TimeoutException ex){
    //这里表示执行超时
    }
     



    注意事项：


    我们使用useScriptEngine.Compile()首先编译脚本，然后将超时仅应用于实际执行脚本。
    上面的调用代码设置的超时时间是1秒，如果JavaScript未在1秒钟内完成，我们将捕获到TimeoutException异常。


    注：在发生TimeoutException以后，我们不应该继续使用ScriptEngine及其关联的对象实例，因为它们可能处于不一致/不可用状态。而是创建一个新的ScriptEngine实例以运行更多脚本文件。

    ]]>     https://www.rickw.cn/blogview/283 C# .Net编程 rick 2023-12-01 23:12:13     <![CDATA[介绍一个C#的javascpript引擎 Jurassic]]> ECMAScript 6的支持还在开发中，已经支持了es6的大部分特性。

    性能好：它将JavaScript编译为.NET字节码（CIL），而非解释执行。这样使得它的运行性能更好；

    ]]>     ECMAScript 6的支持还在开发中，已经支持了es6的大部分特性。

    性能好：它将JavaScript编译为.NET字节码（CIL），而非解释执行。这样使得它的运行性能更好；

    纯.Net开发：纯.Net开发，不依赖任何第三方库，只有单个dll文件，可以完全集成到.Net框架中，可以在任何支持.Net平台执行；

    使用：
    1，可以直接用 NuGet 获取 Jurassic。
    using Jurassic;

    简单的执行js字符串
    var engine = new Jurassic.ScriptEngine();
     engine.Evaluate("function main(a,b){return a+b;}");
    var addResult= engine.CallGlobalFunction("main", 5, 6);//结果11


    2，.Net 和 javascpript 之间交互。
    暴露net的class给js
    [复制到剪贴板]


    using Jurassic    ;
    using Jurassic.Library;

    public class     AppInfo : ObjectInstance
    {
        public     AppInfo(ScriptEngine engine)
            :     base(engine)
        {
                // 重写name属性
                this["name"] = "Test Application";

                // 只读属性
                this.DefineProperty("version", new PropertyDescriptor(5, PropertyAttributes.Sealed), true);
        }
    }
     
    engine.SetGlobalValue("appInfo", new AppInfo(engine));
    Console.WriteLine(engine.Evaluate<string>("appInfo.name + ' ' + appInfo.version")); 



    暴露net的class的静态方法
    [复制到剪贴板]


    using Jurassic    ;
    using Jurassic.Library;

    public class     Math2 : ObjectInstance
    {
        public     Math2(ScriptEngine engine)
            :     base(engine)
        {
                this.PopulateFunctions();
        }

        [    JSFunction(Name = "log10")]
        public static     double Log10(double num)
        {
            return     Math.Log10(num);
        }
    }
     
    engine.SetGlobalValue("math2", new Math2(engine));
    engine.Evaluate<double>("math2.log10(1000)"); 



    暴露net的类实例
    [复制到剪贴板]


    using Jurassic    ;
    using Jurassic.Library;

    public class     RandomConstructor : ClrFunction
    {
        public     RandomConstructor(ScriptEngine engine)
            :     base(engine.Function.InstancePrototype, "Random", new RandomInstance(engine.Object.InstancePrototype))
        {
        }

        [    JSConstructorFunction]
        public     RandomInstance Construct(int seed)
        {
            return new     RandomInstance(this.InstancePrototype, seed);
        }
    }

    public class     RandomInstance : ObjectInstance
    {
        private     Random random;

        public     RandomInstance(ObjectInstance prototype)
            :     base(prototype)
        {
                this.PopulateFunctions();
                this.random = new Random(0);
        }

        public     RandomInstance(ObjectInstance prototype, int seed)
            :     base(prototype)
        {
                this.random = new Random(seed);
        }

        [    JSFunction(Name = "nextDouble")]
        public     double NextDouble()
        {
            return     this.random.NextDouble();
        }
    }
     
     
    engine.SetGlobalValue("Random", new RandomConstructor(engine));
    engine.Evaluate<double>("var rand = new Random(1000); rand.nextDouble()"); 


    ]]>     https://www.rickw.cn/blogview/279 C# .Net编程 rick 2023-11-30 14:25:34     <![CDATA[C#等效于php的password_verify 和 password_hash 功能的函数实现]]> C#中能够等价于 php password_verify 和 password_hash 功能的实现方法。
    有时候可能会需要在C#程序中来验证 php 生成的哈希密码。实现php系统和C#系统的密码互通。
    例如：将php系统迁移到 .NetCore的系统。
    或者混合使用php系统和.NetCore系统。

    ]]>     C#中能够等价于 php password_verify 和 password_hash 功能的实现方法。
    有时候可能会需要在C#程序中来验证 php 生成的哈希密码。实现php系统和C#系统的密码互通。
    例如：将php系统迁移到 .NetCore的系统。
    或者混合使用php系统和.NetCore系统。

    一种保底的实现，间接方式


    使用php开发一个api接口，公开给C#调用。


    直接C#实现的方式


    php的 password_hash 使用的是Blowfish加密算法。我们避免重复造轮子，可以利用现成的类库【CryptSharp】。
    C#中实现的验证密码代码如下：
    [复制到剪贴板]

    using CryptSharp;
    //等价于PHP的 password_verify 函数
    // 验证密码是正确
    // inputPassword 用户输入的密码
    // hashcryptedPassword PHP的password_hash哈希加密的密码
    //
    bool isOK = Crypter.CheckPassword(inputPassword, hashcryptedPassword);
     



    当然我们也可以在C#中实现PHP password_hash 等效的加密功能：
    [复制到剪贴板]

    using CryptSharp;
    //等效于PHP的 password_hash 函数
    // 和PHP使用相同的加密算法： Blowfish crypt ("BCrypt") 
    //
    string hashcryptedPassword = Crypter.Blowfish.Crypt(password);
     




    类库【CryptSharp】下载


    C#加密库CryptSharp_2_1_0.zip
    ]]>     https://www.rickw.cn/blogview/277 C# .Net编程 rick 2023-11-29 11:19:37