Olá pessoal, tudo bem?

O .net 4.0 veio cheio de novidades interessantíssimas para utilizarmos no desenvolvimento do nosso dia-a-dia. Uma delas se trata de Parallel Programming ou Programação Paralela. Mas o que se pode entender sobre Programação Paralela? Trata-se de uma programação que já estamos acostumados ou já vimos alguns códigos na internet sobre chamarmos outros métodos para serem executados por Threads diferentes? Mas como assim? Está meio confuso para você entender? Então vamos detalhar um pouco o que estou falando para melhorar o seu entendimento.

Antes, quando nós queriamos utilizar uma programação paralela, nós diziamos que iriamos utilizar uma Thread, não era dessa forma? Para você entender, o seu programa Console, por exemplo, é uma Thread, e tudo que é executado dentro do seu programa Console, roda dentro desta Thread, que chamamos de Thread Principal da aplicação. Ai veio o LINQ… Mas espera, o que o LINQ tem a ver com Paralelismo ou com programação Multi-Thread? Calma, vou explicar !

De fato o LINQ não tem nada a ver com Programação Paralela, nem muito menos com programação Multi-Thread, mas o que queremos falar do LINQ, envolvendo este assunto é o recurso que foi adicinado ao LINQ na versão do .NET 4.0, o qual a Microsoft chama de: Parallel Programming. Com a implementação deste recurso, não mais precisamos criar uma Thread para trabalhar em paralelo ao que estamos fazendo, como por exemplo, Consultas sejam em Lists, IEnumerable, ou num banco de dados, via LINQ. Este novo recurso, cria toda a estrutura do paralelismo por trás dos bastidores para nós, não nos preocuparmos com isso. E para mostrarmos como funciona este novo recurso no LINQ, segue o bloco de código abaixo:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;
using System.Net.NetworkInformation;

namespace TesteParallelism
{
    class Program
    {
        static void Main(string[] args)
        {
            var consultaSites = from site in new[]
                {
                    "jrobertoaraujo.wordpress.com",
                    "www.microsoft.com",
                    "www.asp.net",
                    "www.bing.com",
                    "www.desenvolvendoparaweb.net",
                    "www.codeplex.com"
                }
                .AsParallel()
                .WithDegreeOfParallelism(6) let p = new Ping()
                    .Send(site) select new
                        {
                            site,
                            Result = p.Status,
                            Time = p.RoundtripTime
                        };
            foreach (var s in consultaSites.ToList())
            {
                Console.WriteLine(s.site + ": " + s.Result + ": " + s.Time);
            }
            
            Console.ReadKey();
        }
    }
}

O que este código faz afinal? Vamos comenta-lo para que você possa conhecer este excelente recurso.

Primeiramente criei um array com alguns valores string, que correspondem vários sites que serão utilizados para realizar um ping:

var consultaSites = from site in new[]
                {
                    "jrobertoaraujo.wordpress.com",
                    "www.microsoft.com",
                    "www.asp.net",
                    "www.bing.com",
                    "www.desenvolvendoparaweb.net",
                    "www.codeplex.com"
                }

Como todos já devem saber, qualquer estrutura de dados, que possibilite você ter algo parecido com uma Lista, como um Array, por exemplo, desde o lançamento do LINQ, podemos realizar consultas ou qualquer tipo de operação LINQ nesta estrutura; que é o que estamos fazendo, quando usamos o código abaixo:

.AsParallel().WithDegreeOfParallelism(6)

Mas o que este código faz? É por meio dele que temos acesso ao novo recurso de paralelismo com o LINQ. Estes comandos informam para a consulta LINQ que será utilizada a estrutura de Paralelismo, fazendo uso de 6 núcleos dos processadores. Este recurso de poder informar a quantidade de processadores é interessante, mas vai até um limite de 64 processadores, acho que está bom né? rs rs

Após configurar a estrutura de Paralelismo, temos a declaração de uma variável, que no LINQ declaramos da seguinte forma:

let p = new Ping().Send(site)

Através da palavra reservada let. Então, agora temos um objecto do tipo Ping, e fazemos uso, da consulta LINQ, passando a string contendo o Site para ser realizado um Ping neste site.

Por último montamos a estrutura que será retornada na consulta LINQ, como mostrado abaixo:

 select new { site, Result = p.Status, Time = p.RoundtripTime };

Se você perceber a variável p é o objeto do tipo Ping, ou seja, temos acesso, agora, as várias propriedades da classe Ping, e assim podemos usar o valor dessas propriedades para retornar na estrutura. Pronto! pode executar o código acima e teremos o seguinte resultado:

Espero que tenham gostado do novo recurso!

Até o próximo post.