C#

using System;

namespace ConsoleApplication1
{
    public class Program
    {
        public delegate int OuterDelegate(object[] o);
        public delegate int InnerDelegate(object[] o);

        public int MyMethod(object[] o)
        {
            int t = 0;
            foreach (object io in o)
            {
                t += (int)io;
            }
            return t;
        }


        static void Main(string[] args)
        {
            Program p = new Program();

            InnerDelegate oInnerDelegate = new InnerDelegate(p.MyMethod);
            OuterDelegate oOuterDelegate = new OuterDelegate(oInnerDelegate);

            int i = oOuterDelegate(new object[] { 1, 2, 3, 4 });
            Console.WriteLine(i.ToString());

            Console.WriteLine("done");
            Console.Read();
        }        
    }
}

Steve Holdorf wrote:

Now, the question I still have is how could I change the OuterDelegate to execute some code on what was returned from the InnerDelegate?

delegate int D1(params int[] list);
delegate void D2(int p);

class DeliDelegate {
  internal void Run(){
    InvokeBoth(ShowInt, Sum, 1, 2, 3, 4, 5);
    InvokeBothAndSome(ShowInt, Sum, 1, 2, 3, 4, 5);
  }

  void InvokeBoth(D2 outer, D1 inner, params int[] p) {
    outer(inner(p));
  }

  void InvokeBothAndSome(D2 outer, D1 inner, params int[] p) {
    int res = inner(p);
    res = res * 6;
    outer(res);
  }

  int Sum(params int[] i) {
    int result = 0;
    foreach (int j in i) {
      result += j;
    }
    return result;
  }

  void ShowInt(int i) {
    Console.WriteLine("Value is {0}", i);
  }
}

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            TestManager tManager = new TestManager();

            Console.WriteLine("ProcessRequest1");

            tManager.Run1();

            Console.WriteLine("ProcessRequest2, returned value is: " + tManager.Run2());

            Console.ReadLine();

        }
    }
}

namespace ConsoleApplication1
{
    delegate object OuterDelegate (int p);
    delegate object InnerDelegate (params string[] list);

    class TestManager
    {
        public int ProcessRequest1(OuterDelegate DoSomethingWithResults, InnerDelegate GetData, params string[] sParams)
        {
            int iRet = Convert.ToInt32(GetData(sParams));

            iRet += 1;

            return Convert.ToInt32(DoSomethingWithResults(iRet));
        }

        public string DoSomethingWithResults(int i)
        {
            i += 4;

            return i.ToString();
        }

        public string DoNothingWithResults(int i)
        {
            return i.ToString();
        }

        public object GetData(params string[] list)
        {
            int iReturn;

            iReturn = (Convert.ToInt32(list.GetValue(0))) + (Convert.ToInt32(list.GetValue(1)));

            return iReturn;
        }

        public int ProcessRequest2(OuterDelegate DoNothingWithResults, InnerDelegate GetData, params string[] sParams)
        {
            int iRet = Convert.ToInt32(GetData(sParams));

            return iRet;
        }
        
        internal void Run1()
        {
            string [] sArray = { "1", "2" };
            Console.WriteLine("Not returning anything, results: " + ProcessRequest1(DoSomethingWithResults, GetData, sArray));
        }

        internal string Run2()
        {
            string[] sArray = { "4", "5" };
            return Convert.ToString(ProcessRequest2(DoNothingWithResults, GetData, sArray));
        }
    }

}

Ennis Ray Lynch, Jr. wrote:

I don't think you are dumb

delegate void TestDelegate(params object[] list);
event TestDelegate aha;

public override void Test(int arg) {
    aha+=new TestDelegate(showArgCount);
    aha.Invoke(1);
    aha.Invoke(1, 2, 3, 4);
}

public void showArgCount(object[] args) {
    log("showArgCount: "+args.Length);
}