Пример #1
0
        public async Task <List <PingResult> > PingScan(PingScanInput pingScanInput)
        {
            var result         = new BlockingCollection <PingResult>();
            var addressesPacks = pingScanInput.Addresses.ChunkInto(pingScanInput.Workers);

            await AsyncHelper.ForEach(addressesPacks, async (addressPack, token) =>
            {
                foreach (var address in addressPack)
                {
                    if (token.IsCancellationRequested)
                    {
                        break;
                    }

                    var pingResult = await Ping(new PingInput
                    {
                        Address = address,
                        Retries = pingScanInput.Retries,
                        Timeout = pingScanInput.Timeout
                    });
                    result.Add(pingResult);
                    OnDeviceScanned(pingResult);
                }
            }, pingScanInput.CancellationToken);

            var finalResult = result.ToList();

            OnDevicesScanComplete(finalResult);
            return(finalResult);
        }
Пример #2
0
        public async Task Run(IOutputInput outputInput)
        {
            var items = Enumerable.Range(1, 5)
                        .ToList();

            outputInput.WriteLine("5 tasks for 5 items without result which should finish in circa 2 seconds:");
            await AsyncHelper.ForEach(items, async (item, cancellationToken) =>
            {
                await Task.Delay(2000);
                outputInput.WriteLine($"Result: {item * 2}");
            });

            outputInput.PutLine();
            outputInput.WriteLine("5 tasks for 5 items without result which should finish in circa 2 seconds:");
            var result = await AsyncHelper.ForEachWithResult(items, async (item, cancellationToken) =>
            {
                await Task.Delay(2000);
                return(item * 2);
            });

            foreach (var pair in result)
            {
                outputInput.WriteLine($"Item: {pair.Key}, result: {pair.Value}");
            }
        }
Пример #3
0
        public async Task <List <PortScanResult> > PortScan(PortScanInput portScanInput, IPortClient portClient)
        {
            var result           = new BlockingCollection <PortScanResult>();
            var mergedInput      = MergePortScanInput(portScanInput);
            var addressPortPairs = mergedInput.ChunkInto(portScanInput.Workers);

            await AsyncHelper.ForEach(addressPortPairs, async (addressPortPair, token) =>
            {
                foreach (var pair in addressPortPair)
                {
                    if (token.IsCancellationRequested)
                    {
                        break;
                    }

                    var portResultEntry = await IsPortOpen(new PortInput
                    {
                        Address = pair.Address,
                        Retries = portScanInput.Retries,
                        Timeout = portScanInput.Timeout,
                        Port    = pair.Port
                    }, portClient);

                    var addressResult = result.FirstOrDefault(r => r.Address == pair.Address);
                    if (addressResult == null)
                    {
                        var portResult = new PortScanResult
                        {
                            Address = pair.Address,
                        };
                        portResult.Results.Add(portResultEntry);
                        result.Add(portResult);
                    }
                    else
                    {
                        addressResult.Results.Add(portResultEntry);
                    }
                    OnPortScanned(pair.Address, portResultEntry);
                }
            }, portScanInput.CancellationToken);

            var finalResult = result.ToList();

            OnPortsScanComplete(finalResult);
            return(finalResult);
        }