## 引言

最近做一个配置的功能，需求是该配置项跟另一个整形配置项关联，具有一定的函数关系，例如有一个配置项是值为 `N` ，则另一配置 `F` 项满足函数关系$F=2/(N+1)$。这个函数关系是客户手动输入，只需要简单的四则运算，所以我们要做的就是判断四则运算表达式是否有效，且给定 `N` 的值，算出表达式的值。

如何快速判断一个四则运算公式字符串是否符合规则，且根据给定值计算出该公式的值？



## 双栈实现

实际上编译器就是利用了双栈实现了的表达式求值，其中一个栈用来保存操作数，另一个栈用来保存运算符。

从左向右遍历表达式，当遇到数字时，就将其直接压入操作数栈；当遇到运算符时，就将其与运算符栈的栈顶元素比较。

如果遇到的运算符比运算符栈顶的元素的优先级高，就将这个运算符压入栈；

如果遇到的运算符比运算符栈顶的元素的优先级低或两者相同，就从运算符栈顶取出运算符，在从操作数栈顶取两个操作数，然后进行计算，并把计算的得到的结果压入操作数栈，继续比较这个运算符与运算符栈顶的元素；

下图表示一个简单四则运算表达式 `3+5*8-6`的计算过程：

![image.png](https://niuery.com/static/img/179736aa50301d68ddf5995fcc6f3305.image.png)

代码实现可以大概简化可以分为以下步骤：

1. 定义运算符栈 `operatorStack` 和操作数栈 `operandStack` 。

2. 从左至右扫描表达式,遇到操作数时,直接将其推入操作数栈 `operandStack` 。

3. 遇到运算符时,比较其与运算符栈顶部运算符的优先级:

    - 如果该运算符的优先级高于或等于运算符栈顶部运算符,则将该运算符直接入栈 `operatorStack` 。

    - 如果该运算符的优先级低于运算符栈顶部运算符,则将运算符栈顶部的运算符出栈,从操作数栈中弹出两个操作数,计算结果后再入栈 `operandStack` ,重复此步骤直到运算符栈为空或遇到优先级高于或等于该运算符的栈顶运算符为止。

4. 遇到括号时:
    - 如果是左括号“(”,则直接入栈 `operatorStack` 。

    - 如果是右括号“)”,则将运算符栈栈顶的运算符出栈,从操作数栈中弹出两个操作数计算结果,重复此步骤直到遇到左括号为止,并将这一对括号从运算符栈中移除。

5. 重复步骤3和4,直到表达式的最右端。

6. 将运算符栈中剩余的所有运算符依次出栈,从操作数栈中弹出两个操作数,计算结果后入栈operandStack。

7. 操作数栈最终只剩一个操作数,这就是表达式的计算结果。

具体实现代码如下：

```csharp
class ExpressionEvaluator
{
    static Dictionary<char, int> PrecedenceDic = new Dictionary<char, int> {
            {'+', 1}, {'-', 1}, {'*', 2}, {'/', 2}, {'^', 3}
        };

    static Dictionary<char, Func<int, int, int>> OperatorsDic = new Dictionary<char, Func<int, int, int>> {
            {'+', (a, b) => a + b },
            {'-', (a, b) => a - b },
            {'*', (a, b) => a * b },
            {'/', (a, b) => a / b },
            {'^', (a, b) => (int)Math.Pow(a, b)}
        };

    public static bool EvaluateExpression(string expression, out double result)
    {
        result = 0;
        try
        {
            // 使用正则表达式验证四则运算表达式的有效性
            string pattern = @"^[-+*/^() x\d\s]+$";

            if (!Regex.IsMatch(expression, pattern))
            {
                return false;
            }
            //操作符栈
            Stack<char> operatorStack = new Stack<char>();
            //操作数栈
            Stack<int> operandStack = new Stack<int>();

            for (int i = 0; i < expression.Length; i++)
            {
                char c = expression[i];

                if (c == ' ') continue;

                if (char.IsDigit(c))
                {
                    //获取操作数
                    int operand = 0;
                    while (i < expression.Length && char.IsDigit(expression[i]))
                    {
                        operand = operand * 10 + (expression[i++] - '0');
                    }
                    i--;
                    operandStack.Push(operand);
                }
                else if (OperatorsDic.ContainsKey(c))
                {
                    while (operatorStack.Count > 0 &&
                        OperatorsDic[c] != null && operatorStack.Peek() != '(' &&
                        PrecedenceDic[operatorStack.Peek()] >= PrecedenceDic[c])
                    {
                        int b = operandStack.Pop();
                        int a = operandStack.Pop();
                        operandStack.Push(OperatorsDic[operatorStack.Pop()](a, b));
                    }
                    operatorStack.Push(c);
                }
                else if (c == '(')
                {
                    operatorStack.Push(c);
                }
                else if (c == ')')
                {
                    while (operatorStack.Peek() != '(')
                    {
                        int b = operandStack.Pop();
                        int a = operandStack.Pop();
                        operandStack.Push(OperatorsDic[operatorStack.Pop()](a, b));
                    }
                    operatorStack.Pop();
                }
            }

            while (operatorStack.Count > 0)
            {
                int b = operandStack.Pop();
                int a = operandStack.Pop();
                operandStack.Push(OperatorsDic[operatorStack.Pop()](a, b));
            }
            result = operandStack.Pop();

            return true;
        }
        catch (Exception)
        {
            return false;
        }
    }
}
```
那接下来测试一下代码，因为代码内只做了整形的计算，所以表达式也只用整形。

![image.png](https://niuery.com/static/img/6d1f76e804d309a034bce9010ed0254d.image.png)

## 官方API

实际上微软官方在 `System.Data` 库中 `DataTable.Compute(String, String)`方法实现了计算表达式，代码如下 

```csharp
using System;
using System.Data;
using System.Text.RegularExpressions;

public class ArithmeticExpressionEvaluator
{
    public static bool IsArithmeticExpression(int arg, string str, out double result)
    {
        result = 0;

        // 验证字符串是否包含有效的四则运算表达式
        if (!IsValidArithmeticExpression(str) || !str.ToLower().Contains("x".ToLower()))
        {
            return false;
        }

        // 将字符串中的变量x替换为传入的整数arg
        string expression = str.Replace("x", arg.ToString());

        // 计算并返回表达式的值
        try
        {
            return double.TryParse(new DataTable().Compute(expression, "").ToString(), out result);
        }
        catch
        {
            return false;
        }
    }

    private static bool IsValidArithmeticExpression(string str)
    {
        // 使用正则表达式验证四则运算表达式的有效性
        string pattern = @"^[-+*/() x\d\s]+$";
        return Regex.IsMatch(str, pattern);
    }
}
class Program
{
    public static void Main()
    {
        while (true)
        {
            string expression = Console.ReadLine();
            string arg = Console.ReadLine();

            if (ArithmeticExpressionEvaluator.IsArithmeticExpression(int.Parse(arg), expression, out double result))
            {
                Console.WriteLine($"The result of the arithmetic expression is: {result}");
            }
            else
            {
                Console.WriteLine("The input string is not a valid arithmetic expression.");
            }
        }
    }
}
```

测试结果：

![image.png](https://niuery.com/static/img/b30dfb2819c69f92a821d3e961767df8.image.png)

## 总结

刚开始拿到这个需求还是有点头疼的，想了很久的方案，突然想到之前看数据结构的书的时候，提到过栈在表达式求值中的应用，翻书看了一下，还是被这个实现方案惊艳到了，所以，还是需要多读多看多思考，才能在面对各种需求游刃有余，加油~

编码技巧 --- 如何实现字符串运算表达式的计算

## 引言

最近想把一些英文官方文档的资料翻译成中文，然后转化为Markdown文档，然后发现[百度通用翻译的API](https://fanyi-api.baidu.com/doc/21)有不错的免费额度，个人申请也能申请到高级版。这个额度足够个人的日常使用了。

![image.png](https://niuery.com/static/img/137ebde496e29359c97ed1b9cd904d03.image.png)

## 如何使用
如何使用通用翻译API？
- 使用您的百度账号登录[百度翻译开放平台](http://api.fanyi.baidu.com/)；
- 注册成为开发者，获得 APPID ；
- 进行开发者认证（如仅需标准版可跳过）；
- 开通通用翻译API服务：[开通链接](https://fanyi-api.baidu.com/choose)；
- 参考技术文档和 Demo 编写代码。

注册完毕后，就可以在百度开放翻译平台的管理控制台看到APPID和密钥，这样就可以通过直接调用翻译API了。

以下内容来自百度翻译开放平台官方文档：
### API地址

通用翻译API通过 HTTP 接口对外提供多语种互译服务。您只需要通过调用通用翻译API，传入待翻译的内容，并指定要翻译的源语言（支持源语言语种自动检测）和目标语言种类，就可以得到相应的翻译结果。

通用翻译API HTTPS 地址：

```js
https://fanyi-api.baidu.com/api/trans/vip/translate
```
### 输入参数
请求方式： 可使用 `GET` 或 `POST` 方式，如使用 `POST` 方式，`Content-Type` 请指定为：`application/x-www-form-urlencoded` 。

字符编码：统一采用 UTF-8 编码格式。

query 长度：为保证翻译质量，请将单次请求长度控制在 6000 bytes以内（汉字约为输入参数 2000 个）。

![image.png](https://niuery.com/static/img/2e0e2b3ba236443d9b1bece990d2a72f.image.png)

### 输出参数

返回的结果是json格式，包含以下字段：

![image.png](https://niuery.com/static/img/af97155a4e64c550548ef109d6864b3e.image.png)

### 错误码

当翻译结果无法正常返回时，请参考下表处理

![image.png](https://niuery.com/static/img/28f1830083ea908b460dc41a5f7651c4.image.png)


### 签名生成

**这里需要特别注意，签名生成容易出错！**。

签名生成分为两步：
1. 将请求参数中的 APPID(appid)， 翻译 query(q，注意为UTF-8编码)，随机数(salt)，以及平台分配的密钥(可在管理控制台查看) 按照 appid+q+salt+密钥的顺序拼接得到字符串 1。
2. 对字符串 1 做 MD5 ，得到 32 位小写的 sign（注意一定转小写）。

除此之外，需要注意以下几点：

- 待翻译文本（q）需为 UTF-8 编码；
- 在生成签名拼接 appid+q+salt+密钥 字符串时，q 不需要做 URL encode，在生成签名之后，发送 HTTP 请求之前才需要对要发送的待翻译文本字段 q 做 URL encode；
- 如遇到报 54001 签名错误，请检查您的签名生成方法是否正确，在对 sign 进行拼接和加密时，q 不需要做 URL encode，很多开发者遇到签名报错均是由于拼接 sign 前就做了 URL encode；
- 在生成签名后，发送 HTTP 请求时，如果将 query 拼接在URL上，需要对 query 做 URL encode。


## 控制台程序Demo

接下来根据自己需要，参考上文中的参数，编写C#控制台程序，测试调用API接口。

```csharp
using System;
using System.Net.Http;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
using System.Web;

class Program
{
    static async Task Main(string[] args)
    {
        while (true)
        {
            var originalText = Console.ReadLine();
            await Translate(originalText);
        }
    }

    static async Task Translate(string originalText)
    {
        string APP_ID = "*************";//您的APPID

        string SecretKey = "****************";//您的密钥

        Random random = new Random();

        string salt = random.Next(10000, 99999).ToString();
        // appid + q + salt + 密钥的MD5值
        string sign = MD5Encrypt(APP_ID + originalText + salt + SecretKey);
        // 将输入的字符串进行URL编码并构造HTTP请求URL
        string url = $"https://fanyi-api.baidu.com/api/trans/vip/translate?" +
                     $"q={HttpUtility.UrlEncode(originalText)}" +
                     $"&from=en" +
                     $"&to=zh" +
                     $"&appid={APP_ID}" +
                     $"&salt={salt}" +
                     $"&sign={sign}";

        try
        {
            using (HttpClient client = new HttpClient())
            {
                // 发送GET请求并获取响应内容
                HttpResponseMessage response = await client.GetAsync(url);
                
                string responseBody = await response.Content.ReadAsStringAsync();
                // 解析响应JSON并输出翻译结果
                dynamic result = Newtonsoft.Json.JsonConvert.DeserializeObject(responseBody);
                
                Console.WriteLine($"{originalText} 的中文翻译为：{result.trans_result[0].dst}");
            }
        }
        catch (HttpRequestException e)
        {
            Console.WriteLine($"发生HTTP请求错误： {e.Message}");
        }
    }
    
    public static string MD5Encrypt(string input)
    {
        byte[] inputBytes = Encoding.UTF8.GetBytes(input);

        using (MD5 md5 = MD5.Create())
        {
            byte[] hashBytes = md5.ComputeHash(inputBytes);
            
            return BitConverter.ToString(hashBytes).Replace("-", "").ToLower();
        }
    }
}
```
示例图：

![image.png](https://niuery.com/static/img/5c469b0bd61165a54d4d86ea15a9873b.image.png)

小工具 --- 百度翻译API翻译工具

工具 --- IL指令集解释

## 引言

先不论什么是闭包，什么是闭包陷阱，我们开篇先看一段代码：

```csharp
static void Main(string[] args)
{
    List<Action> lists = new List<Action>();

    for (int i = 0; i < 5; i++)
    {
        Action action = () => { Console.WriteLine(i); };

        lists.Add(action);
    }

    foreach (var action in lists)
    {
        action();
    }

    Console.ReadLine();
}
```
那么思考一下，控制台输出是什么？



## 闭包陷阱

上述代码的本意是想让 `Action`声明的匿名委托方法接收 `i` 的值，并输出

```csharp
0
1
2
3
4
```
但实际上，上述代码输出的是

```csharp
5
5
5
5
5
```
为什么会这样？就需要提到两个个概念，**变量作用域**和**闭包**。

**变量作用域就不说了，就是指变量可以被访问的范围。例如全局变量，局部变量等**。

**闭包：简单点说，就是函数和其引用的上下文的组合体，就是一个闭包。**，例如上文代码中，`for` 循环内部，匿名方法内引用了变量 `i` ，那么变量 `i` 和匿名方法 `() => { Console.WriteLine(i); }` 就组合成了一个闭包，在 `for` 循环中，变量 `i` 就是一个局部变量，但是在闭包中，变量 `i` 对于匿名方法来说就是全局变量。相当于这样：

```csharp
int i;

public void AnonymousMethod()
{
    Console.WriteLine(i);
}
```
所以，当 `for` 循环结束时，在闭包内的全局变量 `i` 的值就已经变成了5。则下面 `foreach` 代码每次执行输出均为5。

## 根据IL探究原理

实际上，编译器在执行的时候，也确实为闭包生成了一个类，这个类只包含了一个方法和一个全局变量。

来验证一下，将上述代码编译为dll后，通过ILDasm.exe工具查看生成的IL代码

![image.png](https://niuery.com/static/img/8b51e449c9ac390de9f60a9f9349e796.image.png)

可以看到IL为闭包生成了一个类 `<>c_DisplayClass0_0` ,这个类只包含了一个变量 `i`，如下：

![image.png](https://niuery.com/static/img/a4254f46e6e9af97aeac5968dc052107.image.png)

还包含了一个匿名方法`<Main>b_0:void`，从IL中，也可以看出，先取 `<>c_DisplayClass0_0` 的变量 `i` ，再调用控制台输出方法。如下：

![image.png](https://niuery.com/static/img/8fb799edead362055a7e26b6139deed3.image.png)

接下来，在看一下整个控制台程序 `Main` 方法的IL代码：

![image.png](https://niuery.com/static/img/b8db9ab5aa10eaf5a6a6f59be4e8415a.image.png)

在IL_0007行，可以看到，声明创建一个 `Action` 后就紧接着创建了一个 `<>c_DisplayClass0_0` 对象。且 `for` 循环的变量 `i` 就是 `<>c_DisplayClass0_0` 对象的变量 `i` （注意这里指的是引用，并不是值），这样，在循环结束的时候，对象的变量 `i` 就变成了5。

这样就可以解释为什么输出会是5了。

:::info{title="相关信息"}
需要注意的是，`Action action = () => { Console.WriteLine(i); };`这句代码只是声明了一个委托，委托绑定的是一个匿名方法，并没有真正执行，只有调用该委托的时候才真正执行。比如 `action()` 或 `action.Invoke()`。
:::

## 如何避免闭包陷阱

在上面的探究原理的过程中，其实也发现了追根究底的问题其实就是，在创建闭包对象的时候，引用的局部变量，在外部被修改（比如上面代码中的`for` 循环的变量 `i` 就是闭包对象的变量 `i`，指的是指针是同一个），那么可以在创建闭包对象的时候，重新创建一个指针对象，将预期值赋值给它就可以了，比如上面的示例代码可以这样修改：

```csharp
static void Main(string[] args)
{
    List<Action> lists = new List<Action>();

    for (int i = 0; i < 5; i++)
    {
        int temp = i;
        Action action = () => { Console.WriteLine(temp); };
        lists.Add(action);
    }

    foreach (var action in lists)
    {
        action();
    }

    Console.ReadLine();
}

```
这样，闭包对象的变量就不再是 `for` 循环的 `i` 了，也就不会再被修改。输出结果为：

```csharp
0
1
2
3
4
```

编码技巧 --- 谨防闭包陷阱

## 引言

**dynamic** 是 `Framework 4.0` 就出现特性，它的出现让 C# 具有了弱语言类型的特性。编译器在编译的时候不再对类型进行检查，默认 **dynamic** 对象支持开发者想要的任何特性。



## dynamic 介绍

在C#中，dynamic是一种类型，它允许你在运行时动态地确定对象的类型。

使用dynamic类型可以使代码更加灵活，因为不需要在编译时知道对象的确切类型，而可以在运行时根据需要确定类型。

### 确保dynamic对象调用有效

但是正因为你不知道对象的确切类型，所以在编码时一定要注意，确保对象的类型和属性和方法的存在，否则代码可能会引发运行时异常。

比如以下代码：

```csharp
static void Main(string[] args)
{
    dynamic dynamicObject = new Person();
    
    var attr1 = dynamicObject.Name;
    
    var attr2 = dynamicObject.GetAge();

    Console.ReadLine();
}


public class Person
{
    public string Gender { get; set; }
    
    public string Name { get; set; }
    
    public int MakeMoney()
    {
        return 200;
    }
}
```

上述在编译时是不会报错的，但是在运行时，执行第二句是没问题的，因为得到的 `dynamicObject` 对象是有 `Name` ，`Gender` 两个属性的，但是执行第三句时就会抛出异常 `Microsoft.CSharp.RuntimeBinder.RuntimeBinderException` ，并提示 `does not contain a definition for 'GetAge'`。

### dynamic 与 var

有时候会将 `var` 关键字与 `dynamic` 进行对比，那么我觉得主要有以下几点：
1.  `var` 用于在编译时推断变量类型，可以将其视为一种简写方式，将变量类型的声明推迟到编译时。而 `dynamic` 则是一种在运行时动态确定对象类型的类型。它允许您在运行时调用对象的属性和方法，而不需要在编译时确定对象的确切类型。
2.  `var`声明的变量在Visual Studio编译器中能够使用IntelliCode进行“智能提示”，因为Visual Studio编译器在此阶段是可以推断出其实际类型，而`dynamic` 类型的变量不可以进行”智能提示“。
3.  `var` 类型的变量可以使代码更加简洁和易于阅读，而使用 `dynamic` 类型的变量则可以使代码更加灵活和动态。 

## 使用 dynamic 简化反射

常规使用反射，调用上文中 `Person` 类 `MakeMoney()`方法，如下：

```csharp
Person person = new Person();

var method = typeof(Person).GetMethod("MakeMoney");

int moneys = (int)method.Invoke(person, null);
```
那如果使用 **dynamic** 进行简化，则像这样：

```csharp
dynamic person = new Person();

int moneys = person.MakeMoney();
```
这样使用 **dynamic** 后，代码更简洁，而且也减少了一次拆箱操作。

[基准测试工具 --- BenchmarkDotNet](https://niuery.com/post/58)这篇文章中，介绍了使用 **BenchmarkDotNet** 来测试性能，接下来依然使用 **BenchmarkDotNet** 来测试以下，测试一下执行100000次，上述两种方式的区别：

```csharp
static void Main(string[] args)
{
    BenchmarkRunner.Run<BenchmarkTest>();
}

[SimpleJob(RunStrategy.ColdStart, iterationCount: 100000)]
[MemoryDiagnoser]
public class BenchmarkTest
{
    [Benchmark()]
    public int UseReflection()
    {
        Person person = new Person();

        var method = typeof(Person).GetMethod("MakeMoney");

        int moneys = (int)method.Invoke(person, null);

        return moneys;
    }

    [Benchmark()]
    public int UseDynamic()
    {
        dynamic person = new Person();

        int moneys = person.MakeMoney();

        return moneys;
    }
}

```

看一下 **BenchmarkDotNet** 测试结果，从报告中能看出来，使用 Dynamic 方式的方法的平均执行时间（Mean）和内存分配（AllLocated）时远小于使用反射实现的。

![image.png](https://niuery.com/static/img/6525a4af3162ab178d8351644358b473.image.png)


## 结论

在相同数量级的反射实现和使用 Dynamic 方式实现， Dynamic 方式在执行时间或内存分配或代码简洁都是有优势的，所以**推荐使用 dynameic 来简化反射实现**。