有什么区别:

public ActionResult Login(LoginViewModel model, string returnUrl)
{
    if (ModelState.IsValid)
    {
        IdentityResult result = IdentityManager.Authentication.CheckPasswordAndSignIn(AuthenticationManager, model.UserName, model.Password, model.RememberMe);
        if (result.Success)
        {
            return Redirect("~/home");
        }
        else
        {
            AddErrors(result);
        }
    }
    return View(model);
}

和:

[HttpPost]
[AllowAnonymous]
[ValidateAntiForgeryToken]
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
{
    if (ModelState.IsValid)
    {
        IdentityResult result = await IdentityManager.Authentication.CheckPasswordAndSignInAsync(AuthenticationManager, model.UserName, model.Password, model.RememberMe);
        if (result.Success)
        {
            return Redirect("~/home");
        }
        else
        {
            AddErrors(result);
        }
    }
    return View(model);
}

我看到MVC代码现在有异步,但有什么区别.一个人的表现比另一个人好得多吗？调试一个问题比另一个问题更容易吗？我是否应该为我的应用程序更改其他控制器以添加异步？

我的团队目前正在讨论这个问题.

有问题的代码就是这样的

if (!myDictionary.ContainsKey(key))
{
    lock (_SyncObject)
    {
        if (!myDictionary.ContainsKey(key))
        {
            myDictionary.Add(key,value);
        }
    }
}

我见过的一些帖子说这可能是一个很大的NO NO(当使用TryGetValue时).然而,我们团队的成员说没关系,因为"ContainsKey"不会对密钥集合进行迭代,而是通过O(1)中的哈希代码检查密钥是否包含在内.因此他们声称这里没有危险.

我想就此问题得到您的诚实意见.

当我阅读MSDN文章在ASP.NET MVC 4中使用异步方法时,我得出结论,我应该始终使用异步等待I/O绑定操作.

请考虑以下代码,其中movieManager公开ORM的异步方法,如Entity Framework.

public class MovieController : Controller
{
    // fields and constructors

    public async Task<ActionResult> Index()
    {
        var movies = await movieManager.listAsync();

        return View(movies);
    }

    public async Task<ActionResult> Details(int id)
    {
        var movie = await movieManager.FindAsync(id);

        return View(movie);
    }
}

1. 这会不会给我更好的可扩展性和/或性能？
   • 我该怎么测量呢？
2. 为什么不在"现实世界"中使用它？
3. 上下文同步怎么样？
   • 是不是很糟糕,我不应该在ASP.NET MVC中使用异步I/O？

我知道这些问题很多,但关于这一主题的文献却有相互矛盾的结论.有人说你应该总是对依赖于I/O的任务使用异步,其他人说你根本不应该在ASP.NET应用程序中使用async.

我试图找到一种从一堆线程中记录有用上下文的方法.问题是很多代码都是通过线程池线程到达的事件处理的(据我所知),因此它们的名称与任何上下文无关.可以使用以下代码演示此问题:

class Program
{
    private static readonly log4net.ILog log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
    static void Main(string[] args)
    {
        new Thread(TestThis).Start("ThreadA");
        new Thread(TestThis).Start("ThreadB");
        Console.ReadLine();
    }

    private static void TestThis(object name)
    {
        var nameStr = (string)name;
        Thread.CurrentThread.Name = nameStr;
        log4net.ThreadContext.Properties["ThreadContext"] = nameStr;
        log4net.LogicalThreadContext.Properties["LogicalThreadContext"] = nameStr;
        log.Debug("From Thread itself");
        ThreadPool.QueueUserWorkItem(x => log.Debug("From threadpool Thread: " + nameStr));
    }
}

转换模式是:

%date [%thread] %-5level %logger [%property] - %message%newline

输出是这样的:

2010-05-21 15:08:02,357 [ThreadA] DEBUG LogicalContextTest.Program [{LogicalThreadContext=ThreadA, log4net:HostName=xxx, ThreadContext=ThreadA}] - From Thread itself
2010-05-21 15:08:02,357 [ThreadB] DEBUG LogicalContextTest.Program …

我目前正在尝试使用NUnit和Moq设置Unit来对我们的ReactiveUI ViewModels进行单元测试.但是我无法让它发挥作用.我无法将ReactiveUI添加到NUnit测试库(无法解析依赖关系'Rx-Xaml(≥2.2.5)'),我无法将Moq添加到PCL项目中.

是否可以使用NUnit和Moq对ReactiveUI ViewModels进行单元测试？

顺便说一句:我在Mac OSX 10.10.5上使用Xamarin Studio,但代码在Windows 10上正常运行:(

在OSX上我得到一个Unix传输错误,但在Windows上测试确实有效.

情况如下。共有三种服务，一种服务是事件源，并使用事件总线（如 Azure 服务总线或 ActiveMQ）向其他两种服务（订阅者）发布集成或通知事件（发件箱模式）。

此设计的灵感来自.NET 微服务 - 架构电子书 - 订阅事件。

我想知道如果这些事件之一由于错误而无法传递，或者事件处理只是没有正确实现，会发生什么。

• 如果出现应用程序错误，我应该信任我的消息总线吗？
  • 这是死信队列的用例吗？
• 在重新发布事件时，是否应该将所有消息重新发布到所有主题，还是只能重新发布一个子集？
  • 服务重新发布事件是否应该能够访问发布者和订阅者数据库以了解消息偏移量？
  • 或者订阅微服务是否应该能够读取发件箱？

据我所知,Windows服务应用程序中没有同步上下文.

• 是否await fooTask.ConfigureAwait(false)给我的Windows服务中的任何好处？
• 这有什么陷阱吗？

我有一个从多个MessageQueue实例读取的Windows服务.这些消息队列都有自己Task的阅读消息.通常,在阅读消息后,I/O数据库的工作就完成了.我发现文章声称在I/O操作上使用异步是个好主意,因为它可以释放线程.我正在尝试模拟在控制台应用程序中使用异步I/O操作的性能提升.

控制台应用程序

在我的测试环境中,我有10个队列.GetQueues()返回10个不同的MessageQueue实例.

static void Main(string[] args)
{
    var isAsync = Console.ReadLine() == "Y";
    foreach (var queue in queueManager.GetQueues())
    {
        var temp = queue;
        Task.Run(() => ReceiveMessagesForQueue(temp, isAsync));
    }

    while (true)
    {
        FillAllQueuesWithMessages();
        ResetAndStartStopWatch();
        while(!AllMessagesRead())
        {
            Thread.Sleep(10);
        }
        Console.WriteLine("All messages read in {0}ms", stopWatch.ElapsedMilliseconds);
    }
}

static async Task ReceiveMessagesForQueue(MessageQueue queue, bool isAsync)
{
    while (true)
    {
        var message = await Task.Factory.FromAsync<Message>(queue.BeginReceive(), queue.EndReceive);

        if (isAsync)
            await ProcessMessageAsync(message);
        else
            ProcessMessage(message);
    }
}

异步消息处理 …

假设我们有以下虚拟类

Foo <- setClass(Class = "Foo",slots = c(foo = "numeric"), 
    prototype = list(foo = numeric())

我认为,泛型用于超载不同的功能.所以假设我们想要实现一个访问器:

setMethod(f = "getFoo", signature = "Foo", 
    definition = function(Foo)
    {
        return(Foo@foo)
    }
)

这有效吗？或者我必须首先定义通用:

setGeneric(name="getFoo",
    def=function(Foo)
    {
        standardGeneric("getFoo")
    }
)

如果只有一个特定的"实例"这个函数类型,没有理由定义一个通用的,正确的？

我正在构建一个使用ADO.NET的.NET 4.0应用程序,所以我不能使用async/await.我不想要一个解决方案,但我想知道以下哪些实现最好,为什么.我的单元测试通过所有三个实现,但我想知道这三个之间的区别.

#1嵌套任务

在我的第一个实现中,我将任务包装在另一个任务中.我认为搞两个任务对性能不利,但我不确定.

public virtual Task<IDataReader> ExecuteReaderAsync(IDbCommand dbCommand, CancellationToken cancellationToken)
{
    return Task.Factory.StartNew(() =>
    {
        var sqlCommand = CheckIfSqlCommand(dbCommand);
        PrepareExecuteReader(dbCommand);

        return Task<IDataReader>
            .Factory
            .FromAsync(sqlCommand.BeginExecuteReader, sqlCommand.EndExecuteReader, null)
            .Result;
    }, cancellationToken);
}

#2使用TaskCompletionSource

然后我尝试将结果包装成一个TaskCompletionSource所以我只有一个任务.

public virtual Task<IDataReader> ExecuteReaderAsync(IDbCommand dbCommand, CancellationToken cancellationToken)
{
    var taskCompletionSource = new TaskCompletionSource<IDataReader>();
    var sqlCommand = CheckIfSqlCommand(dbCommand);
    PrepareExecuteReader(dbCommand);

    var reader = Task<IDataReader>
        .Factory
        .FromAsync(sqlCommand.BeginExecuteReader, sqlCommand.EndExecuteReader, null)
        .Result;

    taskCompletionSource.SetResult(reader);

    return taskCompletionSource.Task;
}

#3直接返回任务

我的最终解决方案是直接返回我创建的任务而不是包装它.

public virtual Task<IDataReader> ExecuteReaderAsync(IDbCommand dbCommand, CancellationToken cancellationToken)
{
    var sqlCommand = CheckIfSqlCommand(dbCommand); …