Update your error handling

Oct 13, 2025 by recoveryshake.com 36 views

🚀 Feature: Don't Throw Exception When Calling Functions or Evaluating Scripts in the Script Module

In the world of software development, working with scripts and functions can be a complex task. The Script module in .NET provides a powerful way to execute scripts and functions, but it can also throw exceptions when things go wrong. In this article, we will explore a new feature that aims to improve the way exceptions are handled when calling functions or evaluating scripts in the Script module.

When working with the Script module, it's not uncommon to encounter situations where the script execution fails, resulting in an exception being thrown. However, this approach has some limitations. For instance, when a script execution fails, the EvaluateResult object is set to EvaluateResultException, which is not ideal. This is because the low-level binding is introducing additional logic on top of the specification, which can lead to problems in the future.

Let's take a look at an example of how this issue can arise:

await context.Script.CallFunctionAsync("() => { return ['hi']; }", false);

In this example, the CallFunctionAsync method throws a .NET exception instead of returning an EvaluateResult BiDi object. This is because the EvaluateResult object is set to EvaluateResultException, which is not handled properly by the .NET methods.

Why This is a Problem

There are several reasons why this approach is not ideal:

Hiding data: When an exception is thrown, all the data included in the EvaluateResultException is hidden, and it's not possible to access it. This can make it difficult to diagnose and fix issues.
Future-proofing: If new derived types are introduced in the specification, such as "PartiallySuccess", then we will be in a problematic situation. This is because the low-level binding is not designed to handle these new types, which can lead to unexpected behavior.

To illustrate the difference, let's consider an example before and after the new feature:

// Before
public Task<EvaluateResult.Success> CallFunctionAsync(...)

// After
public Task<EvaluateResult> CallFunctionAsync(...)

As you can see, the CallFunctionAsync method now returns a Task<EvaluateResult> instead of a Task<EvaluateResult.Success>. This change allows the method to return an EvaluateResult object, which can be used to handle the result of the script execution.

The new feature provides several benefits, including:

Improved error handling: By returning an EvaluateResult object, it's possible to handle errors in a more robust way. This includes accessing the data included in the EvaluateResultException and handling new derived types that may be introduced in the future.
Future-proofing: The new feature is designed to be future-proof, which means that it can handle new derived types that may be introduced in the specification.
Simplified code: The new feature simplifies the code by removing the need to handle exceptions in a low-level way. This makes it easier to write and maintain code.

In conclusion, the new feature provides a significant improvement in the way exceptions are handled when calling functions or evaluating scripts in the Script module. By returning an EvaluateResult object, it's possible to handle errors in a more robust way, which includes accessing the data included in the EvaluateResultException and handling new derived types that may be introduced in the future. This feature is designed to be future-proof, which means that it can handle new derived types that may be introduced in the specification.
🚀 Feature: Don't Throw Exception When Calling Functions or Evaluating Scripts in the Script Module - Q&A

In our previous article, we explored a new feature that aims to improve the way exceptions are handled when calling functions or evaluating scripts in the Script module. In this article, we will answer some frequently asked questions about this feature to help you better understand its benefits and how it works.

Q: What is the main problem with the current exception handling mechanism?

A: The current exception handling mechanism throws a .NET exception when the script execution fails, which hides all the data included in the EvaluateResultException. This makes it difficult to diagnose and fix issues, and it's not future-proof.

Q: How does the new feature address these issues?

A: The new feature returns an EvaluateResult object, which can be used to handle the result of the script execution. This includes accessing the data included in the EvaluateResultException and handling new derived types that may be introduced in the future.

Q: What are the benefits of the new feature?

A: The new feature provides several benefits, including:

Improved error handling: By returning an EvaluateResult object, it's possible to handle errors in a more robust way.
Future-proofing: The new feature is designed to be future-proof, which means that it can handle new derived types that may be introduced in the specification.
Simplified code: The new feature simplifies the code by removing the need to handle exceptions in a low-level way.

Q: How does the new feature affect the code?

A: The new feature affects the code by changing the return type of the CallFunctionAsync method from Task<EvaluateResult.Success> to Task<EvaluateResult>. This allows the method to return an EvaluateResult object, which can be used to handle the result of the script execution.

Q: What are the implications of this change?

A: The implications of this change are:

Code changes: The code that calls the CallFunctionAsync method will need to be updated to handle the new return type.
Error handling: The error handling mechanism will need to be updated to handle the new EvaluateResult object.
Future-proofing: The code will need to be updated to handle new derived types that may be introduced in the future.

Q: How can I take advantage of this feature?

A: To take advantage of this feature, you will need to:

Update your code: Update your code to use the new return type of the CallFunctionAsync method.
Update your error handling: Update your error handling mechanism to handle the new EvaluateResult object.
Test your code: Test your code to ensure that it works correctly with the new feature.

In conclusion, the new feature provides a significant improvement in the way exceptions are handled when calling functions or evaluating scripts in the Script module. By returning an EvaluateResult object, it's possible to handle errors in a more robust way, which includes accessing the data included in the EvaluateResultException and handling new derived types that may be introduced in the future. We hope that this Q&A article has helped you better understand the benefits and implications of this feature.