A1essandro's questions

最近我读了一篇关于 Habré 的文章（更新：我从评论中意识到我需要附上一个引用，关于这个问题是进一步的）

一旦代码到达 Task.Run() 方法，就会从线程池中取出另一个线程，并在其中执行我们传递给 Task.Run() 的代码。旧线程，作为一个体面的线程，返回到池中并等待再次被调用以完成工作。新线程执行传递的代码，到达同步操作，同步执行（等待操作完成），然后继续执行代码。换句话说，操作一直保持同步：我们和以前一样，在同步操作执行期间使用线程。唯一的区别是我们在调用 Task.Run() 和返回 ExecuteOperation() 时花费了时间切换上下文。一切都变得更糟了。

那里讨论的问题之一是调用Task.Run是一种反模式，它仅用于 GUI 响应性。

问题在于它在Task.Run(() => _anyWork())哪里_anyWork()包含同步代码。如果你这样做，文章中写的内容听起来很合乎逻辑：

await DoWork();
...

Task DoWork() => Task.Run(_work);

是的，在这种情况下，会在线程池上创建额外的负载。但是，如果你这样做：

var task1 = DoWork1();
var task2 = DoWork2();
var task3 = DoWork3();
await Task.WhenAll(task1, task2, task3);

Task.Run立即变成普通代码，对吗？

将执行此代码的线程将创建三个其他线程（upd : speculative: 启动将工作添加到要运行的队列中ThreadPool），它们将并行执行它们的工作。此外，当他遇到 时await，他将返回控制权（最终，他很可能会返回池中）。如果不是请更正。

如果是这样，问题就来了：这条线在哪里，在一个糟糕的实现和一个正常的实现之间？在非库代码中，很明显 - 如果调用了一个方法，并且等待在更远的地方，那么您可以执行Task.Run. 一方面，在库中，如果客户端在调用后等待它们，我们可以并行化方法的工作。另一方面，如果客户端在调用时期望立即得到结果，我们可以徒劳地增加负载。我们无法确切知道客户端将如何调用这些方法，我们只能在文档中给出建议。

也许有一些来自 MS 的官方建议？在 msdn 上，我只找到了对这些方法如何工作的干巴巴的描述。

这个问题很折磨人，我找不到明确的答案。它没有谷歌。

这里我有一个真正的异步方法，其中有几个await's。此方法在更高级别调用：

public async Task<Result> UpperLevelMethod()
{
    return await _component.RealyAsyncMethod();
}

依此类推，贯穿应用程序的所有层。

但理论上，你可以这样写：

public Task<Result> UpperLevelMethod()
{
    return _component.RealyAsyncMethod();
}

并且通话await UpperLevelMethod()将正常工作。而且，据我了解，这种方法更好，因为。不会创建其他实例IAsyncStateMachine，如果我错了，请纠正我。

有趣的是，绘画中的文章和书籍的作者描述了打包/解包的后果，但在异步部分中不知何故忽略了这一点。

这样的电话有什么陷阱吗？或者，在您不需要执行异步延续的情况下，是否可以（甚至更好）使该方法不是异步的？

PS同一个 Skeet 描述了最好这样做来检查参数：

public Task<Result> UpperLevelMethod(string arg)
{
    /*
    Проверка аргумента и выброс исключения в случае ошибки
    */
    return _component.RealyAsyncMethod();
}

但他具体谈论的是检查参数，以便它在同步模式下进行。关于优化 - 没什么。

更新： 版本中内置的控制台应用程序，代码如下：

static void Main(string[] args)
{
    Task.Run(Foo5);
}

static async Task<int> Foo1() => await Task.FromResult(5);

static Task<int> Foo2() => Foo1();

static Task<int> Foo3() => Foo2();

static Task<int> Foo4() => Foo3();

static Task<int> Foo5() => Foo4();

重 8192 字节，加上await's - 10240 字节。

任务是最大化应用程序某个部分的性能。在阅读了一些Habr文章之后，在某处听到或阅读了一些东西后，我开始密封类和方法（并将一些小类变成结构）。已经提交后，我决定在一个小应用程序中检查这是否真的给出了结果。

class X
{
    public int NonVirtual() => DateTime.Now.Millisecond;
    public virtual int Virtual() => DateTime.Now.Minute;
}

class Y : X
{
    public override int Virtual() => DateTime.Now.Millisecond;
}

class Program
{

    private static volatile int TST = 0;

    static int Slow(Y x) => x.Virtual();

    static int Fast(Y y) => y.NonVirtual();

    static void Main(string[] args)
    {

        int i = 0;
        var stopwatch1 = new Stopwatch();
        var stopwatch2 = new Stopwatch();

        stopwatch1.Start();
        var y = new Y();
        for (i = 0; i < 100000000; i++)
        {
            TST = Fast(y);
        }
        stopwatch1.Stop();
        Console.WriteLine("Time elapsed: {0}", stopwatch1.Elapsed);

        stopwatch2.Start();
        for (i = 0; i < 100000000; i++)
        {
            TST = Slow(y);
        }
        stopwatch2.Stop();
        Console.WriteLine("Time elapsed: {0}", stopwatch2.Elapsed);

        Console.ReadKey();
    }
}

该字段TST被声明为volatile防止编译器优化调用。

起初我很惊讶根本没有区别，然后第一个周期快了几十毫秒，然后是第二个（尽管虚拟方法表和所有这些，假设虚拟方法应该是合乎逻辑的至少落后一点）。

然后我进入了 IL：

IL_0001: callvirt  instance int32 PerformanceTests.X::Virtual()

这是一个虚方法调用。感觉真爽。第二次调用：

IL_0001: callvirt  instance int32 PerformanceTests.X::NonVirtual()

对不起，什么？callvirt? 不应该在这里call吗？sealed也不会以任何方式影响虚方法的调用。

想问问比较有经验的同事，毕竟封课在性能方面有什么意义吗？另外，为什么在 IL 中调用非虚拟函数与调用虚拟函数相同？

更新： @Grundy 在评论中写道callvirt- 因为该方法是在基类中声明的。重写代码，以便现在使用基类（即Y- 未使用）。callvirt所以它被调用。

有一个任务列表（调用相同的方法），它是这样的：

//цикл, содержащий код: 
async Task<Result> function() await _pushData(data, cToken);
_taskList.Add(Task.Run(function, cToken));

循环后：

await Task.WhenAll(_taskList);

_pushData里面包含很多子任务，几乎每个子任务都cToken.ThrowIfCancellationRequested();在启动时调用。一些（大） - 几次，在每个复杂的操作之前。任务本身处理不同数量的数据。

调用此循环的代码包含以下内容：

var cts = new CancellationTokenSource();
try
{
    await PushDataThere(data, cts.Token).ConfigureAwait(false);

    _log.Info("Успешно.");
}
catch (PushCancelledException ex)
{
    cts.Cancel();
    _log.Fatal("Остановка задач.");
    throw;
}

在这里，我发现了一个异常，如果有的话-我一次取消所有任务。

问题的本质是我在方法中编写了一个异常的测试抛出_pushData，并且在所有 44 个全局任务中，它总是throw new Exception("Test");在调用之前被调用cts.Cancel();。那些。我需要在所有任务完成之前抛出异常（如果有的话） 。

有什么办法可以解决这个问题吗？

我正在尝试通过DataContract. 该对象有一个子对象列表，这些子对象又有自己的列表（我们称它为树的叶子）。这些叶子，例如主对象列表的第一个元素，可以从列表的其他元素到达（引用相同）。结果是一个相当复杂的图，其中有许多连接。

在反序列化期间，列表的每个元素都有自己的叶子，即 如果在源对象中它是同一张表，则引用将丢失，然后在反序列化后它只是一个副本。

或多或少像这样

    A                A
   / \              / \
  B   C    ====>   B   C
   \ /             |   |
    D              D   D[копия]

（这是一个非常简化的图表）

我试图为所有课程开处方DataContract(IsReference = true)，所以，以防万一，它没有帮助。

除了“手动”构建重复源对象的结构之外，是否有“更快”的方法来正确反序列化？

谢谢你。

我正在学习如何将项目发布为 nuget 包。我用travis-ci. 我使用答案作为部署命令的基础。但我想通过 github 发布来组织发布。正如我从这里了解到的，设置部署条件非常简单。但是我找不到从发布版本中附加软件包版本的示例。我是否正确理解唯一的出路是更改文件中的版本*.csproj？

我正在尝试将 SonarQube 连接到 c# 项目。我已经承诺了这一点appveyor.yml（根据这篇文章）：

before_build:
  - nuget restore
build_script:
  - choco install "msbuild-sonarqube-runner" -y
  - MSBuild.SonarQube.Runner.exe begin /k:"MyProjectKey" /d:"sonar.host.url=https://sonarqube.com" /d:"sonar.login=MY_TOKEN"
  - msbuild "NeuralNetworkConstructor.sln"
  - MSBuild.SonarQube.Runner.exe end /d:"sonar.login=MY_TOKEN"

构建日志的一部分：

...
INFO: Sensor CPD Block Indexer
INFO: Sensor CPD Block Indexer (done) | time=0ms
INFO: 9 files had no CPD blocks
INFO: Calculating CPD for 8 files
INFO: CPD calculation finished
INFO: Analysis report generated in 156ms, dir size=101 KB
INFO: Analysis reports compressed in 47ms, zip size=59 KB
INFO: ------------------------------------------------------------------------
INFO: EXECUTION FAILURE
INFO: ------------------------------------------------------------------------
INFO: Total time: 22.312s
INFO: Final Memory: 68M/164M
INFO: ------------------------------------------------------------------------
ERROR: Error during SonarQube Scanner execution
ERROR: Insufficient privileges <<==============================
...

PS 与问题不完全相关，但我将不胜感激为可以与 appveyor 一起使用的 .net 项目提供良好的服务。我知道还有 travis-ci，但它是通过 mono 实现的。在性能方面，我对“我们什么都不承诺”感到困惑。

我不知道如何正确地表达这个问题，所以我无法用谷歌搜索。

有这样一个类

public class Some<T>
    //where T : class
{

    public T[] Variable;

}

还有另一个包含字典的：

class Another
{

    public IDictionary<Type, Some<???>> Somes;

}

相反???，需要不同的类型。可以为???（或接口）创建一个抽象类，将其写在where T : IThird. 但我需要能够创建Some<float>. 解决办法是什么？

可以不受限制地更新where（因为float它不起作用），但主要问题仍然悬而未决。更改了代码。

PS 我做不到class Another<T>- 因为。在字典中可以并排放置andSome<int>和Some<float>。

我正在学习 Java（到目前为止是为了自我开发，然后是如何进行）。该类有一个方法可以开始生成一个可能很大的数组。并且有一种获取此数组的方法。分离的，用于在单独的线程中实现生成的方法。

public float[][] getTerra() {
    if (task.isAlive()) {
        try {
            task.join(); //жду, чтобы terra сгенерилась до конца
        } catch (InterruptedException ignored) { // <--- Codecov redline
            //empty
        }
    }
    return terra;
}

codecov（单元测试覆盖率）显示处理未以任何方式进行测试catch (InterruptedException)。task如果字符串是一个私有对象，并且不希望有外部访问，你怎么能用测试覆盖它呢？还是我错误地等待线程结束？