小编edd*_*P23的帖子

在Scala中有一个Promise类,可用于手动完成Future.我正在寻找C#的替代品.

我正在编写测试,我希望它看起来与此类似:

// var MyResult has a field `Header`
var promise = new Promise<MyResult>;

handlerMyEventsWithHandler( msg =>
    promise.Complete(msg);
);

// Wait for 2 seconds
var myResult = promise.Future.Await(2000);

Assert.Equals("my header", myResult.Header);

我知道这可能不是C#的正确模式,但我无法找到一种合理的方法来实现同样的东西,即使是有些不同的模式.

编辑:请注意,这async//await没有帮助,因为我没有任务等待!我只能访问将在另一个线程上运行的处理程序.

在我的 Asp.Net Core 应用程序中，我需要一个可以在应用程序的生命周期内重用的单例服务。为了构建它，我需要一个DbContext（来自 EF Core），但它是一个作用域服务并且不是线程安全的。

因此，我使用以下模式来构建我的单例服务。它看起来有点老套，因此我想知道这是否是一种可以接受的方法并且不会导致任何问题？

services.AddScoped<IPersistedConfigurationDbContext, PersistedConfigurationDbContext>();
services.AddSingleton<IPersistedConfigurationService>(s =>
{
    ConfigModel currentConfig;
    using (var scope = s.CreateScope())
    {
        var dbContext = scope.ServiceProvider.GetRequiredService<IPersistedConfigurationDbContext>();
        currentConfig = dbContext.retrieveConfig();            
    }
    return new PersistedConfigurationService(currentConfig);
});

...

public class ConfigModel
{
    string configParam { get; set; }
}

我使用的是 dotnet core 2+，但问题可能更通用。

我的 CI 管道目前看起来像这样：

• dotnet build -c Release
• dotnet test
• dotnet public -c Release --no-build

对于测试步骤，它使用默认Debug配置，因此它也必须使用Debugconfig.js构建应用程序。

因此，我想知道，使用Debug而不是运行测试是否有任何优势，Release或者我应该简单地添加dotnet test -c Release？

我正在努力实现一件非常简单的事情。我有一个 Enumerable 元组，我想同时映射和解构它们（因为使用.Item1,.Item2很难看）。

像这样的东西：

        List<string> stringList = new List<string>() { "one", "two" };

        IEnumerable<(string, int)> tupleList =
            stringList.Select(str => (str, 23));

        // This works fine, but ugly as hell
        tupleList.Select(a => a.Item1 + a.Item2.ToString());

        // Doesn't work, as the whole tuple is in the `str`, and num is the index
        tupleList.Select((str, num) => ...);
        // Doesn't even compile
        tupleList.Select(((a, b), num) => ...);

我正在做一些调试，并希望在开发人员工具中查看完整的 URL，但我找不到方法。

因此我想知道：

• 有办法实现吗？如果没有，那我该如何处理呢？
• 为什么 Chrome 默认情况下不显示此信息？我不认为这可能是一个安全问题，因为 Chrome 正在显示所有其他敏感信息。

示例：当我去https://stackoverflow.com/abc#qwerty：

这是我在网络选项卡中看到的：

我正在使用此处描述的 Dotnet Core 运行状况检查。简而言之，它看起来像这样：

首先，您可以像这样配置服务：

services.AddHealthChecks()
    .AddSqlServer("connectionString", name: "SQlServerHealthCheck")
    ... // Add multiple other checks

然后，您注册一个端点，如下所示：

app.UseHealthChecks("/my/healthCheck/endpoint");

我们也在使用 Swagger（又名 Open API），我们通过 Swagger UI 查看所有端点，但看不到健康检查端点。

有没有办法将它添加到控制器方法中，以便 Swagger 自动获取端点，或者以另一种方式将它与 swagger 集成？

到目前为止，我发现的最佳解决方案是添加自定义硬编码端点（如此处所述），但维护起来并不好。

我不明白为什么以下编译：

StringValues sv = httpContext.Request.Query["param"];
string s = sv;

据我所知，只有在类型为或extends/implements 时才可a分配给。但是查看文档它看起来不像扩展（是一个密封的类，因此它甚至不应该是可能的）。bababStringValuesstringstring

所以我认为这是这里进行的一些隐式转换，但我找不到任何关于它的信息。

想象一下，在 ASP.NET Core 中我注册了一个依赖项，如下Scoped所示：

IServiceCollection services = ...
services.AddScoped<IEmailService, EmailService>();

然后我知道对于每个 HTTP 请求，scope都会创建一个新的请求，并且Email会重用一个新的服务实例。此外，同样的情况scope将在请求的生命周期内持续存在。

现在，假设我添加了一个 Hangfire 后台作业，如下所示：

RecurringJob.AddOrUpdate<IServiceA>("DoA", s => s.DoA(), Cron.Daily());

在哪里

public class ServiceA: IServiceA {
    public ServiceA(IEmailService emailService) { ... }
    public void DoA() { ... }
}

我想了解scopedhangfire工作术语中的含义，默认情况下，hangfire

• 对所有作业和运行使用单一范围
• 为每个作业创建单独的作用域，但同一作业的不同运行共享作用域
• 为任何作业的每次运行创建单独的范围

有关如何配置它的解释的奖励积分。

在我们的应用程序中，我们有很多地方可以使用：

someObservable.take(1).subscribe(onSuccessHandler, onFailureHandler);

但是对于订阅，您需要担心在某个时候退订，这并不总是那么简单。

我当时想简化此过程并将其重写为：

someObservable.toPromise().then(onSuccessHandler).catch(onFailureHandler);

但是，看一下toPromise()（here）的实现，我似乎不明白为什么它不关心取消订阅。

代码中的注释说无法取消，但我们如何像这样将其保留以泄漏内存（以防实际情况）。

编辑

我想出了一个让我担心的例子：

Observable.timer(10, 10).toPromise().then((v) => console.log("I'm done"));

如果我检索到的可观测值永远无法完成，那么不仅我的承诺永远不会完成，而且我也无法取消订阅此类可观测值（例如，使它们和我的承诺超时），因为我无权获取订阅对象。那确实会泄漏内存！

以前肯定有人问过这个问题，但是如何在 JS 中展平承诺？

像这样的东西：

let justAPromise: Promise<something> = aPromise.flatMap( a => getAnotherPromise());

或者像这样：

let promiseOfPromise: Promise<Promise<something>> = aPromise.then( a => getAnotherPromise());
let justAPromise: Promise<something> = promiseOfPromise.flatten();

编辑：

澄清我所说的扁平化承诺的含义。我看到以下两者之间存在巨大差异。第一个是int的promise，第二个是int的promise：

Promise.resolve(23);

Promise.resolve("whatever").then(a => Promise.resolve(23));