如何强制c#二进制整数除法返回双精度？

如何强制双x=3/2；返回1.5英寸x，不带D后缀或铸件？是否存在任何类型的操作员过载？或者一些编译器选项

令人惊讶的是，添加铸造或后缀并不是那么简单，原因如下：

业务用户需要编写和调试自己的公式。目前，C#像DSL（领域特定语言）一样被使用，因为这些用户不是计算机科学工程师。所以他们所知道的就是如何编辑和创建几种类型的类来保存他们的“业务规则”，这些规则通常只是数学公式

但他们总是假设双x=3/2；将返回x=1.5 但是在C#中，返回1

答：他们总是忘记这一点，浪费时间调试，给我打电话寻求支持，然后我们解决它。 B.他们认为这很难看，损害了他们业务规则的可读性

正如你所知，DSL需要更像自然语言

对。我们正计划迁移到Boo，并在此基础上构建DSL，但这是未来的发展方向

是否有一个简单的解决方案使双x=3/2；通过类外部的东西返回1.5，这样用户就看不见了

谢谢！

---

韦恩很简单，如果我没弄错的话：

double x = 3D / 2D;

---

不，没有解决方案可以使

3/2

返回1.5

---

考虑到您的约束的唯一解决方法是不鼓励用户在公式中使用文字。鼓励他们使用常量。或者，如果他们真的需要使用文字，鼓励他们使用带小数点的文字。

一个解决方案是编写一个为他们这样做的方法，并教他们使用它。您的方法总是采用双精度，并且答案总是有正确的小数位数。

我不太确定，但我相信您可以使用3.0/2.0获得双精度 但是，如果你认为.0只是另一种后缀形式，那么它也不是答案：-）

也许你现在可以试试，或者？这些是非常小的表达式解析库

我喜欢在自己的工作中使用强大的静态类型语言，但我认为它们不适合对成为专业人士没有兴趣的初学者

所以我不得不说，不幸的是，你选择的C#可能对那些观众来说不是最好的

---

Boo似乎是静态键入到的。您是否考虑过嵌入Javascript引擎、Python或其他动态类型引擎？这些通常不难插入到现有应用程序中，并且您可以从大量现有文档中获益。

可能是int32上的扩展方法？

在将公式传递给c编译器之前对其进行预处理。做一些类似于：

formula = Regex.Replace(formula, @"(^|[\^\s\+\*\/-])(\d+)(?![DF\.])", "$1$2D")

将整数文本转换为双文本

---

或者，您可以使用一个简单的状态机来跟踪您是否在字符串文本或注释中，而不是盲目地替换，但对于简单的公式，我认为正则表达式就足够了。

尝试这样做：

double result = (double) 3 / 2;

结果=1.5

永远不要说永远。。。 （双）3/2解决方案看起来不错

但它在4+5/6时失败了

试试这个： 捐赠给公共领域，由SymbolicComputing.com免费使用。
它是alpha，但你可以试试，我只在几个测试中运行了它，我的网站和软件应该很快就会上线。 它使用微软的Roslyn，如果一切顺利，它会在每个数字后面加上“d”。Roslyn也是alpha，但它会解析相当多的C

公共静态字符串AddDSuffixesToEquation（字符串不等式）
{
SyntaxNode SyntaxNode=等式到SyntaxNode（不等式）；
List branchs=syntaxNode.groundNodesAndSelf（）.ToList（）；
List numericBranchIndexes=新列表（）；
列表替换=新列表（）；
联合淋巴结置换；
字符串lStr；
Int32 L；
对于（L=0；L=0；L--）
{
ReplaceMBranchs=replacement.groundsNodesAndSelf（）.ToList（）；
replacement=replacement.ReplaceNode（replacementMeBranchs[numericBranchIndexes[L]]，replacements[L]）；
}
返回replacement.ToString（）；
}
公共静态SyntaxNode等式到SyntaxNode（字符串不等式）
{
SyntaxTree=等式到SyntaxTree（不等式）；
返回方程SyntaxTree方程SyntaxNode（树）；
}
公共静态SyntaxTree等式SyntaxTree（字符串不等式）
{
return SyntaxTree.ParseCompilationUnit（“使用系统；类Calc{public static object Eval（）{return”+不等式+”；}}”）；
}
公共静态SyntaxNode等式SyntaxTreeTeEquationSyntaxNode（SyntaxTree SyntaxTree）
{
SyntaxNode SyntaxNode=syntaxTree.Root.groundNodes（）.First（x=>x.Kind==SyntaxKind.ReturnStatement）；
返回syntaxNode.ChildNodes（）.First（）；
}

发问者说：不带D后缀或castingWell，除了有类似解决方案的解决方案。。你也提到了文字，但我很可能在第一句话之后或者在你说完之前评论过。在我们使用DSL之前，鼓励他们使用3.0/2.0的建议将起作用。有些用户从不阅读手册。取而代之的是，他们只是遵循示例代码，用户数量正在增长，无法亲自教授所有这些代码。因此，我将修改所有示例代码和公式，使其使用3.0/2.0语法。这样，新用户将自动模仿。而且他们很聪明

    public static String AddDSuffixesToEquation(String inEquation)
    {
        SyntaxNode syntaxNode = EquationToSyntaxNode(inEquation);
        List<SyntaxNode> branches = syntaxNode.DescendentNodesAndSelf().ToList();
        List<Int32> numericBranchIndexes = new List<int>();
        List<SyntaxNode> replacements = new List<SyntaxNode>();
        SyntaxNode replacement;
        String lStr;
        Int32 L;
        for (L = 0; L < branches.Count; L++)
        {
            if (branches[L].Kind == SyntaxKind.NumericLiteralExpression)
            {
                numericBranchIndexes.Add(L);
                lStr = branches[L].ToString() + "d";
                replacement = EquationToSyntaxNode(lStr);
                replacements.Add(replacement);
            }
        }

        replacement = EquationToSyntaxNode(inEquation);
        List<SyntaxNode> replaceMeBranches;
        for (L = numericBranchIndexes.Count - 1; L >= 0; L--)
        {
            replaceMeBranches = replacement.DescendentNodesAndSelf().ToList();
            replacement = replacement.ReplaceNode(replaceMeBranches[numericBranchIndexes[L]],replacements[L]);
        }
        return replacement.ToString();

    }

    public static SyntaxNode EquationToSyntaxNode(String inEquation)
    {
        SyntaxTree tree = EquationToSyntaxTree(inEquation);
        return EquationSyntaxTreeToEquationSyntaxNode(tree);
    }

    public static SyntaxTree EquationToSyntaxTree(String inEquation)
    {
        return SyntaxTree.ParseCompilationUnit("using System; class Calc { public static object Eval() { return " + inEquation + "; } }");
    }

    public static SyntaxNode EquationSyntaxTreeToEquationSyntaxNode(SyntaxTree syntaxTree)
    {
        SyntaxNode syntaxNode = syntaxTree.Root.DescendentNodes().First(x => x.Kind == SyntaxKind.ReturnStatement);
        return syntaxNode.ChildNodes().First();
    }