如何将Func<double, double>对象转换为Expression<Func<double, double>>以获取Lambda表达式的字符串表示？

Great question! The short answer is that you can't directly convert a compiled Func<double, double> back to an Expression<Func<double, double>>—but there are practical workarounds depending on your situation. Let's break this down:

Option 1: Define the Expression Tree First (Best Practice) #

The most reliable and clean approach is to start with an expression tree, then compile it to a Func when you need executable logic. This way you retain the original structured expression tree for generating the string representation, while still having a usable delegate.

Here's how to implement it for your example:

// First define the expression tree (this preserves the logic structure)
Expression<Func<double, double>> expr = x => x * x;
// Compile it to a Func whenever you need to execute the logic
Func<double, double> function = expr.Compile();

// Now you can still get the familiar string output anytime
string expressionString = expr.ToString(); // Returns "x => (x * x)"

This gives you the best of both worlds: a runnable delegate and the ability to inspect the original expression structure.

Option 2: Reverse-Engineer the Func via IL Parsing (Not Recommended) #

If you already have a Func instance and can't go back to the original expression tree, the only path is to parse the delegate's IL code to reconstruct an expression tree. However, this is extremely complex for a few reasons:

• Compiled IL often includes optimizations (like inlining or constant folding) that erase details of the original expression structure.
• There's no built-in .NET API for this—you'd need to use third-party libraries that specialize in IL analysis, and even then, the reconstructed expression tree might not match the original exactly.
• This approach is fragile, slow, and not worth the effort for most use cases.

Why Direct Conversion Isn't Possible #

To clear up the core limitation:

• A Func<double, double> is a compiled delegate—it contains low-level IL code that executes the logic, not a human-readable or inspectable structure of the logic itself.
• An Expression<Func<double, double>> is an abstract syntax tree (AST) that describes the logic in a structured, queryable format.
• The Compile() method converts the AST to IL, but this is a one-way process. Compilation discards structural details needed to reverse-engineer the original expression tree, so there's no built-in way to convert a delegate back to an expression.

内容的提问来源于stack exchange，提问作者Calimero