标签: task

如果我忘记等待从非异步方法中的异步方法返回的任务，我不会收到警告。由于未观察到的异常，这导致我的代码中存在一些未被发现的错误。

如果调用方法是异步的，我确实会收到警告，但如果调用方法是非异步的，我会收到同样的警告。

我知道您不能等待非异步方法，解决方法是使调用方法异步，然后等待它。但我想要一个警告，让我知道我应该这样做。

在这种情况下，有没有办法让 c# 编译器生成警告？

在这篇文章中，Stephen 描述了在外部 StartNew（参见下面的代码片段）中，TaskScheduler.Current 是我们的 UI 任务调度程序。事实上，下面代码的输出似乎表明所有内容都是在 UI 线程上执行的。然而，当我尝试确认这一点时，我得到了不同的答案：

private void Button_Click(object sender, RoutedEventArgs e)
{
    var uiTaskScheduler = TaskScheduler.FromCurrentSynchronizationContext();
    var ui = new TaskFactory(TaskScheduler.FromCurrentSynchronizationContext());
    ui.StartNew(() =>
    {
        Debug.WriteLine("TaskScheduler.Current == UI TaskScheduler: " + (uiTaskScheduler == TaskScheduler.Current));
        Debug.WriteLine("UI on thread " + Environment.CurrentManagedThreadId);
        Task.Factory.StartNew(() =>
        {
            Debug.WriteLine("Background work on thread " + Environment.CurrentManagedThreadId);
        });
    });
}

和输出：

TaskScheduler.Current == UI TaskScheduler: False
UI on thread 1
Background work on thread 1

为什么会uiTaskScheduler == TaskScheduler.Current返回 false？

我在这里遇到了一个问题，你可能知道答案：我只是仍然无法弄清楚。

我在这里为一个简单的场景创建一个种子：为给定的帖子添加“喜欢”。方法签名是：

async Task GeneratePostLike(string postId, string userId, CancellationToken cancellationToken = default) {
    return await postLikeService.AddUserLikeToPost(
      new PostLikeInput { PostId = postId, UserId = userId },
      cancellationToken
    );
}

我想随机生成对帖子的点赞。我正在使用随机和其他机制来获取随机数来执行此操作。

当我使用旧的 for 循环块时，它会按照我想要的方式执行。这是我正在使用的说明：

var numberOfLikesForPost = random.Next(1, 100);
var randomUsersForLikes = await userService.GetRandomUsers(numberOfLikesForPost);

for (var likeIndex = 0; likeIndex < numberOfLikesForPost; likeIndex++)
{
  var randomUserId = randomUsersForLikes.PickRandom().Id;
  await GeneratePostLike(post.Id!, randomUserId, cancellationToken);
}

但是，当我尝试使用 时Task.WhenAll，它只是执行一两次迭代并继续。看起来它的行为就像某种“一劳永逸”的行为。以下代码代表了我对Task.WhenAll块所做的事情：

var numberOfLikesForPost = random.Next(1, 100);
var randomUsersForLikes = await userService.GetRandomUsers(numberOfLikesForPost);

var generatePostLikeTasks …

我已经创建了一个WCF服务器和一个WCF客户端来使用该服务.服务器的目的是添加2个传入的数字,并在返回总和之前等待X毫秒.

客户端创建Y任务并启动它们.每个任务都是服务器添加数字并等待X毫秒的请求.

当x = 0且y = 1000时,完成所有任务平均需要6.2秒.当X = 0且Y = 10000时,平均需要61秒来完成所有任务.

为什么这么慢或者这可能是正常的？

谢谢达莫

客户端C#方法

private void radButtonTaskWithStatus_Click(object sender, EventArgs e)
        {
            try
            {
                var dateTime1 = DateTime.UtcNow;
                radProgressBarStatus.Maximum = int.Parse(radTextBoxFloodRequests.Text);
                radProgressBarStatus.Value1 = 0;

                Random rnd = new Random();


                Task<int>[] tasks = new Task<int>[int.Parse(radTextBoxFloodRequests.Text)];

                for (int i = 0; i < int.Parse(radTextBoxFloodRequests.Text); i++)
                {
                    int x = i;
                    tasks[i] = new Task<int>(() =>
                    {    

                        int FirstRandomNumber = rnd.Next(1, 20);
                        int SecondRandomNumber = rnd.Next(1, 20);


                        int result = TaskRequestWithResult(FirstRandomNumber, SecondRandomNumber, int.Parse(radTextBoxFloodDelay.Text), x); …

我正在实现一个接口

Task Something()

但是实现中的代码都不是异步的

Task Something(){
    var x=1;
    return null;
}

这当然会在调用时导致错误:

await Something()

如何发回空白任务以使界面满意？

我正在处理的应用程序应该使用http客户端检索json字符串,然后在应用程序中进行反序列化并使用它.

一切正常,除了等待功能.我做错了什么,我似乎无法弄清楚是什么.我如何确保我的DataService类等待,直到我有我的json并且它已被反序列化？

DataService类:

class DataService : IDataService
{
    private IEnumerable<Concert> _concerts;

    public DataService()
    {
        _concerts = new DataFromAPI()._concerts;

        Debug.WriteLine("____Deserialization should be done before continuing____");

        **other tasks that need the json**

    }
}

我的http客户端类:

class DataFromAPI
{

    public IEnumerable<Concert> _concerts { get; set; }

    public DataFromAPI()
    {
        Retrieve();
    }

    public async Task Retrieve()
    {
        try
        {
            HttpClient client = new HttpClient();
            HttpRequestMessage request = new HttpRequestMessage();
            var result = await client.GetAsync(new Uri("http://url-of-my-api"), HttpCompletionOption.ResponseContentRead);
            string jsonstring = await result.Content.ReadAsStringAsync();
            DownloadCompleted(jsonstring);
        }
        catch …

我对此代码感到困惑.根据包含此代码的文档,它会调用允许它们同时执行的每个任务,然后等待它们都完成.

我不明白执行的顺序是如何运作的.通过声明任务var firstTask = DoSomethingAsync();会导致任务开始执行吗？我认为没有await表达式它是同步的.

public async Task RunConcurrentTasks()
{
    var firstTask = DoSomethingAsync();
    var secondTask = DoSomethingElseAsync();

    await firstTask;
    await secondTask;
} 

此外,此代码是否实现了相同的结果？

public async Task RunConcurrentTasks()
{
    var firstTask = DoSomethingAsync();
    var secondTask = DoSomethingElseAsync();

    await Task.WhenAll(firstTask, secondTask);
}

我正在尝试从Entity Framework加载大量数据.请求大约需要一分钟,并阻止页面加载.由于这对于较大的查询变得不合理,我想我会尝试使用后台线程或类似的东西.经过一段时间的研究,我找到了一种名为BackgroundWorker的东西.我试图实现这个但它不起作用.这是我的代码:

  void Page_LoadComplete(object sender, EventArgs e)
    {
        InitializeBackgroundWorker();
    }

    private void InitializeBackgroundWorker()
    {
        bw = new BackgroundWorker {WorkerReportsProgress = true};


        bw.DoWork += (sender, e) => e.Result = (List<object>)e.Argument;
        bw.ProgressChanged += new ProgressChangedEventHandler(bw_ProgressChanged);
        bw.RunWorkerAsync(doSomething());

        bw.RunWorkerCompleted += (sender, e) =>
        {
            AjaxWaitBox.Text = "Completed";
        };
    }
        private readonly Func<List<object>> doSomething = () =>
    {

        var list = ObjectFactory.Container.GetInstance<IActivityRepository>().GetAllActivitiesNotFiltered(ContentReference.RootPage);
        var count = list.Count;
        int i = 0;
        foreach (var item in list)
        {
            i++;
            Console.WriteLine("-(DoWork)->" + i);
            double percentage = (Convert.ToDouble(i) / …

我正在使用以下方法创建新任务并长时间在后台执行操作.如果满足某个条件,我需要完全停止所有任务并向用户显示消息.

dowork()
{

    mylist = new List<DataModel.CheckData>();
    int index = 0;
    foreach (var line in mylist)
    {
        mylist.Add(new DataModel.CheckData() { RawLine = line, data = line,FileName=virtualfilelist[index].ToString() });
        index++;
    }

    BlockingCollection<DataModel.CheckData> ujobs = new BlockingCollection<DataModel.CheckData>();
    timerRefreshUi.Start();

    Task.Factory.StartNew(() =>
    {
        _dtRows.Clear();
        uiQueue.Clear();
        uiQueueBad.Clear();
        uiQueueGood.Clear();

        for (int i = 0; i < mylist.Count; i++)
        {
             AddResultRow(mylist[i].data, "Waiting...",mylist[i].FileName, Color.White);
             ujobs.TryAdd(new DataModel.CheckData() { RowId = i, data = mylist[i].data }, 1000);

         }
         List<Task> openCheckTasks = new List<Task>();

         while (ujobs.Count > 0)
         {
             while (openCheckTasks.Where(task => …

我有以下代码来运行多个异步任务并等待所有结果。

string[] personStoreNames = _faceStoreRepo.GetPersonStoreNames();    
IEnumerable<Task<IdentifyResult[]>> identifyFaceTasks =
        personStoreNames.Select(storename => _faceServiceClient.IdentifyAsync(storename, faceIds, 1));
      var recognitionresults =
        await Task.WhenAll(identifyFaceTasks);

当我得到结果时，如何获得每个任务结果的商店名称。IdentifyResult的每个数组都将用于特定的商店名称，但是我不确定如何以IdentifyResults及其在其中找到的商店名称结尾。