小编Lor*_*eno的帖子

假设我有一个界面:

interface ILoader()
{
    Task<Data> LoadAsync(int id);
}

我有两个这个接口的实现:

class NiceDataBase : ILoader 
{
    public async Task<Data> LoadAsync(int id)
    {
        //this database has async way of fetching the data
        return await NiceDataBaseDriver.LoadDataAsync(id);
    }
}

class NotNiceDataBase : ILoader 
{
    public async Task<Data> LoadAsync(int id)
    {
        //this database's driver does not have aysnc methods, because it's old or done poorly.
        return await Task.Run(() => NotNiceDataBaseDriver.LoadData(id));
    }
}

NotNiceDataBase不提供加载数据的真正异步方式,这就是为什么我实际上在一个新线程上运行它,据我所知,这不是真正的异步,因为真正的异步不使用新线程.我的NotNiceDataBase实现是好的吗？有点欺骗用户认为他正在运行真正的异步操作.

处理这种情况的最佳方法是什么？我认为NotNiceDataBase的客户端应该完全清楚他在做什么,否则他无法很好地控制hiw应用程序的性能.

我的界面可能有额外的Load方法.但在这种情况下,这里的真正好处是什么？NotNiceDataBase的仍然LoadAsync需要有一些实现.抛出NotImplementedException从来都不是一个好的解决方案.

假设我有这个代码：

export class ProductsListComponent {
  @Output() onProductSelected: EventEmitter<Product>;

  constructor() { 
    this.onProductSelected = new EventEmitter();
  }
}

这是一些用法示例EventEmitter。我不明白为什么首先我们声明 onProductSelect 明确指出它EventEmitter携带 Product 实例，然后我们仅使用new EventEmitter(). 为什么不new EventEmitter<Product>()？

我认为在 C# 中我必须采用第二种方式，因为否则如果EventEmitter是通用的，它就无法编译。为什么 TypeScript 不需要这样？

//编辑：

进一步澄清我的问题。有什么区别：

@Output() onProductSelected: EventEmitter<Product>;
this.onProductSelected = new EventEmitter();

和

@Output() onProductSelected: EventEmitter;
this.onProductSelected = new EventEmitter();

我有一个简单的程序：

class Program
{   
    static void Main(string[] args)
    {
        Run().Wait();
    }

    private static async Task Run()
    {
        string someVariable = null;
        someVariable.Replace(",", ".");
    }
}

Run（）方法是有意设计为引发NullReferenceException的。令我困扰的是为什么在网上抛出异常

Run.Wait()

而不是

someVariable.Replace(",",".");

InnerException中提供了实际的异常-为什么？我丢失了调试上下文，因为在Run方法之外引发了异常。

如果我的程序是同步的：

class Program
{
    static void Main(string[] args)
    {
        Run();
    }

    private static void Run()
    {
        string someVariable = null;
        someVariable.Replace(",", ".");
    }
}

在正确的行上抛出异常。为什么异步打破了这个？

AutoFac 允许您使用 注册泛型类builder.RegisterGeneric(Type type)，但它不接受构造参数。该方法的描述甚至说：

注册一个非参数化的通用类型

但是，如果我有一个由 Service 实现的通用接口 IService，需要一些参数怎么办？

目前我已经这样注册了：

builder.Register(c =>
    new Service<Class1>(
        parameter1,
        parameter2))
    .As<IService<Class1>>();

在注册时，我必须指定 T 的确切类型（在本例中为 Class1）。我可以更通用地进行操作，以便我可以为任何 T 提供一个注册吗？

在使用 async-await 的程序中，我的理解是这样的：

• 未等待的异步方法将在后台运行 (?)，其余代码将在此非等待方法完成之前继续执行
• IS 等待的异步方法将等待该方法完成，然后再转到下一行代码

下面的申请是我写的，以检查上述陈述是否正确。

using System;
using System.Threading.Tasks;

namespace ConsoleApp3
{
    class Program
    {
        static async Task Main(string[] args)
        {
            Console.WriteLine("Hello World!");

            DoJob();

            var z = 3;

            Console.ReadLine();
        }

        static async Task DoJob()
        {
            var work1 = new WorkClass();
            var work2 = new WorkClass();

            while (true)
            {
                await work1.DoWork(500);
                await work2.DoWork(1500);
            }
        }
    }

    public class WorkClass
    {
        public async Task DoWork(int delayMs)
        {
            var x = 1;

            await Task.Delay(delayMs);

            var y = 2;
        }
    } …

很长一段时间以来，我一直试图理解.NET中的异步等待内容，但是我却难以成功，所以当我使用异步时，总会发生意想不到的事情。

这是我的应用程序：

namespace ConsoleApp3
{
    class Program
    {
        static async Task Main(string[] args)
        {
            Console.WriteLine("Hello World!");

            var work1 = new WorkClass();
            var work2 = new WorkClass();

            while(true)
            {
                work1.DoWork(500);
                work2.DoWork(1500);
            }
        }
    }

    public class WorkClass
    {
        public async Task DoWork(int delayMs)
        {
            var x = 1;

            await Task.Delay(delayMs)

            var y = 2;
        }
    }
}

这只是我创建的一个示例，用于检查代码将如何执行。有几件事使我感到惊讶。首先，涉及很多线程！如果我在上面设置了一个断点，则var y = 2;可以看到那里的threadId不同，它可以是1、5、6或其他。这是为什么？我认为async / await不会自己使用其他线程，除非我明确命令（使用Task.Run或创建新线程）。至少本文试图说出我的想法。

好的，但是我们可以说出于某种原因还有其他一些线程-即使它们是，我await Task.Delay(msDelay);也没有ConfigureAwait(false)！据我了解，没有此调用，线程不应更改。

我很难很好地理解这个概念，因为我找不到任何可以包含所有信息而不只是几条信息的优质资源。