在 C# 中键入从脚本语言返回值的安全方式

Question

我一直在研究一个小型数学脚本引擎（或 DSL，如果您愿意的话）。让它变得有趣，这没什么大不了的。无论如何，我想要的功能之一是以类型安全的方式从中获取结果的能力。问题是它可以返回 5 种不同的类型。

数字、布尔值、Fun、FunN 和 NamedValue。还有 AnyFun，它是 Fun 和 FunN 的抽象基类。 Fun 和 FunN 的区别在于 Fun 只接受一个参数，而 FunN 接受多个参数。认为使用一个参数来保证单独的类型是很常见的（可能是错误的）。

目前，我正在使用一个名为 Result 的包装器类型和一个名为 Matcher 的类来完成此任务（受 F# 和 Haskell 等语言中的模式匹配的启发）。使用时基本是这个样子。

engine.Eval(src).Match()
  .Case((Number result) => Console.WriteLine("I am a number"))
  .Case((bool result) => Console.WriteLine("I am a bool"))
  .Case((Fun result) => Console.WriteLine("I am a function with one argument"))
  .Case((AnyFun result) => Console.WriteLine("I am any function thats not Fun"))
  .Do();

这是我当前的实现。不过，它是刚性的。添加新类型相当繁琐。

public class Result
{
    public object Val { get; private set; }
    private Callback<Matcher> _finishMatch { get; private set; }

    public Result(Number val)
    {
        Val = val;
        _finishMatch = (m) => m.OnNum(val);
    }

    public Result(bool val)
    {
        Val = val;
        _finishMatch = (m) => m.OnBool(val);
    }

    ... more constructors for the other result types ...

    public Matcher Match()
    {
        return new Matcher(this);
    }

    // Used to match a result
    public class Matcher
    {
        internal Callback<Number> OnNum { get; private set; }
        internal Callback<bool> OnBool { get; private set; }
        internal Callback<NamedValue> OnNamed { get; private set; }
        internal Callback<AnyFun> OnAnyFun { get; private set; }
        internal Callback<Fun> OnFun { get; private set; }
        internal Callback<FunN> OnFunN { get; private set; }
        internal Callback<object> OnElse { get; private set; }
        private Result _result;

        public Matcher(Result r)
        {
            OnElse = (ignored) =>
            {
                throw new Exception("Must add a new exception for this... but there was no case for this :P");
            };
            OnNum = (val) => OnElse(val);
            OnBool = (val) => OnElse(val);
            OnNamed = (val) => OnElse(val);
            OnAnyFun = (val) => OnElse(val);
            OnFun = (val) => OnAnyFun(val);
            OnFunN = (val) => OnAnyFun(val);
            _result = r;
        }

        public Matcher Case(Callback<Number> fn)
        {
            OnNum = fn;
            return this;
        }

        public Matcher Case(Callback<bool> fn)
        {
            OnBool = fn;
            return this;
        }

        ... Case methods for the rest of the return types ...

        public void Do()
        {
            _result._finishMatch(this);
        }
    }
}

问题是我想添加更多类型。我想让函数既可以返回数字也可以返回布尔值，并将 Fun 更改为 Fun，其中 T 是返回类型。这实际上是主要问题所在。我有 AnyFun、Fun、FunN，在引入此更改后，我将不得不处理 AnyFun、Fun、Fun、FunN、FunN。即便如此，我也希望它能够将 AnyFun 与任何与自身不匹配的函数相匹配。像这样：

engine.Eval(src).Match()
  .Case((Fun<Number> result) => Console.WriteLine("I am special!!!"))
  .Case((AnyFun result) => Console.WriteLine("I am a generic function"))
  .Do();

是否有人对更好的实现有任何建议，以更好地处理添加新类型？或者对于如何以类型安全的方式获得结果还有其他建议吗？另外，我是否应该为所有返回类型创建一个通用基类（并为 bool 添加一个新类型）？

性能不是问题，顺便说一句。

保重， 可儿

编辑：

阅读反馈后，我创建了这个匹配器类。

public class Matcher
{
    private Action _onCase;
    private Result _result;

    public Matcher(Result r)
    {
        _onCase = null;
        _result = r;
    }

    public Matcher Case<T>(Callback<T> fn)
    {
        if (_result.Val is T && _onCase == null)
        {
            _onCase = () => fn((T)_result.Val);
        }
        return this;
    }

    public void Else(Callback<object> fn)
    {
        if (_onCase != null)
            _onCase();
        else
            fn(_result.Val);
    }

    public void Do()
    {
        if (_onCase == null)
            throw new Exception("Must add a new exception for this... but there was no case for this :P");
        _onCase();
    }
}

它更短，但案例的顺序很重要。例如，在这种情况下，Fun 选项将永远不会运行。

.Case((AnyFun result) => Console.WriteLine("AAANNNNNNNYYYYYYYYYYYYY!!!!"))
.Case((Fun result) => Console.WriteLine("I am alone"))

但如果你换个地方，它会的。

.Case((Fun result) => Console.WriteLine("I am alone"))
.Case((AnyFun result) => Console.WriteLine("AAANNNNNNNYYYYYYYYYYYYY!!!!"))

有可能改善吗？我的代码还有其他问题吗？

编辑 2：

解决了：D。

Answer 1

您的匹配器可以通过执行以下操作来处理无限类型：

public class Matcher
{
    private readonly Result result; // pass this in
    private readonly List<Func<Result, bool>> cases = new ...();

    public Matcher Case<T>(Action<T> action)
    {
        cases.add(result =>
        {
            if(typeof(T).IsAssignableFrom(result.Value.GetType()))
            {
                action((T)(result.Value));
                return true;
            }
            return false;
        }
        return this;
    }

    public void Do()
    {
        for each(var @case in cases)
        {
            if(@case(result)) return;
        }
    }
}

我认为您实际上并不需要列表，除非您的 Result 直到稍后才有 Value。我不太了解你的对象模型，但是如果结果的类型是已知的，那么不要使用列表并立即进行类型测试。

Answer 2

如果您总是想以同样的方式处理 DSL 结果

如果您总是希望以相同的方式处理结果（例如，如果您总是希望以相同的方式转换/调整特定类型的 DSL 对象），我建议您使用一个或多个字典来放置适配器委托like this.

我不确切知道您打算如何扩展您的应用程序，但在我看来，在您的情况下，每个返回类型有一个单独的字典并让它们都有零个或一个输入参数是个好主意。 （不要使用多个参数，只需将要返回的 DSL 参数包装到一个对象中即可）。

一个例子：

public class SomeClass
{
    public IDictionary<Type, Action<object>> RegistryVoid { get; set; }
    public IDictionary<Type, Func<object, int>> RegistryInt { get; set; }

    public void SomeDlsMethod()
    {
        ...

        // Example when you need to convert your DSL data object to int:
        int value = RegistryInt[someDslObject.GetType()](someDslObject);
    }
}

如果您想以不同的方式处理 DSL 结果

如果您想在代码中以不同的方式处理 DSL 结果，我建议使用 TypeSwith found here。 TypeSwitch 比使用多个 if/else 语句和强制转换更简单。使用这种方法，您可以指定使用它的逻辑，因此您不限于放入字典的逻辑。 （如果您愿意，可以轻松地将 TypeSwitch 修改为扩展方法）。

例子：

public class SomeClass
{
    public void SomeDlsMethod()
    {
        TypeSwitch.Do(someDslObject,
            TypeSwitch.Case<DslObjectA>(someDslObjectA => ...),
            TypeSwitch.Case<DslObjectB>(someDslObjectB => ...),
            TypeSwitch.Default(() => ...)
        );
    }
}