C#程序的异步流

为了演示C#的异步流，我编写了一个简单的程序 （以显示其与Python的区别，因为Python是同步的，因为）

为什么func2（）的执行要等待func1（）完成？

void main()
{
    Console.WriteLine("main");
    func1();
    func2();
}
public void func1()
{
    Console.WriteLine("func1");
    double i = 0;
    while(true)
    {
      i += 1;
      if (i > 100000000)
      {
       break;
      }
    }
    func(3);
    func(4);
}
public void func2()
{
    Console.WriteLine("func2");
    func(5);
    func(6);
}
public void func(int number)
{
    Console.WriteLine(number);
}

在func1（）中，我运行一个循环使程序等待，以便main（）继续运行，并在func（3）和func（4）之前调用func2（）。但每次都以同步方式运行，并按以下顺序打印输出：

main
func1
3
4
func2
5
6

i、 e.func2（）总是在func4（）之后调用，这是我在异步流中没有想到的

为什么func2（）的执行要等待func1（）完成？

void main()
{
    Console.WriteLine("main");
    func1();
    func2();
}
public void func1()
{
    Console.WriteLine("func1");
    double i = 0;
    while(true)
    {
      i += 1;
      if (i > 100000000)
      {
       break;
      }
    }
    func(3);
    func(4);
}
public void func2()
{
    Console.WriteLine("func2");
    func(5);
    func(6);
}
public void func(int number)
{
    Console.WriteLine(number);
}

---

谢谢

C#无法使您的程序同步。所有程序都是同步的（多核除外）。即使是操作系统也是同步运行的，通过给不同的程序执行时间片，也只能产生并行处理的假象。如果你想让你的程序并行运行，你必须明确地告诉它。C#/.NET有许多机制可以做到这一点，但说一种语言是异步的是不公平的。多线程代码可以用C编写以在windows上运行，但如果您在不支持并行处理的嵌入式系统上工作，则不能。

C#不会使您的程序同步。所有程序都是同步的（多核除外）。即使是操作系统也是同步运行的，通过给不同的程序执行时间片，也只能产生并行处理的假象。如果你想让你的程序并行运行，你必须明确地告诉它。C#/.NET有许多机制可以做到这一点，但说一种语言是异步的是不公平的。多线程代码可以用C编写，以便在windows上运行，但如果您在不支持并行处理的嵌入式系统上工作，则无法执行。

如果希望func2不等待func1完成，则需要告诉它：

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("main");
        doWork();
    }
    public async static void doWork()
    {
        Task<int> longTask = func1(); //Start func1
        func2(); //Call func2 while we wait
        int output = await longTask; //Wait for func2 to be finished
    }
    public async static Task<int> func1()
    {
        Console.WriteLine("func1");

        await Task.Delay(10000); //delay, could make func(3) and func(4) run in the meantime if we wanted....

        func(3);
        func(4);
        return 0;
    }
    public static void func2()
    {
        Console.WriteLine("func2");
        func(5);
        func(6);
    }
    public static void func(int number)
    {
         Console.WriteLine(number);
    }
}

---

如果希望func2不要等待func1完成，则需要告诉它：

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("main");
        doWork();
    }
    public async static void doWork()
    {
        Task<int> longTask = func1(); //Start func1
        func2(); //Call func2 while we wait
        int output = await longTask; //Wait for func2 to be finished
    }
    public async static Task<int> func1()
    {
        Console.WriteLine("func1");

        await Task.Delay(10000); //delay, could make func(3) and func(4) run in the meantime if we wanted....

        func(3);
        func(4);
        return 0;
    }
    public static void func2()
    {
        Console.WriteLine("func2");
        func(5);
        func(6);
    }
    public static void func(int number)
    {
         Console.WriteLine(number);
    }
}

---

这是因为每次调用方法时，在C#中，传递给参数的信息都存储在堆栈（调用堆栈）中。该堆栈以先进先出的方式实现。 因此，在您的示例中，当调用func1时，它进入堆栈，main方法将停止并等待func1离开堆栈。

如果没有异步流，就无法实现您想要的功能，我怀疑python也是如此

但是，您可以轻松地更改代码以异步执行它

    public static void Main()
{
    Console.WriteLine("main");
    var t = func1();
    func2();
    t.Wait();
}

public static Task func1()
{
    Console.WriteLine("func1");
    return Task.Factory.StartNew(() => {
        double i = 0;
        while(true)
        {
          i += 1;
          if (i > 100000000)
          {
           break;
          }
        }
        func(3);
        func(4);
    });
}
public static void func2()
{
    Console.WriteLine("func2");
    func(5);
    func(6);
}
public static void func(int number)
{
    Console.WriteLine(number);
}

---

这是因为每次调用方法时，在C#中，传递给参数的信息都存储在堆栈（调用堆栈）中。该堆栈以先进先出的方式实现。 因此，在您的示例中，当调用func1时，它进入堆栈，main方法将停止并等待func1离开堆栈。

如果没有异步流，就无法实现您想要的功能，我怀疑python也是如此

但是，您可以轻松地更改代码以异步执行它

    public static void Main()
{
    Console.WriteLine("main");
    var t = func1();
    func2();
    t.Wait();
}

public static Task func1()
{
    Console.WriteLine("func1");
    return Task.Factory.StartNew(() => {
        double i = 0;
        while(true)
        {
          i += 1;
          if (i > 100000000)
          {
           break;
          }
        }
        func(3);
        func(4);
    });
}
public static void func2()
{
    Console.WriteLine("func2");
    func(5);
    func(6);
}
public static void func(int number)
{
    Console.WriteLine(number);
}

---

了解

async

关键字。你需要告诉程序，异步做事情是可以的，否则它会假设他们需要在Pythyon中完成，也可能是异步的……边注：考虑不想出你自己的“脚本”或“编程”的定义——这可能会导致你的帖子不必要的讨论。这真的与你的问题无关。@AlexeiLevenkov:好的观点：）。我将删除该部分。请阅读

async

关键字。你需要告诉程序，异步做事情是可以的，否则它会假设他们需要在Pythyon中完成，也可能是异步的……边注：考虑不想出你自己的“脚本”或“编程”的定义——这可能会导致你的帖子不必要的讨论。这真的与你的问题无关。@AlexeiLevenkov:好的观点：）。我将删除该部分。你好，幽灵，谢谢你的回复。C#本身不是异步的吗（即不使用async关键字）？我们使用callback（）来确保某个函数在另一个函数之后执行的原因之一。可以使用其他构造，但

async

是最新的构造。如果您不使用这些构造之一，它将按顺序单独执行每条指令。您好，Ghost，谢谢您的回复。C#本身不是异步的吗（即不使用async关键字）？我们使用callback（）来确保某个函数在另一个函数之后执行的原因之一。可以使用其他构造，但

async

是最新的构造。如果不使用这些构造之一，它将按顺序单独执行每条指令。