标签: task

我需要在 Ada 中创建一个参数化任务，我得到的错误是：判别式必须具有离散或访问类型。

这是我的代码：

task type FEP_Con(Port_Num :  Port_Name) is
  entry Start;
end FEP_Con;

type FEP_Con_acc is access FEP_Con;

task body FEP_Con is
  S_Port : Serial_Port;
  Buffer : Ada.Streams.Stream_Element_Array(1..1024);
  Last   : Ada.Streams.Stream_Element_Offset;
  Response_Str : Unbounded_String;
  --cPort : Port_Name := "";
begin
  accept Start;

提前致谢。

我一直在尝试对我的 CPU 绑定函数使用异步方法来计算一些聚合函数。问题是存在一些死锁（我想），因为计算时间太不同了。我是这个任务并行世界的新手，我也阅读了 Stephem Cleary 的文章，但我仍然不确定这种异步方法的各个方面。我的代码：

private static void Main(string[] args)
{
    PIServer server = ConnectToDefaultPIServer();
    AFTimeRange timeRange = new AFTimeRange("1/1/2012", "6/30/2012");
    Program p = new Program();
    for (int i = 0; i < 10; i++)
    {
        p.TestAsynchronousCall(server, timeRange);
        //p.TestAsynchronousCall(server, timeRange).Wait();-same results
    }
    Console.WriteLine("Main check-disconnected done");
    Console.ReadKey();
}

private async Task TestAsynchronousCall(PIServer server, AFTimeRange timeRange)
{
    AsyncClass asyn;
    for (int i = 0; i < 1; i++)
    {
        asyn = new AsyncClass();
        await asyn.DoAsyncTask(server, timeRange);
        //asyn.DoAsyncTask(server, timeRange);-same results
    }
} …

 new Timer().schedule(new TimerTask() {

        public void run() {
            KeyBoardUtil.showKeyBoard(et_search);
        }
    }, 300);

我显示键盘使用 TimerTask，它运行良好。怎么解释呢？

我正在创建一个 Rails 应用程序，让用户可以预订活动的门票。

一旦用户选择了他想要购买的车票，他有 15 分钟的时间完成结账，否则车票将被释放并可供其他人预订。

如何“阻止”票证 15 分钟并在 15 分钟后使其再次可用？

我有一个具有以下签名的方法。

Task<string> Post(PartyVM model);

我正在通过使用以下方法来测试上述Post方法来编写单元测试类。

        mockPartyManager.Setup(mr => mr.Post(It.IsAny<PartyVM>())).Returns(
           (PartyVM target) =>
           {
               if (target.PartyID.Equals(default(int)))
               {
                   target.Name = "NewP";
                   target.Status = "ACTIVE";
                   target.PartyRoleID = msoList.Count() + 1;
                   partyList.Add(target);
               }
               else
               {
                   var original = partyList.Where(q => q.PartyID == target.PartyID).Single();

                   if (original == null)
                   {
                       return "Execution failed";
                   }

                   original.Name = target.Name;
                   original.Status = target.Status;
               }

               return "Execution Successful";
           });
        this.MockMSOManager = mockPartyManager.Object;
    }

当我尝试返回字符串时收到错误消息。

错误 45 无法将类型“字符串”隐式转换为“System.Threading.Tasks.Task”

我该如何解决这个问题。

我正在编写一段代码，从一个来源获取数据，进行一些处理，然后将其保存到不同的来源。由于两端的延迟水平很高，我尝试使用 async/await 等待加载和保存操作完成。理想情况下，这将启动所有输入任务，当每个任务完成时，它会进行一些快速处理，然后启动输出任务 - 使用 Task.WaitAll 会导致程序在新任务开始时不做任何事情。

由于第二个异步任务取决于第一个的结果，我无法弄清楚如何处理第二个等待，让它恢复处理第一个等待的其他结果 - 一旦结果被处理，第二个等待被击中，它会完全阻塞，直到保存功能完成，而不是继续处理其他结果。我正在尝试这样的事情，我做错了什么？

async Task MainAsync()
{
    /* gets a list of id's */

    var dataRequests = ids.Select(id => LoadEntryById(id)).ToList();

    foreach(var request in dataRequests)
    {
        RawEntry response = await request;

        ProcessedEntry result = doSomething(response);

        await SaveResult(result);
    }
}

async Task<RawEntry> LoadEntryById(int id)
{
    /* IO task */
}

async Task SaveResult(ProcessedEntry result)
{
    /* IO task */
}

我有一个带有PDFReader的UWP应用。PDFReader有一个搜索窗口。在搜索文本框中输入单词后，便可以开始搜索。当前，这样一来，如果您开始搜索，则必须等待3秒钟，直到看到一条消息，该单词的出现频率很高。

现在，我想用“正在搜索...”消息填充这3秒钟。

我有一个解决方案是：

private async void DoSearch(...)
{
//...
Task<string> searchingText = setSearchMsg();
infoBox.Text = await searchingText;
//...
}

private async Task<string> setSearchMsg()
{
infoBox.Text = "Searching...";
await Task.Delay(1);
return "";
}

但这看起来并不正确。我注意到的一件事是，当我正在寻找一个单词并且可以在80页中找到3000次该单词时，infoBox跳过“正在搜索...”消息，并再次将信息框填充为空。为了解决这个问题，我可以将更Task.Delay改为like Task.Delay(100)，这并不是我认为正确的解决方案。

因此，我试图找出一种取消特定任务的方法。在示例中，我想取消它产生的3个任务中的2个

static async Task Main(string[] args)
{

    var tasks = Enumerable.Range(0, 3).Select(x => Task.Run(() =>
    {
        Counter();
    }));



    await Task.WhenAll(tasks);

    Console.ReadLine();

}

public static void Counter()
{
    while (true)
    {
        for (int i = 0; i < 1000; i++)
        {
            Console.WriteLine(i);
        }
    }
}

如果我要while (someProperty)更改someProperty为，false则所有线程都将停止。我想停止2/3，该怎么做？

很长一段时间以来，我一直试图理解.NET中的异步等待内容，但是我却难以成功，所以当我使用异步时，总会发生意想不到的事情。

这是我的应用程序：

namespace ConsoleApp3
{
    class Program
    {
        static async Task Main(string[] args)
        {
            Console.WriteLine("Hello World!");

            var work1 = new WorkClass();
            var work2 = new WorkClass();

            while(true)
            {
                work1.DoWork(500);
                work2.DoWork(1500);
            }
        }
    }

    public class WorkClass
    {
        public async Task DoWork(int delayMs)
        {
            var x = 1;

            await Task.Delay(delayMs)

            var y = 2;
        }
    }
}

这只是我创建的一个示例，用于检查代码将如何执行。有几件事使我感到惊讶。首先，涉及很多线程！如果我在上面设置了一个断点，则var y = 2;可以看到那里的threadId不同，它可以是1、5、6或其他。这是为什么？我认为async / await不会自己使用其他线程，除非我明确命令（使用Task.Run或创建新线程）。至少本文试图说出我的想法。

好的，但是我们可以说出于某种原因还有其他一些线程-即使它们是，我await Task.Delay(msDelay);也没有ConfigureAwait(false)！据我了解，没有此调用，线程不应更改。

我很难很好地理解这个概念，因为我找不到任何可以包含所有信息而不只是几条信息的优质资源。

我正在Laravel中开发一个二进制的多层次营销系统，在注册时，我们必须为新用户的每个父节点执行一项任务，以输入许多类型的奖励。此任务非常耗时。

没有人希望看到缓冲和任务花费超过30秒的时间，这不是正确的方法。

我想在后台运行此机制，并发送一条成功消息，说明您的帐户已成功创建。