qué - tipos de clases en c#

Repita la tarea<T> a la tarea<objeto> en C#sin tener T

Question

Tengo una clase estática llena de métodos de extensión donde cada uno de los métodos es asíncrono y devuelve algún valor, como este

public static class MyContextExtensions{
  public static async Task<bool> SomeFunction(this DbContext myContext){
    bool output = false;
    //...doing stuff with myContext
    return output;
  }

  public static async Task<List<string>> SomeOtherFunction(this DbContext myContext){
    List<string> output = new List<string>();
    //...doing stuff with myContext
    return output;
  }
}

Mi objetivo es poder invocar cualquiera de estos métodos desde un solo método en otra clase y devolver su resultado como un objeto. Se vería algo como esto:

public class MyHub: Hub{
  public async Task<object> InvokeContextExtension(string methodName){
    using(var context = new DbContext()){
      //This fails because of invalid cast
      return await (Task<object>)typeof(MyContextExtensions).GetMethod(methodName).Invoke(null, context);
    }
  }
}

El problema es que el reparto falla. Mi dilema es que no puedo pasar ningún tipo de parámetros al método "InvokeContextExtension" porque es parte de un concentrador SignalR y es invocado por javascript. Y, hasta cierto punto, no me importa el tipo de devolución del método de extensión, ya que simplemente se serializará a JSON y se enviará de vuelta al cliente javascript. Sin embargo, tengo que convertir el valor devuelto por Invocar como una Tarea para usar el operador de espera. Y tengo que proporcionar un parámetro genérico con esa "Tarea", de lo contrario tratará el tipo de devolución como nulo. Entonces, todo se reduce a cómo puedo convertir con éxito la Tarea con el parámetro genérico T a una Tarea con un parámetro genérico del objeto donde T representa la salida del método de extensión.

Answer 1

El abordaje más eficiente sería el personalizador personalizado:

struct TaskCast<TSource, TDestination>
    where TSource : TDestination
{
    readonly Task<TSource> task;

    public TaskCast(Task<TSource> task)
    {
        this.task = task;
    }

    public Awaiter GetAwaiter() => new Awaiter(task);

    public struct Awaiter
        : System.Runtime.CompilerServices.INotifyCompletion
    {
        System.Runtime.CompilerServices.TaskAwaiter<TSource> awaiter;

        public Awaiter(Task<TSource> task)
        {
            awaiter = task.GetAwaiter();
        }

        public bool IsCompleted => awaiter.IsCompleted;    
        public TDestination GetResult() => awaiter.GetResult();    
        public void OnCompleted(Action continuation) => awaiter.OnCompleted(continuation);
    }
}

con el siguiente uso:

Task<...> someTask = ...;
await TaskCast<..., object>(someTask);

La limitación de este enfoque es que el resultado no es un Task<object> sino un objeto que se puede esperar.

Answer 2

En general, para convertir una Task<T> en la Task<object> , simplemente iría por la asignación de continuación directa:

Task<T> yourTaskT;

// ....

Task<object> yourTaskObject = yourTaskT.ContinueWith(t => (object) t.Result);

( enlace de documentación aquí )

Sin embargo, su necesidad específica real es invocar una Task por reflexión y obtener su resultado (tipo desconocido) .

Para esto, puede consultar la respuesta completa de dasblinkenlight , que debe encajar con su problema exacto.

Answer 3

Esta no es una buena idea mezclar await con invocar dinámico / reflejo ya que await es una instrucción del compilador que genera una gran cantidad de código alrededor del método invocado y no tiene sentido real "emular" el trabajo del compilador con más reflejos, continuaciones, envoltorios, etc. .

Ya que lo que necesita es administrar su código en RUN TIME, entonces olvide que asyc await sintaxis de azúcar que funciona en tiempo de compilación. Reescriba SomeFunction y SomeFunction sin ellos, e inicie operaciones en sus propias tareas creadas en el tiempo de ejecución. Obtendrá el mismo comportamiento pero con código claro como el cristal.

Answer 4

Hice un pequeño método de extensión basado en la respuesta de dasblinkenlight:

public static class TaskExtension
{
    public async static Task<T> Cast<T>(this Task task)
    { 
        if (!task.GetType().IsGenericType) throw new InvalidOperationException();

        await task.ConfigureAwait(false);

        // Harvest the result. Ugly but works
        return (T)((dynamic)task).Result;
    }
}

Uso:

Task<Foo> task = ...
Task<object> = task.Cast<object>();

De esta manera puedes cambiar T en la Task<T> a lo que quieras.

Answer 5

Me gustaría proporcionar una implementación que sea, en mi humilde opinión, la mejor combinación de las respuestas anteriores:

• manejo preciso de argumentos
• sin despacho dinámico
• método de extensión de propósito general

Aqui tienes:

/// <summary> 
/// Casts a <see cref="Task"/> to a <see cref="Task{TResult}"/>. 
/// This method will throw an <see cref="InvalidCastException"/> if the specified task 
/// returns a value which is not identity-convertible to <typeparamref name="T"/>. 
/// </summary>
public static async Task<T> Cast<T>(this Task task)
{
    if (task == null)
        throw new ArgumentNullException(nameof(task));
    if (!task.GetType().IsGenericType || task.GetType().GetGenericTypeDefinition() != typeof(Task<>))
        throw new ArgumentException("An argument of type ''System.Threading.Tasks.Task`1'' was expected");

    await task.ConfigureAwait(false);

    object result = task.GetType().GetProperty(nameof(Task<object>.Result)).GetValue(task);
    return (T)result;
}

Answer 6

No puedes lanzar la Task<T> al Task<object> , porque la Task<T> no es covariante (tampoco es contravariante). La solución más simple sería usar un poco más de reflexión:

var task   = (Task) mi.Invoke (obj, null) ;
var result = task.GetType ().GetProperty ("Result").GetValue (task) ;

Esto es lento e ineficiente, pero se puede usar si este código no se ejecuta con frecuencia. Aparte de esto, ¿de qué sirve tener un método asíncrono MakeMyClass1 si va a bloquear esperando su resultado?

Y otra posibilidad es escribir un método de extensión para este propósito:

  public static Task<object> Convert<T>(this Task<T> task)
    {
        TaskCompletionSource<object> res = new TaskCompletionSource<object>();

        return task.ContinueWith(t =>
        {
            if (t.IsCanceled)
            {
                res.TrySetCanceled();
            }
            else if (t.IsFaulted)
            {
                res.TrySetException(t.Exception);
            }
            else
            {
                res.TrySetResult(t.Result);
            }
            return res.Task;
        }
        , TaskContinuationOptions.ExecuteSynchronously).Unwrap();
    }

Es una solución sin bloqueo y conservará el estado / excepción original de la Tarea.

Answer 7

Para obtener el mejor enfoque , sin utilizar la reflexión y la sintaxis fea y dinámica, y sin pasar tipos genéricos. Yo usaría dos métodos de extensión para lograr este objetivo.

    public static async Task<object> CastToObject<T>([NotNull] this Task<T> task)
    {
        return await task.ConfigureAwait(false);
    }

    public static async Task<TResult> Cast<TResult>([NotNull] this Task<object> task)
    {
        return (TResult) await task.ConfigureAwait(false);
    }

Uso:

    Task<T1> task ...
    Task<T2> task2 = task.CastToObject().Cast<T2>();

Este es mi segundo enfoque , pero no recomendado :

public static async Task<TResult> Cast<TSource, TResult>([NotNull] this Task<TSource> task, TResult dummy = default)
{
    return (TResult)(object) await task.ConfigureAwait(false);
}

Uso:

Task<T1> task ...
Task<T2> task2 = task.Cast((T2) default);

// Or

Task<T2> task2 = task.Cast<T1, T2>();

Este es mi tercer enfoque , pero no recomendado : (similar al segundo)

public static async Task<TResult> Cast<TSource, TResult>([NotNull] this Task<TSource> task, Type<TResult> type = null)
{
    return (TResult)(object) await task.ConfigureAwait(false);
}

// Dummy type class
public class Type<T>
{
}

public static class TypeExtension
{
    public static Type<T> ToGeneric<T>(this T source)
    {
        return new Type<T>();
    }
}

Uso:

Task<T1> task ...
Task<T2> task2 = task.Cast(typeof(T2).ToGeneric());

// Or

Task<T2> task2 = task.Cast<T1, T2>();

Answer 8

Puede hacerlo en dos pasos: await la tarea usando la clase base, luego cosechar el resultado usando reflexión o dynamic :

using(var context = new DbContext()) {
    // Get the task
    Task task = (Task)typeof(MyContextExtensions).GetMethod(methodName).Invoke(null, context);
    // Make sure it runs to completion
    await task.ConfigureAwait(false);
    // Harvest the result
    return (object)((dynamic)task).Result;
}

Este es un ejemplo completo de ejecución que pone en contexto la técnica anterior de llamar a la Task través de la reflexión:

class MainClass {
    public static void Main(string[] args) {
        var t1 = Task.Run(async () => Console.WriteLine(await Bar("Foo1")));
        var t2 = Task.Run(async () => Console.WriteLine(await Bar("Foo2")));
        Task.WaitAll(t1, t2);
    }
    public static async Task<object> Bar(string name) {
        Task t = (Task)typeof(MainClass).GetMethod(name).Invoke(null, new object[] { "bar" });
        await t.ConfigureAwait(false);
        return (object)((dynamic)t).Result;
    }
    public static Task<string> Foo1(string s) {
        return Task.FromResult("hello");
    }
    public static Task<bool> Foo2(string s) {
        return Task.FromResult(true);
    }
}