为什么日志“ End-Test”在运行时不打印，但在调试时打印？

如何解决为什么日志“ End-Test”在运行时不打印，但在调试时打印？

运行此测试时，不会打印“ End-Test”日志，但是当我逐步调试它时，它确实会打印。 这是什么原因？

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Newtonsoft.Json;
using NUnit.Framework;

  namespace Tests.Integrations
  {
   [TestFixture]
   public class Test
   {
    private static ConcurrentDictionary<DateTimeOffset,string> _log;

    static Test()
    {
        _log = new ConcurrentDictionary<DateTimeOffset,string>();
    }

    [Test]
    [TestCase("Why_End-Test_is_notPrinted")]
    public async Task main(string testId)
    {
        LogWrite($"START-Test");
        var sucssess = await SomethingSlow();
        LogWrite($"END-Test,sucssess:{sucssess}");
        LogSave(testId);
    }
    private async Task<bool> SomethingSlow()
    {
        return await Task<bool>.Run(() =>
        {
            LogWrite("Something Slow In");
            for (int i = 0; i < int.MaxValue; i++) { };
            LogWrite("Something Slow Out");
            return true;
        });
    }
    public void LogWrite(string msg)
    {
        Task.Run(() =>
        {
            var time = DateTimeOffset.UtcNow;
            var ts = time
                .ToLocalTime()
                .ToString("dd/MM/yy HH:mm:ss,fffffff");
            var threadId = Thread.CurrentThread.ManagedThreadId;
            _log.TryAdd(time,$"{ts}-[{threadId}]: {msg}");
        });
    }
    public void LogSave(string testId)
    {
        var sorted = LogSort();
        string json = JsonConvert.SerializeObject(sorted,Formatting.Indented);
        string Path = $"{DirectoryPath.GetDirectoryPath()}";
        using (
           System.IO.StreamWriter file =
           new System.IO.StreamWriter($"{Path}\\ActualResults\\{testId}.json"))
        {
            file.WriteLine(json);
        }
    }
    public List<string> LogSort()
    {
        var sortedLog = new List<string>();
        var logKeys = _log.Keys.ToList();
        logKeys.Sort();
        logKeys.ForEach(key =>
        {
            string value = string.Empty;
            if (_log.TryGetValue(key,out value))
                sortedLog.Add(value);
        });
        return sortedLog;
    }
 }

}

未经调试的日志输出：

[
  "16/08/20 11:27:34,1133986-[9]: START-Test","16/08/20 11:27:34,1144001-[11]: Something Slow In","16/08/20 11:27:39,3383941-[9]: Something Slow Out"
]

带有调试步骤的日志输出：

[
  "16/08/20 11:29:18,8003608-[9]: START-Test","16/08/20 11:29:18,8033588-[10]: Something Slow In","16/08/20 11:29:24,1967210-[10]: Something Slow Out","16/08/20 11:29:35,0146056-[9]: END-Test,sucssess:True"
]

预期结果是在逐步调试时将其打印在日志中。 因为我希望在等待任务“ SomethingSlow（）”的主任务时，直到返回“ SomethingSlow（）”，然后返回log（“ End-Test”）时，主任务外壳中的其余代码行才被处理应该处理。 另外，线程之间的移动不那么令人期待，因为“ Something Slow In”和“ Something Slow Out”这两行都在同一任务中，因此它们必须在同一线程中，但是在不调试的情况下运行就不会像那。

解决方法

在不调试的情况下运行代码时，任务无法及时完成。因此，您必须等待它。

更改LogWrite方法：

public Task LogWrite(string msg)
{
    return Task.Run(() =>
    {
        ...
    });
}

然后等待此方法：

public async Task main(string testId)
{
    await LogWrite($"START-Test");
    var sucssess = await SomethingSlow();
    await LogWrite($"END-Test,sucssess:{sucssess}");
    LogSave(testId);
}

还简化SomethingSlow方法：

private Task<bool> SomethingSlow()
{
    return Task<bool>.Run(() =>
    {
        ...
    });
}