Функции вызова в цепочке событий/функций?

Question

У меня есть 3 функции. Их можно вызывать в любом порядке (позже они могут нуждаться в определенном порядке). Возвращаемое значение одной функции должно быть первым параметром следующего. Как мне это сделать? Я думаю, что это что-то вроде ниже. Каков наилучший способ сделать это?

string void fn(string sz, data d, eventhdl nextFunc) 
{ 
    //do stuff 
    if(nextFunc == null) 
     return ret; 
    else 
     return nextFunc(ret, d, nextFunc.Next); 
} 

Answer 1

Вам нужно несколько методов для участия в одном запросе. У меня есть вопрос. Я думаю, что у вас может быть собственный шаблон Decorator. Проблема в том, что это трудно сделать, но может быть Chain of Responsibility, если вы пытаетесь направьте запрос на правый функция.

Answer 2

Вы ищете что-то в этом роде?

T Foo<T>(T seed, IEnumerable<Func<T, T>> funcs) 
{ 
    T current = seed; 

    foreach (Func<T, T> func in funcs) 
    { 
     current = func(current); 
    } 

    return current; 
} 

Использование:.

int result = Foo<int>(1, new Func<int, int>[] 
      { 
       i => i + 1, 
       i => i * 2, 
       i => i * i 
      }); 

// result is 16 

Answer 3

Рассмотрим сделать класс ComboFunc текучим интерфейс на нем, так что вы можете сделать ...

вар п = новый ComboFunc() А ("arg1 ") .B (" арг2 ") С (." arg3"); var result = fn.Apply ("arg4");

Свободный интерфейс в классе ComboFunc можно использовать для создания внутренней функциональной цепочки, которую вы затем выполняете. B(), например, будет цепной функцией b() в цепочке Func внутри и возвращать новый объект ComboFunc().

Это дает вам (a) чистый синтаксис; (б) возможность задавать правила, которые ограничивают время разработки, какие функции можно назвать на вершине которой другие (вернув другой тип.

Что-то вроде ...

public abstract class ComboFuncBase 
    { 
     protected Func<string,string> chain = x => x;  // start with identity operation 

     // Here are your various functions ... defined as methods or as functions like this .. 
     protected Func<string, string> Afunc = input => input + "A"; 
     protected Func<string, string> Bfunc = input => input + "B"; 
     protected Func<string, string> Cfunc = input => input + "C"; 

     /// <summary> 
     /// Execute the chain of functions 
     /// </summary> 
     public string Apply(string argument) 
     { 
      return chain(argument); 
     } 

     /// <summary> 
     /// Apply FunctionC - always available 
     /// </summary> 
     public ComboFuncWithC C(string sz) 
     { 
      return new ComboFuncWithC() { chain = x => Cfunc(chain(x)) }; 
     } 

    } 

    /// <summary> 
    /// A chain without a C in it yet allows A's and B's 
    /// </summary> 
    public class ComboFunc : ComboFuncBase 
    { 
     /// <summary> 
     /// Apply FunctionA 
     /// </summary> 
     public ComboFunc A(string sz) 
     { 
      return new ComboFunc() { chain = x => Afunc(chain(x)) }; 
     } 

     /// <summary> 
     /// Apply FunctionB 
     /// </summary> 
     public ComboFunc B(string sz) 
     { 
      return new ComboFunc() { chain = x => Bfunc(chain(x)) }; 
     } 
    } 

    /// <summary> 
    /// After C has been applied you can't apply A or B 
    /// </summary> 
    public class ComboFuncWithC : ComboFuncBase 
    { 
    } 


    static void Main(string[] args) 
    { 
     string input = "hello"; 

     var combo = new ComboFunc().A(" world").B("!").C(" - see"); 

     // Intellisense/Compiler will not allow this ... 
     //var combo2 = new ComboFuncBase.ComboFunc().A(" world").C("!").B(" - see"); 

Answer 4

using System; 
using System.Collections.Generic; 

namespace FunctionCaller 
{ 
    class Demo 
    { 
     private class data { } 

     delegate string OperationDelegate(string sz, data d, Queue<OperationDelegate> funcs); 

     public void CallFunctions() 
     { 
      var funcs = new Queue<OperationDelegate>(); 
      funcs.Enqueue(fn1); 
      funcs.Enqueue(fn2); 
      funcs.Enqueue(fn3); 
      data d = new data(); 
      string sz = "Start"; 

      string result = CallFuncChain(sz, d, funcs); 

      Console.WriteLine(result); 
     } 

     private static string CallFuncChain(string sz, data d, Queue<OperationDelegate> funcs) 
     { 
      if (funcs.Count > 0) 
      { 
       OperationDelegate nextFunc = funcs.Dequeue(); 
       sz = nextFunc(sz, d, funcs); 
      } 
      return sz; 
     } 

     string fn1(string sz, data d, Queue<OperationDelegate> funcs) 
     { 
      string ret = sz + "\r\nfn1"; 
      ret = CallFuncChain(ret, d, funcs); 
      return ret; 
     } 

     string fn2(string sz, data d, Queue<OperationDelegate> funcs) 
     { 
      string ret = sz + "\r\nfn2"; 
      ret = CallFuncChain(ret, d, funcs); 
      return ret; 
     } 

     string fn3(string sz, data d, Queue<OperationDelegate> funcs) 
     { 
      string ret = sz + "\r\nfn3"; 
      ret = CallFuncChain(ret, d, funcs); 
      return ret; 
     } 
    } 
} 

Answer 5

Хорошо, если вы не хотите использовать свой собственный CallFuncChain, есть альтернатива Linq.

using System; 
using System.Linq; 

namespace FunctionCaller 
{ 
    class Demo2 
    { 
     private class data { } 

     public void CallFunctions() 
     { 
      var funcs = new Func<string, data, string>[] { 
       fn1, fn2, fn3 
      }; 

      data d = new data(); 

      string sz1 = "Start"; 

      string result = funcs.Aggregate(
       sz1, 
       (sz, x) => x(sz, d) 
      ); 

      Console.WriteLine(result); 
     } 

     string fn1(string sz, data d) 
     { 
      return sz + "\r\nfn1"; 
     } 


     string fn2(string sz, data d) 
     { 
      return sz + "\r\nfn2"; 
     } 

     string fn3(string sz, data d) 
     { 
      return sz + "\r\nfn3"; 
     } 
    } 
} 

Я немного неловко об этом, хотя это чистое ... Linq позволяет нам сделать много вещей, с функциями, которые я иногда думаю «должны» быть сделано с объектами вместо этого.