C# 中的单任务与列表<Task>

Question

我正在用 C# 创建一个简单的端口扫描器，它应该扫描给定 IP 范围的开放端口。我在大部分代码中使用 async/await 和 Task，如下所示：

internal class PortScanner
{
    private IPAddress host;
    private int startPort;
    private int endPort;

    private const int PORT_MIN_VALUE = 1;
    private const int PORT_MAX_VALUE = 65535;

    public PortScanner(IPAddress host, int portStart, int portStop)
    {
        this.host = host;
        this.startPort = portStart;
        this.endPort = portStop;
    }

    public PortScanner(IPAddress host)
        : this(host, PORT_MIN_VALUE, PORT_MIN_VALUE)
    {
    }

    private async Task<bool> IsPortOpen(int port)
    {
        Socket socket = null;

        try
        {
            // make a TCP based socket
            socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            // connect
            await Task.Run(() => socket.Connect(this.host, port));

            return true;
        }
        catch (SocketException ex)
        {
            if (ex.SocketErrorCode == SocketError.ConnectionRefused)
            {
                return false;
            }
        }
        finally
        {
            if (socket?.Connected ?? false)
            {
                socket?.Disconnect(false);
            }
            socket?.Close();
        }

        return false;
    }

    private async Task CheckPort(int port)
    {
        if (await IsPortOpen(port))
        {
            Console.WriteLine("Host: {0} - Port: {1} is open.", this.host.ToString(), port.ToString());
        }
    }

    public async Task Scan()
    {
        Console.WriteLine("Scanning for {0}", this.host);
        for (int port = this.startPort; port <= this.endPort; port++)
        {
            await CheckPort(port);
        }
    }
}

现在，关键是如果在 Main 函数中，我使用单个 Task 像这样：

try
{
    PortScanner ps = new PortScanner(ipsInRange.Begin, 15, 25);
    var task = ps.Scan();
    task.Wait();
}
catch (Exception ex)
{
    Console.WriteLine(ex);
}

它工作正常，因为我得到了如下输出（并且需要几秒钟才能完成）：

Scanning for 192.168.1.1
Host: 192.168.1.1 - Port: 21 is open.
Host: 192.168.1.1 - Port: 23 is open.

但是，当我尝试使用 List<Task> 时，例如：

foreach (var set in setOfIPs)
{
    List<Task> scanTasks = new List<Task>(set.Count());

    foreach (var ip in set)
    {
        scanTasks.Add(Task.Factory.StartNew(async () =>
        {
            PortScanner ps = new PortScanner(ip, 15, 25);
            await ps.Scan();
        }));
    }

    Task.WaitAll(scanTasks.ToArray());
}

我得到的输出只是这样（程序也在 1 秒内立即完成）：

Scanning for 192.168.1.3
Scanning for 192.168.1.2
Scanning for 192.168.1.1
Scanning for 192.168.1.4
Scanning for 192.168.1.5

因此，它基本上似乎不会单独扫描每个端口，因为它不会打印任何打开的端口。任何想法可能是什么问题，我如何在 List<Task>?

中调用多个 Task

Answer 1

这是Task.Factory.StartNew的经典陷阱。方法 return 是 Task<T>，其中 T 是回调的 return 类型。您的 lambda 是异步的，因此 return 是一个任务。放在一起，你最终得到一个 Task<Task>，你在等待外部任务，而你应该等待内部任务。

两种解决方案：

推荐的一种：使用Task.Run代替Task.Factory.StartNew。这是一般性建议，除非您知道这是正确的解决方案，否则永远不要使用 Task.Factory.StartNew。 Task.Run 避免了很多陷阱，例如你运行进入的陷阱。
```
scanTasks.Add(Task.Run(async () =>
{
    PortScanner ps = new PortScanner(ip, 15, 25);
    await ps.Scan();
}));
```

如果你有正当理由使用 Task.Factory.StartNew，那么你可以在任务上使用 .Unwrap() 方法来等待内部任务：

scanTasks.Add(Task.Factory.StartNew(async () =>
{
    PortScanner ps = new PortScanner(ip, 15, 25);
    await ps.Scan();
}).Unwrap());

C# 中的单任务与列表<Task>

Single Task vs List<Task> in C#

c#

multithreading

network-programming