Carica e chiama dinamicamente i delegati in base ai dati di origine

Supponiamo che abbia un flusso di record che deve avere un calcolo. I record avranno una combinazione di queste funzioni eseguite Sum , Aggregate , Sum over the last 90 seconds o ignore .

Un record di dati assomiglia a questo:

Date;Data;ID

Domanda

Supponendo che ID sia un int di qualche tipo, e che int corrisponda a una matrice di alcuni delegati da eseguire, come dovrei usare C # per costruire dinamicamente quella mappa di lancio?

Sono sicuro che questa idea esiste ... è usata in Windows Form che ha molti delegati / eventi, la maggior parte dei quali non sarà mai invocato in una vera applicazione.

Nell'esempio riportato di seguito sono inclusi alcuni delegati che desidero eseguire (somma, conteggio e stampa), ma non so come rendere la quantità di delegati attiva in base ai dati di origine. (ad esempio, stampa gli eventi e somma le probabilità in questo esempio)

using System;
using System.Threading;
using System.Collections.Generic;
internal static class TestThreadpool
{

    delegate int TestDelegate(int  parameter);

    private static void Main()
    {
        try
        {
            // this approach works is void is returned.
            //ThreadPool.QueueUserWorkItem(new WaitCallback(PrintOut), "Hello");

            int c = 0;
            int w = 0;
            ThreadPool.GetMaxThreads(out w, out c);
            bool rrr =ThreadPool.SetMinThreads(w, c);
            Console.WriteLine(rrr);

            // perhaps the above needs time to set up6
            Thread.Sleep(1000);

            DateTime ttt = DateTime.UtcNow;
            TestDelegate d = new TestDelegate(PrintOut);

            List<IAsyncResult> arDict = new List<IAsyncResult>();

            int count = 1000000;

            for (int i = 0; i < count; i++)
            {
                IAsyncResult ar = d.BeginInvoke(i, new AsyncCallback(Callback), d);
                arDict.Add(ar);
            }

            for (int i = 0; i < count; i++)
            {
                int result = d.EndInvoke(arDict[i]);
            }


            // Give the callback time to execute - otherwise the app
            // may terminate before it is called
            //Thread.Sleep(1000);

            var res = DateTime.UtcNow - ttt;
            Console.WriteLine("Main program done----- Total time --> " + res.TotalMilliseconds);
        }
        catch (Exception e)
        {
            Console.WriteLine(e);
        }

        Console.ReadKey(true);
    }


    static int PrintOut(int parameter)
    {
        // Console.WriteLine(Thread.CurrentThread.ManagedThreadId + " Delegate PRINTOUT waited and printed this:"+parameter);
        var tmp = parameter * parameter;
        return tmp;
    }

    static int Sum(int parameter)
    {
        Thread.Sleep(5000); // Pretend to do some math... maybe save a summary to disk on a separate thread
        return parameter;
    }

    static int Count(int parameter)
    {
        Thread.Sleep(5000); // Pretend to do some math... maybe save a summary to disk on a separate thread
        return parameter;
    }

    static void Callback(IAsyncResult ar)
    {
        TestDelegate d = (TestDelegate)ar.AsyncState;
       //Console.WriteLine("Callback is delayed and returned") ;//d.EndInvoke(ar));
    }

}