Los delegados son inmutables. El operador += crea un nuevo delegado con una lista de invocaciones que consta de la lista de invocaciones del lado izquierdo, seguida de la lista de invocaciones del lado derecho del operador. Luego almacena una referencia a ese delegado en la variable del lado izquierdo. Asi que

 act += () => MessageLog.Message("A");

es equivalente a

 act = act + (Action) (() => MessageLog.Message("A"));

que a su vez es equivalente a:

 act = (Action) Delegate.Combine(act, (Action) (() => MessageLog.Message("A"));

Entonces, ahora podemos llegar a su delegado add . Esta expresión lambda:

 a => a += () => MessageLog.Message("C");

... modifica el parámetro a para referirse al delegado recién combinado... y luego lo ignora.

En su lugar, debe devolver el delegado combinado (así que cambie add para que sea Func<Action, Action> ) y luego use el valor devuelto cuando invoque add :

 Action act = null; act += () => MessageLog.Message("A"); act += () => MessageLog.Message("B"); Func<Action, Action> add = a => a + () => MessageLog.Message("C"); act = add(act); act.Invoke();

Como probablemente sepa, A += B es solo una abreviatura de A = A + B , por lo que su delegado add es realmente solo:

 a => a = a + () => MessageLog.Message("C")

El + crea el delegado combinado a + () => MessageLog.Message("C") , y = lo vuelve a asignar a a . Observe cómo solo está reasignando el parámetro a , y ahora debe quedar claro que esto no cambia la variable que se pasa en ( act ) en absoluto .

Además de devolver el delegado combinado, también puede pasar el act por referencia:

 delegate void ByRefAction<T>(ref T parameter); ... Action act = null; act += () => Console.WriteLine("A"); act += () => Console.WriteLine("B"); ByRefAction<Action> add = (ref Action a) => a += () => Console.WriteLine("C"); add(ref act); act.Invoke();