相关疑难解决方法(0)

我正在实现一个方法,Task<Result> StartSomeTask()并且在调用方法之前就已经知道了结果.如何创建已完成的Task <T>？

这就是我目前正在做的事情:

private readonly Result theResult = new Result();

public override Task<Result> StartSomeTask()
{
    var task = new Task<Result>(() => theResult);
    task.RunSynchronously(CurrentThreadTaskScheduler.CurrentThread);
    return task;
}

有更好的解决方案吗？

我有一个IAnimation暴露方法的接口BeginAsync().该方法应该启动动画并在完成时返回.

我想要做的是实现一个只在执行时返回的null动画类.NoAnimationBeginAsync()

这是正确的实施吗？

public async Task BeginAsync()
{
    await Task.Run(() => { });
}

我怀疑有一种比这更优雅的方法.我还考虑过创建一个空方法.但这给了我一个我不喜欢的警告.

我有一个接口我在两个地方实现,如:

interface I 
{ 
   Task DoSomething();
}

该接口具有异步Task DoSomething方法API,然后在A类中实现,如:

class A : I {....}

class B : I {....}

在A类中,DoSomething的实现如下所示,这是正常的:

public async Task DoSomething()
{
    if (...)
    {
        await DoIt();
    }
}

但是,在B类中,DoSomething()的实现不应该做任何事情.所以,它的实现看起来像这样:

public async Task DoSomething()
{
    // nothing
}

这编译但我不确定除了方法没用之外,做这样的事情是多么正确.

但在这种情况下"无用"在这种情况下是可以的,因为它的实现只是因为实现接口I的B类需要它.

我想知道这是否是一种正确的方法来实现一个返回异步任务但没有等待或返回的方法？我知道这个方法很简单,无法同步执行,因为没有调用await.

更新:此处已经提出了类似的问题,我在询问这一问题之前已经检查了所有这些问题.没有人问我要问的是什么

类似于在同步代码中实现需要Task返回类型的接口,尽管我很好奇我是否应该忽略编译器错误而不是我的情况.

假设我有这样的界面:

public interface IAmAwesome {
    Task MakeAwesomeAsync();
}

在一些实现中,通过使用async和异步完成来实现令人敬畏的好处await.这实际上是接口试图允许的内容.

在其他情况下,也许很少见,只需要一个简单的同步方法来制作真棒.所以我们假设实现如下:

public class SimplyAwesome : IAmAwesome {
    public async Task MakeAwesomeAsync() {
        // Some really awesome stuff here...
    }
}

这有效,但编译器警告:

这种方法缺少"等待"运算符并将同步运行.考虑使用await运算符等待非阻塞API调用,或者"等待TaskEx.Run(...)"在后台线程上执行CPU绑定工作.

编译器实际上是在建议这个解决方案:

public class SimplyAwesome : IAmAwesome {
    public async Task MakeAwesomeAsync() {
        await Task.Run(() => {
            // Some really awesome stuff here, but on a BACKGROUND THREAD! WOW!
        });
    }
}

我的问题是 - 当我选择忽略此编译器警告时应该确定什么？在某些情况下,工作非常简单,为它产生一个线程无疑会适得其反.

我有一个异步方法,它将通过Api查找作业调度服务的jobId.

如果没有找到结果,那么返回一个空任务或null是否更好？

据我所知,当返回一个集合时,最好返回一个空集合而不是null并使用对象最好返回null而不是空对象; 但对于任务我不确定哪个是最好的.见附件.

谢谢

   public virtual Task<int> GetJobRunIdAsync(int jobId)
        {
            var jobMonRequest = new jobmonRequest(true, true, true, true, true, 
            true, true, true, true, true, true, true,
            true,
            true, true, true, DateTime.Today, jobId, null, 0, null, null,
            null, null, 0, 0);

        var jobMonResponseTask = Client.jobmonAsync(jobMonRequest);

        var jobTask = jobMonResponseTask.ContinueWith(task =>
        {
            if (jobMonResponseTask.Result == null )
            {
                var empty = new Task<int>(() => 0); // as i understand creating a task with a predefined result will reduce overhead.

                return empty.Result; …

返回没有泛型类型参数的任务的最佳方法是什么？换句话说,一个任务代表一个不返回任何东西或返回的操作void？

换句话说,我正在寻找以下的替代方案:

T value = default(T);
return Task.FromResult<T>(value); // and

var tcs = new TaskCompletionSource<T>();
tcs.SetResult(value);
return tcs.Task;

但对于代表不应返回任何内容的操作的任务.

我从D4()哪里回来的？

async static Task D4()
{
    Console.Write("Enter the divisor: ");
    var n = int.Parse(Console.ReadLine());
    Console.WriteLine((24 / n).ToString());

    // NONE OF THESE WORK
    // THE COMPILER COMPLAINS WITH AN ERROR THAT SAYS:
    // Since 'Program.D4()' is an async method that returns 'Task', 
    // a return keyword must not be followed by an object expression.
    // Did you intend to return 'Task<T>'?
    // return new TaskCompletionSource<object>().Task;
    // return Task.FromResult<object>(null);
    // return Task.FromResult<bool>(false);
    // return Task.FromResult(0);
}

我之前问了类似的东西,它可能在我的情况下有效,但我现在没有回忆这种情况.此外,这个线程 …

我有一些VB.net代码,如:

If (condition1) Then
    Dim Task1 = function1Async()
    Dim Task2 = function2Async()
    Await Task.WhenAll(Task1, Task2)
Else
    Dim Task1 = function1Async()
    Dim Task3 = function3Async()
    Await Task.WhenAll(Task1, Task3)
End If

但我更愿意做以下事情:

Dim Task1 = function1Async()
Dim Task2 = New Task()
Dim Task3 = New Task()
If (condition1) Then
    Task2 = function2Async()
Else
    Task3 = function3Async()
End If
Await Task.WhenAll(Task1, Task2, Task3)

但是,"New Task()"并不会产生令人期待的任务.我是否可以创建一些最小的等待任务作为占位符,以防以后不创建真正的任务？