¿Cómo se relacionan entre sí el Marco Reactivo, PLINQ, TPL y las extensiones Paralelas?

PLINQ (Parallel Linq) es simplemente una nueva forma de escribir consultas Linq regulares para que se ejecuten en paralelo; en otras palabras, el Marco se encargará automáticamente de ejecutar su consulta a través de múltiples subprocesos para que terminen más rápido (es decir, utilizando múltiples núcleos de CPU).

Por ejemplo, digamos que tienes un montón de cadenas y quieres obtener todas las que comienzan con la letra "A". Puedes escribir tu consulta así:

var words = new[] { "Apple", "Banana", "Coconut", "Anvil" };
var myWords = words.Select(s => s.StartsWith("A"));

Y esto funciona fino. Sin embargo, si tuviera 50.000 palabras para buscar, es posible que desee aprovechar el hecho de que cada prueba es independiente y dividir esto en varios núcleos:

var myWords = words.AsParallel().Select(s => s.StartsWith("A"));

Eso es todo lo que tiene que hacer para convertir una consulta regular en una paralela que se ejecute en varios núcleos. Bastante limpio.

El TPL (Biblioteca Paralela de Tareas) es una especie de complemento de PLINQ, y juntos forman Extensiones Paralelas. Mientras que PLINQ se basa en gran medida en un funcional estilo de programación con no efectos secundarios, los efectos secundarios son precisamente para lo que está el TPL. Si quieres realmente trabajar en paralelo en lugar de simplemente buscar/seleccionar cosas en paralelo, utiliza el TPL.

El TPL es esencialmente la clase Parallel que expone sobrecargas de For, Foreach, y Invoke. Invoke es un poco como hacer cola de tareas en el ThreadPool, pero un poco más simple de usar. IMO, los bits más interesantes son el For y Foreach. Por ejemplo, digamos que tienes un montón de archivos que quieres comprimir. Usted podría escribir la versión secuencial regular:

string[] fileNames = (...);
foreach (string fileName in fileNames)
{
    byte[] data = File.ReadAllBytes(fileName);
    byte[] compressedData = Compress(data);
    string outputFileName = Path.ChangeExtension(fileName, ".zip");
    File.WriteAllBytes(outputFileName, compressedData);
}

De nuevo, cada iteración de esta compresión es completamente independiente de cualquier otra. Podemos acelerar esto haciendo varios de ellos a la vez:

Parallel.ForEach(fileNames, fileName =>
{
    byte[] data = File.ReadAllBytes(fileName);
    byte[] compressedData = Compress(data);
    string outputFileName = Path.ChangeExtension(fileName, ".zip");
    File.WriteAllBytes(outputFileName, compressedData);
});

Y de nuevo, eso es todo lo que se necesita para paralelizar esta operación. Ahora, cuando ejecutamos nuestro método CompressFiles (o como decidamos llamarlo), usará múltiples núcleos de CPU y probablemente terminará a la mitad o 1/4 de la vez.

La ventaja de esto sobre simplemente tirarlo todo en el ThreadPool es que esto en realidad se ejecuta sincrónicamente. Si usaras ThreadPool en su lugar (o simplemente Thread instancias), tendrías que encontrar una manera de averiguar cuándo todas las tareas están terminadas, y aunque esto no es terriblemente complicado, es algo con lo que mucha gente tiende a meter la pata o al menos tiene problemas. Cuando usas la clase Parallel, no tienes que pensar sobre ello; el aspecto de multi-threading está oculto para ti, todo se maneja detrás de las escenas.

Las extensiones reactivas (Rx) son realmente una bestia completamente diferente. Es una forma diferente de pensar sobre el manejo de eventos. Realmente hay mucho material para cubrir en esto, pero para hacer una larga historia corta, en lugar de conectar los controladores de eventos a los eventos, Rx le permite tratar las secuencias de eventos como... bueno, secuencias (IEnumerable<T>). Puedes procesar eventos de manera iterativa en lugar de dispararlos asincrónicamente en momentos aleatorios, donde tienes que guardar estado todo el tiempo para detectar una serie de eventos que ocurren en un orden particular.

Uno de los mejores ejemplos que he encontrado de Rx es aquí. Vaya a la sección" Linq to IObservable " donde implementa un controlador de arrastrar y soltar, que normalmente es un dolor en WPF, en solo 4 líneas de código. Rx te da composición de eventos, algo que realmente no tienes con los controladores de eventos regulares y los fragmentos de código como estos también son fáciles de refactorizar en clases de comportamiento que puede incluir en cualquier lugar.

Y eso es todo. Estas son algunas de las características más frescas que están disponibles en. NET 4.0. Hay varios más, por supuesto,pero estos fueron los que usted preguntó!