相关疑难解决方法(0)

我正在创建一个简单的wpf桌面应用程序.UI只有一个按钮和.cs文件中的代码.

private void Button_Click_2(object sender, RoutedEventArgs e)
{
    FunctionA();
}

public void FunctionA()
{
    Task.Delay(5000).Start();
    MessageBox.Show("Waiting Complete");
}

但令人惊讶的Task.Delay(5000).Start();是,线路投掷了InvalidOperationException:

可能不会在promise样式的任务上调用Start.

任何人都能帮助为什么会这样吗？

我已经阅读了很多文章,但仍然无法理解这一部分.

考虑以下代码:

    private async void button1_Click(object sender, EventArgs e)
    {
        await Dosomething();
    }

    private async Task<string> Dosomething()
    {
        await Task.Run((() => "Do Work"));
        return "I am done";
    }

第一个问题:

当我单击按钮时,它将调用DoSomething并等待通过调用Task.Run(如果我没有记错)从线程池创建线程的任务,并且所有这些都是异步运行的.所以我实现了创建一个完成我的工作但是异步执行的线程？但是考虑到我不需要任何结果,我只是希望在没有得到任何结果的情况下完成工作,是否真的需要使用async/await,如果是这样,怎么样？

第二个问题:

在异步运行线程时,它是如何工作的？它是在主UI上运行但是在单独的线程上运行还是在单独的线程上运行并且在该方法中是异步的？

第一种方式:

var tds=SearchProcess();
await tds;

public async  Task<XmlElement> SearchProcess()
{
}

第二种方式:

var tds= Task.Factory.StartNew(()=>SearchProcess());
Task.WaitAll(tds);

public XmlElement SearchProcess()
{
}

在上述两种方法中,存在任何性能差异吗？

我试图让自己等待和异步，所以我编写了这个小测试应用程序，但是我没有想到的结果。

该程序将继续执行，而不是等待任务完成。

class Program
{
    static void Main(string[] args)
    {
        var task = new Task(Run);
        task.Start();
        task.Wait();

        Console.WriteLine("Main finished");
        Console.ReadLine();
    }

    public async static void Run()
    {
        var task = Task.Factory.StartNew(() =>
        {
            Console.WriteLine("Starting");
            Thread.Sleep(1000);
            Console.WriteLine("End");
        });

        await task;
        Console.WriteLine("Run finished");
    }
}

输出量

Main finished
Starting
End
Run finished

如果我将“等待任务”替换为“ task.Await（）”，则它将按预期产生运行

Starting
End
Run finished
Main finished

我正在研究ASP.NET MVC项目.
我需要一些时间来解释我的疯狂情况.
我正在尝试从MVC项目向Android和Apple设备发送推送通知.
两者的发送逻辑都是正确的,请不要浪费你的时间考虑这个

我面临的灾难是:不调用负责发送通知的静态类中的静态方法.(我不是新鲜的程序员,我在C#编程方面有超过5年的时间)但我无法调用方法.

为了让您进入问题的上下文,当我在本地计算机(开发计算机)上执行代码时,将调用并执行此方法并将通知到达设备.
当我发布MVC项目并将其部署到我们的服务器时,不会调用静态方法.

我如何知道该方法未被调用？
因为我正在记录到一个文本文件,并且在调用该方法之前在方法的第一行和一个日志语句中放了一个日志语句.
调用方法之前的日志被执行并充实到文本文件,但是不执行静态方法开始的日志!!!!!.

这是一些代码,然后我会告诉你我试图解决这个问题.

public interface IHandler<T> where T : IMessage
{
    Task Handle(T args);
}

public class RequestAddedAppMonitorHandler : IHandler<RequestAdded>
{
    public Task Handle(RequestAdded args)
    {
        return Task.Factory.StartNew(() =>
        {
            try
            {
                GoogleNotification notification = CreateAndroidPartnerAppNotification(deviceId);

                // this statment is executed, and the text log file will contains this line
                TracingSystem.TraceInformation("Before Send Google Notification");  

                SendersFacade.PartnerSender.Send(notification).Wait();
            }
            catch (Exception ex)
            {
                TracingSystem.TraceException(ex);
            }
        }); …

我正在尝试建立一些具有一些最小耦合的工作者,但我想使用C#async和任务.并非所有任务都是纯粹的异步(有些将是完全同步的).这样做的动机是我想创建一些执行业务逻辑的简单方法,并使用System.Threading.Tasks.TaskAPI将它们链接在一起以保留一些排序概念.基本上,我想创建第一个任务,注册一些延续,然后等待最终任务完成.

这是我构建的简单原型,看看我想做什么甚至可以工作:

void Main()
{
    var worker = new Worker();

    var work = worker.StartWork(1, 2000);
    work.ConfigureAwait(false);

    var final = work.ContinueWith(_ => worker.StartWork(2, 0))
        .ContinueWith(ant => worker.StartWork(3, 1500));

    var awaiter = final.ContinueWith(_ => Tuple.Create(_.Id, _.Status));
    Console.WriteLine("\"final\" completed with result {0}", awaiter.Result);
    Console.WriteLine("Done.");
}

// Define other methods and classes here
class Worker {
    internal async Task StartWork(int phase, int delay) {
        Console.WriteLine("Entering phase {0} (in Task {1}) with {2} milliseconds timeout.", phase, Task.CurrentId, delay);
        if (delay > …

我发表过评论埃里克利珀的回答到什么是Task.Start /等待和异步/等待有什么区别？

我问这个问题,因为我仍然不确定我是否正确理解了这个概念以及我是如何实现我的目标的.添加大量评论对任何人都没有多大帮助.

我理解: await告诉编译器当前线程有能力执行其他一些计算,并在等待操作完成后返回.这意味着工作流程将中断,直到等待的操作完成.这不会加快包含await的上下文的计算速度,但会因为更好地使用worker而提高整体应用程序性能.

不,我的问题:我想继续工作流程,最后确保操作完成.所以基本上允许工作人员继续当前的工作流程,即使等待的操作没有完成并等待工作流程结束时完成.我希望工人花时间在我的工作流程上而不是逃跑并帮助别人.

我认为可能有用:考虑n个 async Add操作和Flush处理添加项的操作.Flush需要添加项目.但添加项目不需要添加上一项.所以基本上我想收集所有正在运行的 Add操作,并在添加所有操作后等待所有操作.在等待他们之后,他们应该被Flush编辑.

1. 我可以通过将Add任务添加到列表中来完成此操作,并最终等待所有这些任务吗？
2. 或者这是伪同步并且最终没有任何好处？
3. 是否与Add直接等待所有操作相同？(没有收集它们)