Как передать произвольный метод в класс для асинхронного выполнения, отслеживания статуса и получения результата?

Question

[Илья]

Приветствую уважаемое сообщество.

Краткая вводная часть
Сейчас пишу небольшой WCF Restful сервис, возникла задача выполнять длительные запросы. Наиболее простым и понятным решением было принимать такие запросы на обработку, выдавая номер задания и соответствующий статус. Затем клиент обращается с номером задания по другому адресу с номером и получает свой ответ (если он уже готов). Идея не новая, очевидная и была подтверждена поисками:
- billhiggins.us/blog/2011/04/27/resty-long-ops (очень хорошо описано)
- lostechies.com/jimmybogard/2013/05/15/eventual-con...

Что я пытался сделать
Вспомнив, что около года назад писал что-то подобное, посмотрел архивы кода. Оказалось, что в тот раз мне нужно было выполнять всего один длительный метод, так что решил я всё быстро и просто (подозреваю, что далеко не идеально, но работает) - долгий метод был обёрнут в класс, подобный этому:

using System;
using System.ComponentModel;
namespace Service
{
    public class LongTermJob
    {
	public string JobId { get; private set; }
        public bool IsCompleted
        {
            get { return !_worker.IsBusy; }
        }
        public string Result
        {
            get { return IsCompleted ? _result : null; }
        }
        private readonly BackgroundWorker _worker;
        // Результаты выполнения, вместо string нужный тип.
        private string _result;
        public LongTermJob(string jobId, WorkerArgs args)
        {
	    JobId = jobId;
            _worker = new BackgroundWorker();
            _worker.DoWork += _worker_DoWork;
            _worker.RunWorkerCompleted += _worker_RunWorkerCompleted;
            _worker.RunWorkerAsync(args);
        }
        private void _worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            _result = "Результат выполнения метода";
        }
        private void _worker_DoWork(object sender, DoWorkEventArgs e)
        {
            var user = (WorkerArgs) e.Argument;
            Console.WriteLine("Name: {0} Age: {1}", user.Name, user.Age);
        }
    }
    public class WorkerArgs
    {
        public string Name { get; set; }
        public int Age { get; set; }
    }
}

Параметры запроса принимались, помещались в WorkerArgs, присваивался JobId (по которому потом осуществлялся возврат), создавался экземпляр LongTermJob и просто помещался в List<>. Затем при обращении проверялся статус задания и при надобности возвращался результат. Для того случая было удобно, даже процент выполнения при надобности можно выдавать.

Но в этот раз такой код не подходит. Требуется выполнять неопределённое время уже не один, а десятки самых разных методов, которые возвращают самые разные типы и имеют произвольное количество параметров.
Я начал читать и пробовать варианты с:
- делегатами, но они позволяют передать только конкретные параметры и возвращать один тип;
- Task'ами, но в него ещё надо как то передать метод;
- Func'ами, чтобы передавать их в Task'и, но у них перегрузки под каждое количество параметров, как передавать произвольное.

В общем, перепробовал всё, что смог. Сейчас остановится примерно на таком коде:

public class LongTermJob
    {
        public bool IsCompleted
        {
            get { return _task.IsCompleted; }
        }
        public TestClass Result
        {
            get { return IsCompleted ? _result : null; }
        }
        private readonly Task<TestClass> _task;
        private readonly TestClass _result;
        public LongTermJob(Func<TestClass> method)
        {
            _task = Task.Factory.StartNew((method));
            _result = _task.Result;
        }
    }
    public class WorkerArgs
    {
        public string Name { get; set; }
        public int Age { get; set; }
    }

Если бы вот такой код, но чтобы TestClass был <T>...

Возможно, надо подойти совсем с другой стороны или есть уже готовые решения для подобных ситуаций. Буду благодарен любому решению и предложению.

Comments

[Илья]

Посидел ещё, посмотрел, почитал, довёл код до такого:

public interface ILongTermJob<T>
    {
        string Id { get; }
        bool IsCompleted { get; }
        T Result { get; }
    }

    public class LongTermJob<T> : ILongTermJob<T>
    {
        private readonly Task<T> _task;
        private readonly string _id;

        public delegate T Method();

        public string Id
        {
            get { return _id; }
        }

        public bool IsCompleted
        {
            get { return _task.IsCompleted; }
        }

        public T Result
        {
            get { return _task.Result; }
        }

        public LongTermJob(string id, Method method)
        {
            _id = id;
            _task = Task.Factory.StartNew(() => method());
        }
    }

Пока не представляю, как передавать делегат со множеством переменных разных типов.

[Вадим Мартынов]

Я правильно понял, что "десятки разных методов" никак не связаны друг с другом и относятся к разным обращениям пользователя? При этом хочется сделать один шедулер, в который складывались все эти долгие методы и при запросе пользователя о статусе его задания - сервер обращался бы в одну точку доступа, где лежат все разные работы за статусом?

[Илья]

@Vadimyan, вы меня очень точно поняли. Идея именно такая. Единственное уточнение: "одну точку доступа, где лежат все разные работы за статусом" - за статусом и результатом. Интерфейс в коде выше очень точно показывает, что я ходу от этого хранилища:

public interface ILongTermJob<T>
    {
        string Id { get; }
        bool IsCompleted { get; }
        T Result { get; }
   }

[Илья]

Если совсем кратко, в тезисах, то простейшая демонстрация того, что мне нужно, такая (псевдокод):

// Моя библиотека методов, которые могу выполняться очень долго
// Они принимают и возвращают различные типы данных
public string Method1 (int x) {...}
public int Method2 (string x) {...}
public long Method3 (bool x) {...}

// Это то, как я их хочу хранить
List<MyJob> _jobs = new List<MyJob>();

// Это методы, которые реализует интерфейс сервиса WCF
// Добавляем задание
public Status NewMegaWork(string x)
{
	string id = newJobId;
	_jobs.Add(new MyJob(id, Method1(x)));
	return new Status {Id = id};
}

// Получаем результат c уже выполненным методом.
public string GetMegaWork(string id)
{
	return _job.Where(x => x.Id = id).First();
}

Answer 1

[Вадим Мартынов]

Возможно, до тех пор, как я доберусь до вашего вопроса, кто-то другой вспомнит промышленное решение.
Я для унификации сигнатур функций использовался вот этим методом:
habrahabr.ru/post/143465
То есть, любую функцию с N параметрами при помощи карринга / частичного применения можно привести к виду TResult Method(). Из недостатков - класс FunctionalExtensions у меня содержал порядка десятка методов под разное количество параметров, приводимое к разному числу параметров. Вам удобнее - нужно функции с разным числом параметров привести к одному виду - функции без параметров.

Comments

[Илья]

Спасибо, сейчас прочитаю.

[Илья]

Возможно, мой пробел в фундаментальных знаниях языка несколько глубже, чем я предполагал, но я не смог перенести информацию из статьи на мой случай. Посмотрите, пожалуйста, я в уточнениях добавил псевдокод.

[Вадим Мартынов]

Набросал очень простой пример, естественно, менеджер должен быть сложнее и потокобезопасней

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApplication7
{
    public abstract class Job
    {
        public Guid Id { get; private set; }
        public bool IsCompleted { get; protected set; }

        protected Job()
        {
            Id = Guid.NewGuid();
            IsCompleted = false;
        }
    }

    public class Job<TResult> : Job
    {
        public TResult Result { get; private set; }

        public Job(Func<TResult> workFunction)
        {
            MakeJob(workFunction);
        }

        private async void MakeJob(Func<TResult> func)
        {
            var result = await Task.Run(func);
            Result = result;
            IsCompleted = true;
        }
    }

    public class JobManager
    {
        private readonly Dictionary<Guid, Job> _jobs = new Dictionary<Guid, Job>();

        public Guid StartJob<TResult>(Func<TResult> func)
        {
            Job job = new Job<TResult>(func);
            _jobs.Add(job.Id, job);
            return job.Id;
        }

        public bool TrtGetResult<TResult>(Guid jobId, out TResult result)
        {
            if (!_jobs.ContainsKey(jobId))
            {
                throw new ArgumentException("Работы с данным идентификатором нет в списке.", "jobId");
            }

            var job = _jobs[jobId];

            if (!job.IsCompleted)
            {
                result = default(TResult);
                return false;
            }

            var parametrizedJob = job as Job<TResult>;
            
            if (parametrizedJob == null)
            {
                throw new ArgumentException("Ты, что, забыл какой тип возвращаемого значения тебе нужен?");
            }

            result = parametrizedJob.Result;
            _jobs.Remove(jobId);
            return true;
        }
    }

    public static class JobExamples
    {
        public static int Sum(int a, int b)
        {
            return a + b;
        }

        public static string Trim(string str)
        {
            return str.Trim();
        }
    }

    public static class FunctionalHelper
    {
        public static Func<TResult> ApplyPartial<T1, T2, T3, TResult>
        (Func<T1, T2, T3, TResult> function, T1 arg1, T2 arg2, T3 arg3)
        {
            return () => function(arg1, arg2, arg3);
        }

        public static Func<TResult> ApplyPartial<T1, T2, TResult>
            (Func<T1, T2, TResult> function, T1 arg1, T2 arg2)
        {
            return () => function(arg1, arg2);
        }

        public static Func<TResult> ApplyPartial<T1, TResult>
            (Func<T1, TResult> function, T1 arg1)
        {
            return () => function(arg1);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var manager = new JobManager();
            var jobId1 = manager.StartJob(FunctionalHelper.ApplyPartial(JobExamples.Sum, 2, 6));
            var jobId2 = manager.StartJob(FunctionalHelper.ApplyPartial(JobExamples.Trim, "   a a aaaa  "));

            int job1Result;

            Thread.Sleep(100);

            if (manager.TrtGetResult(jobId1, out job1Result))
            {
                Console.WriteLine(job1Result);
            }

            Console.ReadKey();

        }
    }
}

[Илья]

Это просто идеальный пример. Безмерно благодарен.
Вы знаете, у меня не было практики работы с Func<>, но как раз по пути домой читал главу "Linq: язык интегрированных запросов" (Фримен) где Func рассматривается. А по приезду домой как раз отлично новые знания легли на ваш пример.