I would like to cast a Task<object> to Task<?> at the runtime like that :

return task.CastTo(targetType);

Here is my best approach:

时间戳

首页 > 解决方案 > 如何施放任务 to Task?

I would like to cast a Task<object> to Task<?> at the runtime like that :

return task.CastTo(targetType);

Here is my best approach:

c# - 如何施放任务 to Task?

I would like to cast a Task<object> to Task<?> at the runtime like that :

return task.CastTo(targetType);

Here is my best approach:

问题描述

I would like to cast a Task<object> to Task<?> at the runtime like that :

return task.CastTo(targetType);

Here is my best approach:

    [TestMethod]
    public void CastToString()
    {
        var task = CallTaskString("test");
        var casting = CastTo<string>(task);
        Assert.IsNotNull(casting);
        var targetTask = casting as Task<string>;
        Assert.IsNotNull(targetTask);
    }

    private async Task<T> CastTo<T>(Task task)
    {
       await task.ConfigureAwait(false);
        return (T)((dynamic)task).Result;
    }

    public Task<object> CallTaskString(string value)
    {
        return Task.Run<object>(() => value);
    }

I just want to replace the T by an argument Type targetType like that: public static async Task CastTo(this Task task, Type targetType).

Thanks

How to use a queue to count the number of graph components?

I have the queue functions and I have to use them to count the number of graph components. These are my functions:

    struct TQueue {
    int value;
    TQueue * next;
};

void QueueInit(TQueue * & a_head, TQueue * & a_tail) {
    a_head = NULL;
    a_tail = NULL;
};

bool IsQueueEmpty(TQueue * a_head) {
    return !a_head;
};

void Enqueue(TQueue * & a_head, TQueue * & a_tail, int a_val) {
    TQueue * l_hlp = new TQueue;
    l_hlp->value = a_val;
    l_hlp->next = NULL;
    if (a_tail) a_tail->next = l_hlp;
    if (!a_head) a_head = l_hlp;
    a_tail = l_hlp;
}

int Dequeue(TQueue * & a_head, TQueue * & a_tail) {
    int l_val = a_head->value;
    TQueue * l_hlp = a_head;
    a_head = a_head->next;
    if (!a_head) a_tail = NULL;
    delete l_hlp;
    return l_val;

};

void EmptyQueue(TQueue * & a_head, TQueue * & a_tail) {
    TQueue * l_hlp;
    while (a_head) {
        l_hlp = a_head;
        a_head = a_head->next;
        delete l_hlp;
    }
    a_tail = NULL;
};

And this is my main() function and some variables:

    // constant - number of vertexes
    const int n = 9;

    // queue declaration
    TQueue *phead, *ptail;    
    QueueInit(phead, ptail);

    // array of distanc    
    int dist[n];

    // distanc array initialization   
    for (int i = 0; i < n; i++) dist[i] = -1;

    // current distance
    int d = 0;    
    // processingvertex
    int v;    
    // number of components
    int c = 0;

I prefer to use stack and DFS but it's a school projec so I must to use queue and BFS algorithm.

标签： c#typescastingtask

解决方案

可以在运行时调用泛型方法。也许这可以帮助你：

public static class TaskExtension
{
    public static Task CastTo(this Task task, Type targetType)
    {
        var taskType = task.GetType();
        var srcType = taskType.GetGenericArguments().First();
        var method = typeof(TaskExtension).GetMethods(BindingFlags.NonPublic | BindingFlags.Static).Single(m => m.Name == nameof(CastToImpl)).MakeGenericMethod(srcType, targetType);
        return (Task)method.Invoke(null, new[] { task });
    }

    private static Task<R> CastToImpl<T, R>(Task<T> t)
        where R : T
    {
        return t.ContinueWith(t => (R)t.Result); 
    }
}

你可以像这样使用：

[TestMethod]
public void CastToString1()
{
    var task = CallTaskString("test");
    var casting = task.CastTo(typeof(string));
    Assert.IsNotNull(casting);
    var targetTask = casting as Task<string>;
    Assert.IsNotNull(targetTask);
}

推荐阅读