想用C#做一个类似于excel里的公式库以及公式的运算模块，可以自定义函数，并可以解析公式并运算

Question

主要包括数学计算函数、逻辑判断函数、文本函数、时间日期函数等，应用场合是模型平台，表达模型中不同参数之间的关系，存储介质是数据库，不是应用于类似于excel的表格。不知有没有类似的开源代码，或者有什么好的建议。谢谢！

Answer 1

1.工具－－宏－录制新宏－确定。

2.在宏窗口上“停止录制”

3.工具－宏－宏,点击macro1－编辑，进入一个窗口，把里面的内容全部删除，粘贴下面代码：
Function GetNum(b)
Dim i As Integer
Dim Al As String
For i = 1 To Len(b)
Al = Mid(b, i, 1)
If IsNumeric(Al) Or Al = "." Then
GetNum = GetNum & Al
End If
Next
End Function

选中一个单元格后，输入： =getnum(a1)

如果提取不是数字的，就改成：

Function Getstr(b)
Dim i As Integer
Dim Al As String
For i = 1 To Len(b)
Al = Mid(b, i, 1)
If not IsNumeric(Al) Then
Getstr= Getstr & Al
End If
Next
End Function

选中一个单元格后，输入： =getstr(a1)

Answer 2

直接增加这几个宏就好了

#define MK_FP( seg,ofs )( (void _seg * )( seg ) +( void near * )( ofs ))
#define FP_SEG( fp )( (unsigned )( void _seg * )( void far * )( fp ))
#define FP_OFF( fp )( (unsigned )( fp ))

Answer 3

也许他们没懂你什么意思，但是我差不多懂了你的意思，因为我最近也在做这些，我在做套版，客户自定义公式，获取自己想要的结果，像EXCEL一样输入公式就获得值。

我是建议你不要做什么反射，用什么js反编译，会降低你的软件性能，不参与什么编译，字符串转代码的事情，简单的循环一般的CPU还是应付得了的。

做这个事情首先你要内置函数，像EXCEL一样，他其实内置了封装函数，然后判断字符串去转义，我简单举例，看对你由帮助没有：

using System;
using System.Linq;
using System.Windows.Forms;

namespace mutua
{
    public class anys
    {
            //year函数
        public string year(string datestr)
        {
            return Convert.ToString(Convert.ToDateTime(datestr.Replace("\"", "")).Year);
        }
        //left函数
        public string left(string str, int len)
        {
            try
            {
                return str.Substring(0, len);
            }
            catch
            {
                return "#N/A";
            }
        }
        //公式解析
        public string gs(string gsstr)
        {
            //用一个数组去记录公式里的连接符嵌套函数体
            string[] gst = null;
            if (gsstr != "")
            {
                //用等于号开始
                if (gsstr.Substring(0, 1) == "=")
                {
                    //等于号去掉，用&符号分割，空格忽略加入数组
                    string[] ar = gsstr.Substring(1, gsstr.Length - 1).Trim().Split('&');
                    gst = ar;
                }
                else
                {
                    gst = null;
                }
            }
            else
            {
                gst = null;
            }
            //如果公式有效
            if (gst != null)
            {
                string arf = "";//寄存嵌套函数体计算结果
                foreach (string la in gst)//遍历数组
                {
                    string game = "";//寄存单个嵌套函数体的值
                    #region 
                    string laf = "";//处理单引号，双引号
                    laf = la.Replace("\"", "").Replace("'", "");
                    int kar = 0;//计算单个嵌套整体有几个函数
                    for (int i = 0; i < laf.Length; i++)
                    {
                        if (laf.Substring(i, 1) == "(")
                        {
                            kar++;
                        }
                    }
                    //从最深层函数开始运算，依次计算出函数体结果
                    for (int j = kar; j > 0; j--)
                    {
                        //获取最深层函数体( 位置
                        int jar = 0;
                        for (int i = 0; i < laf.Length; i++)
                        {
                            if (laf.Substring(i, 1) == "(")
                            {
                                jar = i + 1;
                            }
                        }
                        //获取函数体前面标志位置，截取函数体
                        int ga = 0, y = 0;
                        for (int i = laf.Length - 1; i > 0; i--)
                        {
                            if (laf.Substring(i, 1) == "(")
                            {
                                y++;
                                if (y == 2)
                                {
                                    ga = i + 1;
                                }
                            }
                        }
                        //如果只找到一个(，那么他前面就没有函数嵌套
                        if (y < 2)
                        {
                            ga = 0;
                        }
                        //字符串深层第一个)
                        int tur = 0;
                        for (int i = 0; i < laf.Length; i++)
                        {
                            if (laf.Substring(i, 1) == ")")
                            {
                                tur = i + 1;
                                break;
                            }
                        }
                        string fx = laf.Substring(ga, jar - ga - 1).ToLower();//获取深层函数名称
                        string value = "";//寄存深层函数参数
                        //内置函数转义
                        switch (fx)
                        {
                            case "year":
                                value = year(laf.Substring(jar, tur - jar - 1));//转义year函数
                                break;
                            case "left":
                                value = left(laf.Substring(jar, tur - jar - 1), Convert.ToInt32(laf.Substring(jar, tur - jar - 1).Split(',')[1]));//转义left函数
                                break;
                        }
                        //重新组织函数体
                        laf = laf.Substring(0, ga) + value + laf.Substring(tur, laf.Length - tur);
                        //得到函数体值
                        game = laf;
                    }
                    #endregion
                    //累计公式的值
                    arf += game;
                }
                //获取公式结果
                return arf;
            }
            else
            {
                //公式不成立就返回自身
                return gsstr;
            }
        }
    }
}

以上是公式模块，现在我们调用拖一个窗体，一个文本框一个按钮，输入公式测试

代码调用模块方法

效果如下

是你要的效果吗？

我的方法是每一个公式你都定义好，然后按自己的方法分解函数体，从深层到外层转义成值，最后再拼接函数体获得的值

Answer 4

这个不会有开源的代码，只能自己写。