将Delegate []传递给方法

Question

I am trying to desconstruct a method written by another coder to see how it works but it's getting a bit confusing

We have a Delegate that takes an Action as parameter.

private delegate void FunctionDelegate(Action next);

A function is then called in the constructor that takes an array of these delegates as parameter and executes each value in the array

LoadInSeries(LoadRoleAreaHours, LoadTableData);

The Function looks like this

private void LoadInSeries(params FunctionDelegate[] _delegates)
        {

          var Delegates = new List<FunctionDelegate>(_delegates);

           Func<Action, Action> creator = null;
            creator = delegate(Action inner)
            {
                if (Delegates.Count > 0)
                {
                    FunctionDelegate L = Delegates.First();
                    Delegates.RemoveAt(0);
                    Action next = delegate { L(inner); };
                    return creator(next);
                }
                else return inner;
            };
            Action outer = creator(null);

             if (outer != null)
                outer();
        }

The intent was too chain a series of functions with each function calling the next but wouldnt it just be easy to use a multicast delegate and add each function to the invocation list.

Does this code do something different?

Answer 1

Without a good Minimal, Complete, and Verifiable code example , it's impossible to understand the code fully. Of most significant concern is that your code example includes a mysterious L() method, the behavior of which we have no idea. There is also the problem with the FunctionDelegate = Delegates.First(); statement. At best, the FunctionDelegate identifier refers to a class field or property; at worst, that statement won't even compile. Either way, there's no evidence that the delegate object being removed from the input list is ever actually invoked.

So to even answer the question, some basic assumptions have to be made, which may or may not be correct.

That said, in the best-case scenario — which is that the code has hidden some awful, convoluted mechanism in the L() method that ultimately winds up able to invoke the delegate for the current call to the creator delegate — the code you're looking at is not simply invoking delegates in sequence, as would be the case with a MulticastDelegate . Rather, the code is constructing a chain of calls to the L() method, passing each delegate instance to the method in sequence.

Since you didn't show us the L() method, there's no way to say what the code actually does. I would agree that if all that L() does is invoke the delegate you pass to it, then this code looks like a very complicated way to just invoke an array of delegates. But, giving the benefit of the doubt to the person who wrote the code, this simply means that L() probably does something other than simply invoke the delegate.

Of course, it's possible the author of the code doesn't deserve the benefit of the doubt. In that case, not only would it be simpler to just use a multicast delegate, the simplest implementation would just iterate over the array, invoking each delegate in the desired sequence. But I say that without really knowing what the code does. I'm just assuming it's intended to do something useful with the delegates that are passed to it. There's no evidence in the code you posted to support even that generous assumption.

Give us the full picture, and a more definitive answer can be provided. Without knowing what L() is, or what side effects might exist in the passed-in delegates' target methods, it's impossible to say for sure whether the code you're looking at really needs to be written that way or not.