我可能会遗漏一些东西但是做什么之间有什么不同:

public void MyMethod()
{
  Task t = Task.Factory.StartNew(DoSomethingThatTakesTime);
  t.Wait();
  UpdateLabelToSayItsComplete();
}

public async void MyMethod()
{
  var result = Task.Factory.StartNew(DoSomethingThatTakesTime);
  await result;
  UpdateLabelToSayItsComplete();
}

private void DoSomethingThatTakesTime()
{
  Thread.Sleep(10000);
}

我不明白后缀和前缀增量或减量的概念.谁能给出更好的解释？

任务并行库很棒,在过去的几个月里我经常使用它.但是,有一些事情让我感到困扰:事实TaskScheduler.Current是默认的任务调度程序,而不是TaskScheduler.Default.这在文档和样本中乍一看绝对不是很明显.

Current可以导致细微的错误,因为它的行为正在改变,这取决于你是否在另一个任务中.哪个不容易确定.

假设我正在编写异步方法库,使用基于事件的标准异步模式来表示原始同步上下文的完成,这与XxxAsync方法在.NET Framework中完全相同(例如DownloadFileAsync).我决定使用任务并行库来实现,因为使用以下代码实现此行为非常容易:

public class MyLibrary
{
    public event EventHandler SomeOperationCompleted;

    private void OnSomeOperationCompleted()
    {
        SomeOperationCompleted?.Invoke(this, EventArgs.Empty);
    }

    public void DoSomeOperationAsync()
    {
        Task.Factory.StartNew(() =>
        {
            Thread.Sleep(1000); // simulate a long operation
        }, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default)
        .ContinueWith(t =>
        {
            OnSomeOperationCompleted(); // trigger the event
        }, TaskScheduler.FromCurrentSynchronizationContext());
    }
}

到目前为止,一切运作良好.现在,让我们在WPF或WinForms应用程序中单击按钮调用此库:

private void Button_OnClick(object sender, EventArgs args)
{
    var myLibrary = new MyLibrary();
    myLibrary.SomeOperationCompleted += (s, e) => DoSomethingElse();
    myLibrary.DoSomeOperationAsync(); // call that triggers the …

我已经搜索了SO以及网络的其他部分以获得一个很好的答案,但我找不到一个我真正理解的内容.我将以不同的方式呈现这一点,希望答案也能帮助其他人.

据我所知,这两个概念具有相同的规则,但由于方法实现能力,抽象类更灵活.此外,我知道你可以实现多个接口,只扩展一个类,但我确信有比我提到的两个更多的差异.

请查看代码的两个片段,并举例说明我可以对我的每个示例做些什么,这些示例会让我想要或不想使用另一个.

抽象类

abstract class Foo {
    abstract public function getValue();
    abstract public function setValue($value); 
}


class myObj extends Foo {
    function getValue() {

    }
    function setValue($value) {

    }
}

接口

interface Foo {
    public function getValue();
    public function setValue($value);
}

class myObj implements Foo {
    function getValue() {

    }
    function setValue($value) {

    }
}

这个问题是关于最佳REST API设计和我在嵌套资源和根级别集合之间选择的问题.

为了说明这个概念,假设我有收藏City,Business和Employees.典型的API可以如下构造.想象一下,ABC,X7N和WWW是关键,例如guids:

GET Api/City/ABC/Businesses                       (returns all Businesses in City ABC)
GET Api/City/ABC/Businesses/X7N                   (returns business X7N)
GET Api/City/ABC/Businesses/X7N/Employees         (returns all employees at business X7N)
PUT Api/City/ABC/Businesses/X7N/Employees/WWW     (updates employee WWW)

这看起来很干净,因为它遵循原始域结构 - 业务在城市,员工在公司.单个项目可通过集合下的密钥访问(例如,../Businesses返回所有业务,同时../Businesses/X7N返回单个业务).

以下是API消费者需要做的事情:

• 在城市中获得业务 (GET Api/City/ABC/Businesses)
• 让所有员工都参与进来 (GET Api/City/ABC/Businesses/X7N/Employees)
• 更新个人员工信息 (PUT Api/City/ABC/Businesses/X7N/Employees/WWW)

第二次和第三次调用虽然看起来在正确的位置,但使用了许多实际上不必要的参数.

• 为了让员工参与到业务中,唯一需要的参数是business(X7N)的关键.
• 要更新单个员工,唯一的参数需要员工的密钥(WWW)

后端代码中的任何内容都不需要非关键信息来查找业务或更新员工.因此,相反,以下端点看起来更好:

GET Api/City/ABC/Businesses                       (returns all Businesses in City ABC)
GET Api/Businesses/X7N                            (returns business X7N)
GET Api/Businesses/X7N/Employees                  (returns all employees at business …

感谢Jeremy Miller在日常.NET开发的功能编程方面所做的出色工作,我有一个工作的命令执行器,它可以完成我想要的所有工作(对线程池进行繁重的工作,将结果或错误发送回同步环境,甚至发布进度回同步上下文),但我无法解释为什么它使用SynchronizationContext.Send从线程池和Synchronization.Post从Func传递到了做繁重的方法.我已经多次阅读过这些文档,但我对于它的不同之处并不是很有道理.我应该从一个叫做Send一个叫做一个被调用的事实中获得什么Post？我觉得魔术是Send"启动同步请求"和Post"启动异步请求" 这一事实,但这两个请求都来自线程池,需要发送/发回到UI线程.

有人可以解释这个区别,即使它只是一个助记符设备,让我知道何时选择一个而不是另一个？

在如此重要的情况下,这是我的测试代码,我用Post发进度回UI:

private Action _ExecuteCommand
                (SynchronizationContext context
                 , Action<int, int> progress
                 , Action<int, int> after)
{
    int count = 3;
    int accumulatedValue = 0;
    int threadId = Thread.CurrentThread.ManagedThreadId;
    for (int i = 0; i < count; i++)
    {
        Thread.Sleep(1000);
        context.Post(delegate { progress(i + 1, threadId); });
        accumulatedValue += i;
    }

    return () => …

我们的一位培训师在解释CountDownLatch和CyclicBarrier之间的差异时给出了一个例子.

CountDownLatch:假设一块石头可以被10个人抬起,所以你将等待所有10个人来.然后只有你可以抬起石头.

CyclicBarrier:如果你要去野餐,你需要先在一个共同的地方见面,从那里开始你的旅程.

如果有人同意这些意见,请给我一些细节.

我已经阅读了这两个类的sun API.但我还需要一些解释.

我糊涂了.一个或多个如何Task在一个线程上并行运行？我对并行性的理解显然是错误的.

MSDN的比特我无法理解:

async和await关键字不会导致创建其他线程.异步方法不需要多线程,因为异步方法不能在自己的线程上运行.该方法在当前同步上下文上运行,并仅在方法处于活动状态时在线程上使用时间.

..和:

在启动任务和等待任务之间,您可以启动其他任务.其他任务隐式并行运行,但不会创建其他线程.

Stephen Toub在博客中写道

SynchronizationContext和TaskScheduler都是表示"调度程序"的抽象,是您提供一些工作的东西,它决定了运行该工作的时间和地点.有许多不同形式的调度程序.例如,ThreadPool是一个调度程序:您调用ThreadPool.QueueUserWorkItem来提供一个委托来运行,该委托被排队,并且其中一个ThreadPool的线程最终选择并运行该委托.您的用户界面还有一个调度程序:消息泵.

因此System.Reactive.Concurrency.EventLoopScheduler,Reactive Extensions的Dispatcher,ThreadPool,TaskScheduler,SyncrhonizationContext和IScheduler实现在这个意义上都是"调度程序".

他们之间有什么区别？

他们为什么都是必要的？我想我得到EventLoop,Dispatcher,ThreadPool.IScheduler也有很好的解释.
但是TaskScheduler和SyncrhonizationContext仍然不清楚.

Stephen Cleary的优秀文章解释了SyncrhonizationContext,我想我明白了.那么为什么我们需要TaskScheduler,目前尚不清楚.

请解释或指向消息来源.

我是否正确async/await本身与并发/并行无关,只不过是继续传递样式(CPS)实现？真正的线程是通过传递/恢复的SynchronizationContext实例来执行的await？

如果这是正确的,我有以下问题SynchronizationContext:
它保证在同一个线程上执行继续.

但是,是否有任何保证线程的上下文信息是持久的？我的意思是Name,CurrentPrincipal,CurrentCulture,CurrentUICulture,等它是否依赖于框架(ASP.NET,WinForms的,WCF,WPF)？