将委托序列的复杂交互链接在一起

Question

这个问题问起来感觉相当复杂，虽然解决方案看起来很简单，但更多代表返回的代表内部的代表令人难以置信的程度导致我的大脑自行崩溃。

无需进一步说明，我将解释：

场景是您有翻译委托 (Func[A, B]) 和翻译行为 (Func[A, Func[Func[A, B], B]])。

这个想法是，围绕给定的翻译，您将拥有一组特定的行为，将调用包装到翻译中，即，他们接受 A，随意使用它做他们想做的事情，将其传递给下一个行为，同时能够更改返回值 (B)。

可能有一些 monad 可以完美地描述这一点，但也许一些代码会更有帮助。

受害者：

public class B
{

}

public class A
{

}

行为委托

public delegate Func<Func<A, B>, B> TranslationBehavior(A input);

应该将它们链接在一起的函数，并返回一个 Func，允许传入翻译函数并获取由行为

static Func<Func<A, B>, Func<A, B>> Chain(IEnumerable<TranslationBehavior> behaviors)
{
    throw new NotImplementedException();
}

使用场景

static void Main(string[] args)
{
    var behaviors = new[]
    {
        (TranslationBehavior) (inp => next => next(inp)),
        (TranslationBehavior) (inp => next => next(inp)),
        (TranslationBehavior) (inp => next => next(inp)),
    };

    var input = new A();

    var chained = Chain(behaviors);

    var output = chained(a => new B());

}

包装的新翻译函数在示例代码中，行为实现不这样做不做任何调用下一个行为的事情，我们的翻译实现只是返回一个新的 B。

函数“链”是问题函数，能够将行为链接在一起一直困扰着我，但为了向自己证明这实际上应该有效，我硬编码了一个幼稚的解决方案，专门将三种行为链接在一起：

static Func<Func<A, B>, Func<A, B>> Chain(IEnumerable<TranslationBehavior> behaviors)
{
    var behavior1 = (TranslationBehavior)null;
    var behavior2 = (TranslationBehavior)null;
    var behavior3 = (TranslationBehavior)null;

    return translation => input =>
        behavior1(input)(transformed1 =>
            behavior2(transformed1)(transformed2 =>
                behavior3(transformed2)(translation)
            )
        );
}

这可行，但显然是这样；很没用。

对此的任何帮助都将非常有用，并且有关这是否是已知模式或单子的任何信息都将非常有趣，我不认为此代码远非可推广的。

提前致谢， 史蒂芬.

Answer 1

我没有完全理解你的场景 - 没有一些额外的上下文，它听起来太复杂了:-)但是，仅从类型来看，我认为你正在寻找的实现是这样的。诀窍是添加一个与 IEnumerator 一起使用并且是递归的方法：

Func<Func<A, B>, Func<A, B>> Chain
  (IEnumerable<TranslationBehavior> behaviors, Func<A, B> final) {
    return translation => Chain(behaviors.GetEnumerator(), translation);
}

// Recursive method that takes IEnumerator and processes one element..
Func<A, B> Chain
  (IEnumerator<TranslationBehavior> behaviors, Func<A, B> last) {
    if (behaviors.MoveNext())
      return input => behaviors.Current(input)(Chain(behaviors, last));
    else
      return last;
}

您可以添加异常处理并处置枚举器，但这应该是正确的结构。

Answer 2

这个想法是，围绕给定的翻译，您将拥有一组特定的行为，将调用包装到翻译中，即，他们接受 A，随意使用它做他们想做的事情，将其传递下去到下一个行为，同时能够更改返回值 (B)。

这句话似乎最清楚地说明了你的问题。听起来您已经拥有

A -> {Black Box} -> B

并且想要

A -> pre-process A -> {same Black Box} -> B -> post-process and return B

如果这就是您想要的，我会推荐一个接口以及包装另一个实现的该接口的实现。这看起来类似于复合模式或代理模式，尽管它并不完全是其中之一。

interface ITranslator 
{
    B Transform(A input);
}
class TranslatorWrapper : ITranslator
{
    TranslatorWrapper(ITranslator wrapped)
    {
        _wrapped = wrapped;
    }

    ITranslator _wrapped;

    B Transform(A input)
    {
        //do preprocessing here
        B result = _wrapped.Transform(input);
        //do postprocessing here
        return result;
    }
}

这里的好处是，您可以通过在构造函数参数中传递“嵌套”或“链”TranslatorWrappers 以及其他类似的类来传递它们。根据您想要的语法，您可能需要添加一些扩展方法来为这些包装器提供更流畅的编码样式。