return Task.ContineWith<；TResult>；()而不知道TResult

本文关键字：TResult 不知道 gt lt return Task ContineWith | 更新日期: 2023-09-27 18:22:02

如果我只能访问Task，我如何使用反射或任何其他方式创建并返回continuation Task？

我需要一种方法，让延续中的异常返回到原始调用者。据我所知，这只能通过返回继续任务而不是原始任务来完成。问题是我不知道Task的结果类型，所以无法创建一个合适的continuation Task。

编辑：我无法更改签名类型。我有许多接口返回Task<TResult>对象，并且不能期望客户端获得Task<对象>结果。这些接口是WCF合同。我想在"核心"逻辑方法完成后做一些额外的验证逻辑，并在需要时抛出异常。这个异常必须返回到客户端，但目前还没有返回，因为我还没有返回继续任务。此外，我事先不知道类型，因为我正在应用postsharp方面并使用OnExit（）重写，这使我可以访问一个返回值，我知道它是一个Task，但它可以是任何数量的Task对象，TResult只在运行时才知道。

using System;
using System.Threading.Tasks;
    namespace TaskContinueWith
    {
        internal class Program
        {
            private static void Main(string[] args)
            {
                try
                {
                    Task<string> myTask = Interceptor();
                    myTask.Wait();
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex);
                }
                Console.ReadLine();
            }
            private static Task<string> Interceptor()
            {
                Task<string> task = CoreLogic(); //Ignore

                Task unknownReturnType = task; //This is what I have access to. A Task object which can be one of numerous Task<TResult> types only known at runtime.
                Task continuation = unknownReturnType.ContinueWith(
                    t =>
                        {
                         if(someCondition)
                         {
                             throw new Exception("Error");
                         }
                         return t.Result; //This obviously does not work since we don't know the result. 
                    });
                return continuation;
            }

            private static async Task<string> CoreLogic()
            {
                return "test";
            }
        }
    }

表达问题的另一种方式。

  1. 我只能更改DoExtraValidation（）内部的内容
  2. 我无法更改DoExtraValidation（）的签名以使用泛型

如何更改DoExtraValidation以使其适用于任何任务<TResult>返回类型

using System;
using System.Threading.Tasks;
namespace TaskContinueWith
{
    interface IServiceContract
    {
        Task<string> DoWork();
    }
    public class Servce : IServiceContract
    {
        public Task<string> DoWork()
        {
            var task = Task.FromResult("Hello");
            return  (Task<string>) DoExtraValidation(task);
        }
        private static Task DoExtraValidation(Task task)
        {
            Task returnTask = null;
            if (task.GetType() == typeof(Task<string>))
            {
                var knownType = task as Task<string>;
                returnTask = task.ContinueWith(
                    t =>
                    {
                        if(new Random().Next(100) > 50)
                        {
                            throw new Exception("Error");
                        }
                        return knownType.Result;
                    });
            }
            return returnTask;
        }
    }
    internal class Program
    {
        private static void Main(string[] args)
        {
            try
            {
                IServiceContract myService = new Servce();
                Task<string> myTask = myService.DoWork();
                myTask.Wait();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
            }
            Console.ReadLine();
        }
    }
}

return Task.ContineWith<；TResult>；()而不知道TResult

听起来像是dynamic的情况。我会尽量少用dynamic。首先，我们定义了一个强类型的助手：

static Task<TResult> SetContinuation<TResult>(Task<TResult> task)
{
    return task.ContinueWith(
        t =>
            {
             if(someCondition)
             {
                 throw new Exception("Error");
             }
             return t.Result;
        });
}

这个函数显然有效，但它需要知道TResult。dynamic可以填写：

Task continuation = SetContinuation((dynamic)unknownReturnType);

我刚刚测试了绑定在运行时是否有效。或者，您可以使用反射来调用辅助对象（使用MethodInfo.MakeGenericMethod和其他方法）。

您可以使用泛型（Interceptor在这里是一种扩展方法）：

public static class ProjectExtensions
{
    public static Task<T> Interceptor<T>(this Task<T> task)
    {
        Task<T> continuation = task.ContinueWith<T>(t =>
            {
            if(someCondition)
            {
                throw new Exception("Error");
            }
            return t.Result;
        });
        return continuation;
    }
}

通过这种方式，呼叫可以是任何类型：

var t1 = new Task<string>(() => /* return string */).Interceptor();
var t2 = new Task<int>(() => /* return int */).Interceptor();
相关文章：