标签: task

给予struct task_struct合作。确定进程有多老的最佳方法是什么？

用于task_struct保存指向其下一个最小的兄弟姐妹和最大的孩子的特定指针。这在某些内核版本中似乎不再可用。

我专门使用 Android goldfish 内核。我一直在尝试学习如何使用该list_head结构来迭代进程，但我似乎无法弄清楚如何确定每个子进程或兄弟进程的年龄。

那么，什么成员或用法task_struct可以做到这一点？

我对此已经摸不着头脑有一段时间了。我不知道这个异常是在哪里抛出的。我到底应该在哪里捕获这个异常？它是System.Net.WebException。我想我只是没有得到任务和异步/等待。我知道我正在创建其他线程，这很好，但是我在哪里处理异常？

The remote server returned an error: (403) Forbidden.

这是代码：

public async void sendRequest(string database, string table, string where, bool isPost, int deviceType)
{
    string urlQuery = Constants.URL_QUERY + database + "/" + table + "?" + where;

    Debug.WriteLine("URL Query: " + urlQuery);

    HttpWebRequest request = (HttpWebRequest)WebRequest.Create(urlQuery);
    request.Method = isPost ? "POST" : "GET";
    request.ContentType = "application/json";

    try
    {
        Debug.WriteLine("getting response");
        WebResponse response = await makeAsyncRequest(request);
        Debug.WriteLine("response obtained");
        finishRequest(response);
    }
    catch (WebException e)
    {
        Debug.WriteLine("WebException caught");
    }
} …

我试图理解 System.Task，但我不确定我所做的是否正确。我的目标是编写一种方法来批量并行处理图像。

我的理解是否正确，如果batchSize = 3该方法将排队 3 个任务并尽快并行运行所有 3 个任务Task.WaitAll()在调用时？

如果这样做有没有更优雅的方法？

private static void ProcessImages(int batchSize)
{
      List<Task> tasks = new List<Task>();
      foreach (var image in ImageSource.ReadImages())
      {
            if(tasks.Count < batchSize)
            { 
                 tasks.Add(Task.Run(() => ImageProcessor.ProcessImage(image)));
            }
            else
            {
                 Task.WaitAll(tasks.ToArray());
                 tasks.Clear();
            }
      }
}

我刚刚async在 C# 中发现了关键字，只是想知道如何使用按钮单击来停止它。我只是想了解它是如何工作的以及如何在执行另一个事件后停止任务。我尝试使用 bool 停止它，但没有运气。吹是我的代码：

//start
private void button1_Click(object sender, EventArgs e)
{
    Read(true);
}

private async void Read(bool state)
{
    while (state == true)
    {
        await Task.Delay(4000);
        listBox1.Items.Insert(0, "Read 1");
    }
}

//stop
private void button2_Click(object sender, EventArgs e)
{
    Read(false);
}

我有这个代码：

public async Task PickCard()
{
    switch (Settings.Co)
    {
        case CO.Random: Random(); break;
        case CO.FirstToLast: ArrangeCardOrder(true); break;
        case CO.LastToFirst: ArrangeCardOrder(false); break;
    }
    await ShowCard();
}

我将要修改Random()，ArrangeCardOrder(true)并ArrangeCardOrder(false)返回一个trueor false。

有没有办法可以从 switch 中获取该信息，如果它们的方法返回true然后调用await ShowCard，然后以 true 退出 PickCard，如果方法返回false，只需以 退出 PickCard false？

如何有选择地创建多个任务并使用它们执行 await Task.WhenAll(a,b,c);

我有以下课程

public class TaskProcessor
{
    private ProcessResult Result;

    public TaskProcessor(ProcessResult result)
    {
        Result = result ?? throw new ArgumentNullException(nameof(result));
    }

    public async Task<ProcessResult> Process(TaskOption option)
    {
        // First optional task
        Task<int?> typeFetcher = Task.FromResult<int?>(null);
        if (option is IProcessType t)
        {
            typeFetcher = t.GetAsync();
        }

        // Second optional task
        Task<int?> subtypeFetcher = Task.FromResult<int?>(null);
        if (option is IProcessSubtype st)
        {
            subtypeFetcher = st.GetAsync();
        }

        // Third optional task
        Task mainContent = Task.CompletedTask;

        if(Result.Content != null) 
        {
            mainContent = SetMainContentAsync(Result.Content); …

我是异步编程的新手。我的用户界面中有一个按钮和文本框。我想单击该按钮，它将使用 FileStream.ReadAsync 方法读取文件，然后它应该在文本框中显示文件的结果。问题是我不想在读取文件时阻止我的 UI。我认为使用 Read 方法应该这样做。但它不起作用。此方法有什么不正确以及如何将 Read 更改为 ReadAsync？

  private  void Button_Click(object sender, RoutedEventArgs e)
        {
            string filename = @"D:\Log\log.txt";
            byte[] result;
            UnicodeEncoding uniencoding = new UnicodeEncoding();
            using (FileStream SourceStream = File.Open(filename, FileMode.Open))
            {
                result = new byte[SourceStream.Length];
                Task<int> tf = new Task<int>(()=> SourceStream.Read(result, 0, (int)SourceStream.Length));
                tf.ContinueWith((x) =>
                 {
                     try
                     {
                         string txt = Encoding.ASCII.GetString(result);
                         Dispatcher.BeginInvoke((Action)(() => txtBox.Text = txt));
                     }
                     catch (Exception ae)
                     {

                         MessageBox.Show(ae.Message);
                     }
                 });

                tf.Start();
            }

在 C# 中，我有一个例子：

public async static Task TaskTest(int i)
{
    await Task.Delay(1);
    Console.WriteLine($"{i}. {DateTime.Now.ToString("HH:mm:ss fff")} " +
        $"ThreadId:{Thread.CurrentThread.ManagedThreadId} Start");

    int count = 1;
    while (true)
    {
        DoSomeThing(count);

        var stopWatch = new Stopwatch();
        stopWatch.Start();

        await Task.Delay(100);

        stopWatch.Stop();
        if (stopWatch.Elapsed.TotalMilliseconds > 200)
            Console.ForegroundColor = ConsoleColor.Red;

        Console.WriteLine($"Id:{count} Time:{DateTime.Now.ToString("HH:mm:ss fff")} " +
         $"ThreadID:{Thread.CurrentThread.ManagedThreadId} Time Delay:{stopWatch.Elapsed.TotalMilliseconds }");

        Console.ForegroundColor = ConsoleColor.White;
        count++;
    }
}

public async static Task DoSomeThing(int index)
{
    await Task.Delay(1);
    Task.Delay(1000).Wait();
}

private static void Main(string[] args)
{
    int i = 1;
    while …

这应该很简单，但我只是无法将其聚焦。

在这个方法中

public static async Task<string> UnloadAsync(Assembly assy, bool silentFail = false)
{
  if (AssyLoadContext.__alcd.ContainsKey(assy))
  {
    var assemblyName = __namd.Where(kvp => kvp.Value == assy).First().Key;
    __alcd[assy].Unloading += alc => //signal the task to complete and return assemblyName
    __namd.Remove(assemblyName);
    __alcd[assy].Unload();
    __alcd.Remove(assy);
    Debug.WriteLine($"Unloaded assembly '{assy.GetName().Name}'");
  }
  if (silentFail) 
  {
    return null;
  }
  else
  {
    throw new InvalidOperationException($"Assembly '{assy.GetName().Name}' cannot be unloaded. Did you load it using AssyLoadContext.LoadWithPrivateContext(string assyPath)?");
  }
}

该AssemblyLoadContext.Unload()操作实际上是异步的，但不可等待。一旦不再有强 GC 引用等操作完成，程序集将卸载并触发 Unloading 事件。

返回值是assemblyName我想提供给延续的。

我可以找到所有关于需求的废话，await因为这就是产量发生的地方，但我不能那样写。你如何做到这一点没有 …

我有这个功能，最多可以获取 10 个项目作为输入列表

public async Task<KeyValuePair<string, bool>[]> PayCallSendSMS(List<SmsRequest> ListSms)
{
    List<Task<KeyValuePair<string, bool>>> tasks = new List<Task<KeyValuePair<string, bool>>>();

    foreach (SmsRequest sms in ListSms)
    {
        tasks.Add(Task.Run(() => SendSMS(sms)));
    }

    var result = await Task.WhenAll(tasks);
    return result;
}

在这个函数中，我await要下载一些 JSON，然后反序列化它。

public async Task<KeyValuePair<string, bool>> SendSMS(SmsRequest sms)
 {
    //some code
      using (WebResponse response = webRequest.GetResponse())
    {
        using (Stream responseStream = response.GetResponseStream())
        {
            StreamReader rdr = new StreamReader(responseStream, Encoding.UTF8);
            string Json = await rdr.ReadToEndAsync();
            deserializedJsonDictionary = (Dictionary<string, object>)jsonSerializer.DeserializeObject(Json);
        }
    }
    //some code
     return …