小编i3a*_*non的帖子

我只是看看默认的MVC5项目以及它如何在控制器中使用async.

我想知道async在简单地使用同步调用时提供了什么好处:

    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task<ActionResult> Disassociate(string loginProvider, string providerKey)
    {
        ManageMessageId? message = null;

        //why use an async database call here with await instead of just using a synchronous one?
        IdentityResult result = await UserManager.RemoveLoginAsync(User.Identity.GetUserId(), new UserLoginInfo(loginProvider, providerKey));
        if (result.Succeeded)
        {
            message = ManageMessageId.RemoveLoginSuccess;
        }
        else
        {
            message = ManageMessageId.Error;
        }
        return RedirectToAction("Manage", new { Message = message });
    }

我错过了什么？

这是否会在此处发生的等待类型中提供某种性能优势？

我正在研究各种消费者使用的C#API.此API提供对共享资源的访问(在我的情况下是执行串行通信的硬件),通常会有一些不同的参与者尝试同时使用它.

我遇到的问题是我的一些消费者希望在多线程环境中使用它 - 每个actor都独立工作并尝试使用该资源.一个简单的锁在这里工作正常.但我的一些消费者更愿意使用async-await和时间片资源.(据我所知),这需要一个异步锁定来将时间片返回到其他任务; 在锁定时阻塞会停止整个线程.

而且我认为拥有串行锁定最多是无法执行的,并且最坏的情况是潜在的竞争条件或死锁.

那么如何在公共代码库中为潜在的并发使用保护这个共享资源呢？

我期望以下两个发布者产生输出,但它只产生第一个的输出:

var broadcastBlock = new BroadcastBlock<int>(null);
var transformBlock = new TransformBlock<int, int>(i => i*10);
var publish1 = new ActionBlock<int>(i => Console.WriteLine("Publisher 1:" + i));
var publish2 = new ActionBlock<int>(i => Console.WriteLine("Publisher 2:" + i));

broadcastBlock.LinkTo(transformBlock, new DataflowLinkOptions() { PropagateCompletion = true });
transformBlock.LinkTo(publish1, new DataflowLinkOptions() { PropagateCompletion = true });
transformBlock.LinkTo(publish2, new DataflowLinkOptions() { PropagateCompletion = true });

foreach (var i in Enumerable.Range(0, 5))
{
    broadcastBlock.Post(i);
}
broadcastBlock.Complete();
Task.WhenAll(publish1.Completion, publish2.Completion).Wait();

我显然在这里缺少一些基本的东西,任何想法？

我目前使用构建器模式来构建我的MVC视图模型.

var viewModel = builder
                  .WithCarousel(),
                  .WithFeaturedItems(3),
                  .Build()

我遇到的问题是当我必须对异步方法进行服务调用时.这意味着我的构建器方法必须返回Task<HomeViewModelBuilder>而不是HomeViewModelBuilder.这可以防止我像我一样链接构建方法await.

示例方法

public async Task<HomeViewModelBuilder> WithCarousel()
{   
    var carouselItems = await _service.GetAsync();
    _viewModel.Carousel = carouselItems;
    return this;
}

现在我必须使用await调用构建器方法.

await builder.WithCarousel();
await builder.WithFeaturedItems(3);

有没有人使用构建器模式的异步方法？如果是这样,是否可以链接方法或推迟await构建方法.

我在Xamarin中有以下代码(在ios中测试):

private static async Task<string> TaskWithException()
{
    return await Task.Factory.StartNew (() => {
        throw new Exception ("Booo!");
        return "";
    });
}

public static async Task<string> RunTask()
{
    try
    {
        return await TaskWithException ();
    }
    catch(Exception ex)
    {
        Console.WriteLine (ex.ToString());
        throw;
    }
}

调用此方法await RunTask(),会抛出该TaskWithException方法的异常,但是catch方法RunTask永远不会被命中.这是为什么？我希望catch能像微软的async/await实现一样工作.我错过了什么吗？

我想创建一个复合索引,其中一个键应该是升序,第二个键是降序.

我怎样才能做到这一点？

我有一个包含用户选择的属性名称的字符串.

collection.EnsureIndex(IndexKeys.Descending(selectedProperties[0]),
                IndexKeys.Ascending(selectedProperties[1])),
IndexOptions.......

不起作用

我刚刚看到了C#5来电者信息属性(http://msdn.microsoft.com/en-us/library/hh534540.aspx).

这似乎是一个非常有用的功能,我已经阅读了一些文档(http://www.codeproject.com/Tips/606379/Caller-Info-Attributes-in-Csharp).

但是,我只是想知道:为什么必须传递默认值？它们是如何使用的？

以下示例代码显示了如何使用调用者信息属性:

public static void ShowCallerInfo([CallerMemberName] 
  string callerName = null, [CallerFilePath] string 
  callerFilePath = null, [CallerLineNumber] int callerLine=-1)
{
    Console.WriteLine("Caller Name: {0}", callerName);
    Console.WriteLine("Caller FilePath: {0}", callerFilePath);
    Console.WriteLine("Caller Line number: {0}", callerLine);
}

我的问题是:什么是默认值null,null以及-1用来做什么？上面的代码如何不同于:

public static void ShowCallerInfo([CallerMemberName] 
  string callerName = "hello", [CallerFilePath] string 
  callerFilePath = "world", [CallerLineNumber] int callerLine=-42)
{
    Console.WriteLine("Caller Name: {0}", callerName);
    Console.WriteLine("Caller FilePath: {0}", callerFilePath);
    Console.WriteLine("Caller Line number: {0}", callerLine);
}

我理解它的方式,这些是可选参数,编译器提供默认值,替换我们分配的默认值.在这种情况下,我们为什么要指定默认值？是否有一些奇怪的边缘情况,编译器可能无法填写值,并转向我们提供的默认值？如果没有,那么为什么要求我们输入这些数据呢？要求开发者提供永远不会使用的默认值似乎相当笨拙.

免责声明:我试过谷歌搜索,但我找不到任何东西.我几乎害怕在SO上提问,因为大多数这样的新手问题都会遇到这样的敌意,但作为最后的手段,我会冒一个问题.主持人/高级用户,没有违法行为 - …

我试图编写一个尝试执行操作但吞下任何引发的异常的方法.

我的第一次尝试如下:

public static void SafeExecute(Action actionThatMayThrowException) {
    try {
        actionThatMayThrowException();
    } catch {
        // noop
    }
}

使用同步操作调用时有效:

SafeExecute(() => { 
    throw new Exception(); 
});

但是在使用异步操作调用时失败:

SafeExecute(async () => { 
    await Task.FromResult(0);
    throw new Exception(); 
});

有可能编写一个处理这两种情况的方法吗？

我试图在TPL Dataflow块中完成"完成".特别是,TransformBlock似乎没有完成.为什么？

示例程序

我的代码计算从1到1000的所有整数的平方.我使用了a BufferBlock和a TransformBlock.稍后在我的代码中,我等待完成TransformBlock.该块永远不会实际完成,我不明白为什么.

static void Main(string[] args)
{
    var bufferBlock = new BufferBlock<int>();
    var calculatorBlock = new TransformBlock<int, int>(i =>
    {
        Console.WriteLine("Calculating {0}²", i);
        return (int)Math.Pow(i, 2);
    }, new ExecutionDataflowBlockOptions { MaxDegreeOfParallelism = 8 });

    using (bufferBlock.LinkTo(calculatorBlock, new DataflowLinkOptions { PropagateCompletion = true }))
    {
        foreach (var number in Enumerable.Range(1, 1000))
        {
            bufferBlock.Post(number);
        }

        bufferBlock.Complete();

        // This line never completes
        calculatorBlock.Completion.Wait();

        // Unreachable code
        IList<int> results;
        if (calculatorBlock.TryReceiveAll(out results))
        {
            foreach …

请遵守以下简单的代码:

class Program
{
    static void Main()
    {
        var sw = new Stopwatch();
        sw.Start();
        try
        {
            Task.WhenAny(RunAsync()).GetAwaiter().GetResult();
        }
        catch (TimeoutException)
        {
            Console.WriteLine("Timed out");
        }
        Console.WriteLine("Elapsed: " + sw.Elapsed);
        Console.WriteLine("Press Enter to exit");
        Console.ReadLine();
    }

    private static async Task RunAsync()
    {
        await Observable.StartAsync(async ct =>
        {
            for (int i = 0; i < 10; ++i)
            {
                await Task.Delay(500, ct);
                Console.WriteLine("Inside " + i);
            }
            return Unit.Default;
        }).Timeout(TimeSpan.FromMilliseconds(1000));
    }
}

运行它输出:

Inside 0
Inside 1
Elapsed: 00:00:01.1723818
Press Enter to exit

注意,没有 …