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