Mostrando las entradas con la etiqueta PLINQ. Mostrar todas las entradas
Mostrando las entradas con la etiqueta PLINQ. Mostrar todas las entradas

jueves, 25 de enero de 2018

El Manual del Día: Programación Asíncrona y Paralela en .NET 4.5

MSDN - Manual de Programación Asíncrona y Paralela en .NET 4.5

Titulo: Manual de Programación Asíncrona y Paralela en .NET 4.5
Fuente Original: Microsoft Developer Network (MSDN)
Compilado Por: Luis Dueñas Huaroto (Lduenas)
Año de Compilación: 2010
Número de Páginas: 336

Indice del Manual de Programación Asíncrona y Paralela en .NET 4.5

1. Subprocesamiento administrado
  1.1. Principios básicos del subprocesamiento administrado
    1.1.1. Subprocesos y subprocesamiento
    1.1.2. Excepciones en subprocesos administrados
    1.1.3. Sincronizar datos para subprocesamiento múltiple
    1.1.4. Estados de subprocesos administrados
    1.1.5. Subprocesos de primer y segundo plano
    1.1.6. Subprocesamiento administrado y no administrado en Windows
    1.1.7. Thread.Suspend, recolección de elementos no utilizados y puntos de seguridad
    1.1.8. Almacenamiento local de subprocesos: Campos estáticos relacionados con
              subprocesos y ranuras de datos
    1.1.9. Cancelación en subprocesos administrados
      1.1.9.1. Cómo: Realizar escuchas de solicitudes mediante sondeo
      1.1.9.2. Cómo: Registrar devoluciones de llamadas de solicitudes de cancelación
      1.1.9.3. Cómo: Realizar escuchas de solicitudes de cancelación cuando tienen
                   controladores de espera
      1.1.9.4. Cómo: Realizar escuchas de varias solicitudes de cancelación
  1.2. Utilizar subprocesos y subprocesamiento
    1.2.1. Crear subprocesos y analizar los datos en el inicio
    1.2.2. Pausar y reanudar subprocesos
    1.2.3. Destruir subprocesos
    1.2.4. Planear subprocesos
    1.2.5. Cancelar subprocesos de manera cooperativa
  1.3. Procedimientos recomendados para el subprocesamiento administrado
  1.4. Objetos y características de subprocesos
    1.4.1. Grupo de subprocesos administrados
    1.4.2. Temporizadores
    1.4.3. Monitores
    1.4.4. Controladores de espera
    1.4.5. Controladores de espera
      1.4.5.1. EventWaitHandle
      1.4.5.2. AutoResetEvent
      1.4.5.3. ManualResetEvent y ManualResetEventSlim
      1.4.5.4. CountdownEvent
    1.4.6. Exclusiones mutuas (mutex)
    1.4.7. Operaciones de bloqueo
    1.4.8. Bloqueos de lector y escritor
    1.4.9. Semaphore y SemaphoreSlim
    1.4.10. Información general sobre los primitivos de sincronización
    1.4.11. Barrier
      1.4.11.1. Cómo: Sincronizar operaciones simultáneas con una clase Barrier
    1.4.12. SpinLock
      1.4.12.1. Cómo: Utilizar SpinLock para la sincronización de bajo nivel
      1.4.12.2. Cómo: Habilitar el modo de seguimiento de subproceso en el bloqueo SpinLock
    1.4.13. Tokens de cancelación
    1.4.14. SpinWait
      1.4.14.1. Cómo: Usar SpinWait para implementar una operación de espera de dos fases
2. Modelos para la programación asincrónica
  2.1. Modelo asincrónico basado en tareas (TAP)
    2.1.1. Implementar el modelo asincrónico basado en tareas
    2.1.2. Utilizar el modelo asincrónico basado en tareas
    2.1.3. Interoperabilidad con los modelos asincrónicos y otros tipos
  2.2. Publicar datos de símbolos
    2.2.1. Programación multiproceso con el modelo asincrónico basado en eventos
      2.2.1.1. Información general sobre el modelo asincrónico basado en eventos
      2.2.1.2. Implementar el modelo asincrónico basado en eventos
      2.2.1.3. Procedimientos recomendados para implementar el modelo asincrónico
                   basado en eventos
      2.2.1.4. Decidir cuándo implementar el modelo asincrónico basado en eventos
      2.2.1.5. Tutorial: Implementar un componente que admita el modelo asincrónico
                   basado en eventos
        2.2.1.5.1. Cómo: Implementar un componente que admita el modelo asincrónico
                        basado en eventos
        2.2.1.5.2. Cómo: Implementar un cliente en un modelo asincrónico basado en eventos
      2.2.1.6. Cómo: Utilizar componentes que admitan el modelo asincrónico basado en eventos
  2.3. Modelo de programación asincrónica (APM)
    2.3.1. Llamar a métodos asincrónicos mediante IAsyncResult
      2.3.1.1. Bloquear la ejecución de una aplicación mediante AsyncWaitHandle
      2.3.1.2. Bloquear la ejecución de una aplicación al finalizar una operación asincrónica
      2.3.1.3. Sondear el estado de una operación asincrónica
      2.3.1.4. Utilizar un delegado AsyncCallback para finalizar una operación asincrónica
        2.3.1.4.1. Utilizar un delegado AsyncCallback y un objeto State
    2.3.2. Programación asincrónica mediante delegados
      2.3.2.1. Llamar a métodos sincrónicos de forma asincrónica
      2.3.2.2. Ejemplo de programación de delegados asincrónicos
3. Programación paralela en .NET Framework
  3.1. Biblioteca de procesamiento paralelo basado en tareas (TPL)
    3.1.1. Paralelismo de datos (Task Parallel Library)
      3.1.1.1. Cómo: Escribir un bucle Parallel.For simple
      3.1.1.2. Cómo: Escribir un bucle Parallel.ForEach simple
      3.1.1.3. Cómo: Detener o interrumpir un bucle Parallel.For
      3.1.1.4. Cómo: Escribir un bucle Parallel.For que tenga variables locales de subproceso
      3.1.1.5. Cómo: Escribir un bucle Parallel.ForEach que tenga variables locales de subproceso
      3.1.1.6. Cómo: Cancelar un bucle Parallel.For o ForEach
      3.1.1.7. Cómo: Controlar excepciones en bucles paralelos
      3.1.1.8. Cómo: Acelerar cuerpos de bucle pequeños
      3.1.1.9. Cómo: Recorrer en iteración directorios con la clase paralela
    3.1.2. Paralelismo de tareas (Task Parallel Library)
      3.1.2.1. Tareas de continuación
      3.1.2.2. Tareas anidadas y tareas secundarias
      3.1.2.3. Cancelación de tareas
      3.1.2.4. Control de excepciones
      3.1.2.5. Cómo: Usar Parallel.Invoke para ejecutar operaciones paralelas
      3.1.2.6. Cómo: Devolver un valor de una tarea
      3.1.2.7. Cómo: Esperar a que una o varias tareas se completen
      3.1.2.8. Cómo: Cancelar una tarea y sus elementos secundarios
      3.1.2.9. Cómo: Controlar excepciones iniciadas por tareas
      3.1.2.10. Cómo: Encadenar varias tareas con continuaciones
      3.1.2.11. Cómo: Crear tareas precalculadas
      3.1.2.12. Cómo: Recorrer un árbol binario con tareas paralelas
      3.1.2.13. Cómo: Desencapsular una tarea anidada
      3.1.2.14. Cómo: Evitar que una tarea secundaria se adjunte a su elemento primario
    3.1.3. Biblioteca de procesamiento paralelo basado en tareas (TPL)
      3.1.3.1. Cómo: Escribir y leer mensajes en un bloque de flujo de datos
      3.1.3.2. Cómo: Implementar un modelo de flujo de datos productor-consumidor
      3.1.3.3. Cómo: Realizar una acción cuando un bloque de flujos de datos recibe datos
      3.1.3.4. Tutorial: Crear una canalización de flujos de datos
      3.1.3.5. Cómo: Desvincular bloques de flujos de datos
      3.1.3.6. Tutorial: Usar flujos de datos en aplicaciones de Windows Forms
      3.1.3.7. Cómo: Cancelar un bloque de flujos de datos
      3.1.3.8. Tutorial: Crear tipos de bloques de flujos de datos personalizados
      3.1.3.9. Cómo: Usar JoinBlock para leer datos de diferentes orígenes
      3.1.3.10. Cómo: Especificar el grado de paralelismo en un bloque de flujos de datos
      3.1.3.11. Cómo: Especificar un programador de tareas en un bloque de flujos de datos
      3.1.3.12. Tutorial: Usar BatchBlock y BatchedJoinBlock para mejorar la eficacia
    3.1.4. TPL con otros modelos asincrónicos
      3.1.4.1. TPL y la programación asincrónica tradicional de .NET
      3.1.4.2. Cómo: Encapsular modelos de EAP en una tarea
      3.1.4.3. Problemas potenciales en el paralelismo de datos y tareas
  3.2. Parallel LINQ (PLINQ)
    3.2.1. Introducción a PLINQ
    3.2.2. Introducción a la velocidad en PLINQ
    3.2.3. Conservar el orden en PLINQ
    3.2.4. Opciones de combinación en PLINQ
    3.2.5. Posibles problemas con PLINQ
    3.2.6. Cómo: Crear y ejecutar una consulta PLINQ simple
    3.2.7. Cómo: Controlar la ordenación en una consulta PLINQ
    3.2.8. Cómo: Combinar consultas LINQ paralelas y secuenciales
    3.2.9. Cómo: Controlar excepciones en una consulta PLINQ
    3.2.10. Cómo: Cancelar una consulta PLINQ
    3.2.11. Cómo: Escribir una función de agregado personalizada de PLINQ
    3.2.12. Cómo: Especificar el modo de ejecución en PLINQ
    3.2.13. Cómo: Especificar opciones de combinación en PLINQ
    3.2.14. Cómo: Recorrer en iteración directorios con PLINQ
    3.2.15. Cómo: Medir el rendimiento de consultas PLINQ
    3.2.16. Ejemplo de datos de PLINQ
  3.3. Estructuras de datos para la programación paralela
  3.4. Herramientas de diagnóstico paralelo
  3.5. Particionadores personalizados para PLINQ y TPL
    3.5.1. Cómo: Implementar las particiones dinámicas
    3.5.2. Cómo: Implementar un particionador con un número estático de particiones
  3.6. Generadores de tareas
  3.7. Programadores de tareas
    3.7.1. Cómo: Crear un programador de tareas que limita el grado de simultaneidad
    3.7.2. Cómo: Programar trabajo en el subproceso de la interfaz de usuario
  3.8. Expresiones lambda en PLINQ y TPL

Descarga

jueves, 6 de octubre de 2016

El Libro del Día: Effective C# (2nd Edition)

El Libro del Día: 2016-10-06

Titulo: Effective C# (2nd Edition)
Autor: Bill Wagner
Editorial: Addison-Wesley
Nro Paginas: 343

Capítulos:
Chapter 1 C# Language Idioms
- Item 1: Use Properties Instead of Accessible Data Members
- Item 2: Prefer readonly to const
- Item 3: Prefer the is or as Operators to Casts
- Item 4: Use Conditional Attributes Instead of #if
- Item 5: Always Provide ToString()
- Item 6: Understand the Relationships Among the Many Different Concepts of Equality
- Item 7: Understand the Pitfalls of GetHashCode()
- Item 8: Prefer Query Syntax to Loops
- Item 9: Avoid Conversion Operators in Your APIs
- Item 10: Use Optional Parameters to Minimize Method Overloads
- Item 11: Understand the Attraction of Small Functions
Chapter 2 .NET Resource Management
- Item 12: Prefer Member Initializers to Assignment Statements
- Item 13: Use Proper Initialization for Static Class Members
- Item 14: Minimize Duplicate Initialization Logic
- Item 15: Utilize using and try/finally for Resource Cleanup
- Item 16: Avoid Creating Unnecessary Objects
- Item 17: Implement the Standard Dispose Pattern
- Item 18: Distinguish Between Value Types and Reference Types
- Item 19: Ensure That 0 Is a Valid State for Value Types
- Item 20: Prefer Immutable Atomic Value Types
Chapter 3 Expressing Designs in C#
- Item 21: Limit Visibility of Your Types
- Item 22: Prefer Defining and Implementing Interfaces to Inheritance
- Item 23: Understand How Interface Methods Differ from Virtual Methods
- Item 24: Express Callbacks with Delegates
- Item 25: Implement the Event Pattern for Notifications
- Item 26: Avoid Returning References to Internal Class Objects
- Item 27: Prefer Making Your Types Serializable
- Item 28: Create Large-Grain Internet Service APIs
- Item 29: Support Generic Covariance and Contravariance
Chapter 4 Working with the Framework
- Item 30: Prefer Overrides to Event Handlers
- Item 31: Implement Ordering Relations with IComparable<T> and IComparer<T>
- Item 32: Avoid ICloneable
- Item 33: Use the new Modifier Only to React to Base Class Updates
- Item 34: Avoid Overloading Methods Defined in Base Classes
- Item 35: Learn How PLINQ Implements Parallel Algorithms
- Item 36: Understand How to Use PLINQ for I/O Bound Operations
- Item 37: Construct Parallel Algorithms with Exceptions in Mind
Chapter 5 Dynamic Programming in C#
- Item 38: Understand the Pros and Cons of Dynamic
- Item 39: Use Dynamic to Leverage the Runtime Type of Generic Type Parameters
- Item 40: Use Dynamic for Parameters That Receive Anonymous Types
- Item 41: Use DynamicObject or IDynamicMetaObjectProvider for Data Driven Dynamic Types
- Item 42: Understand How to Make Use of the Expression API
- Item 43: Use Expressions to Transform Late Binding into Early Binding
- Item 44: Minimize Dynamic Objects in Public APIs
Chapter 6 Miscellaneous
- Item 45: Minimize Boxing and Unboxing
- Item 46: Create Complete Application-Specific Exception Classes
- Item 47: Prefer the Strong Exception Guarantee
- Item 48: Prefer Safe Code
- Item 49: Prefer CLS-Compliant Assemblies
- Item 50: Prefer Smaller, Cohesive Assemblies

Descarga:
Effective_C#_2nd_Edition

miércoles, 25 de febrero de 2015

El Libro del Día: C# Multithreaded and Parallel Programming

El Libro del Día: 2015-02-25

Titulo: C# Multithreaded and Parallel Programming
Autor: Rodney Ringler
Editorial: Packt
Nro Paginas: 345

Capítulos:
Chapter 1: Understanding Multiprocessing and Multiple Cores
Chapter 2: Looking at Multithreaded Classes - BackgroundWorker
Chapter 3: Thread Class – Heavyweight Concurrency in C#
Chapter 4: Advanced Thread Processing
Chapter 5: Lightweight Concurrency - Task Parallel Library (TPL)
Chapter 6: Task-based Parallelism
Chapter 7: Data Parallelism
Chapter 8: Debugging Multithreaded Applications with Visual Studio
Chapter 9: Pipeline and Producer-consumer Design Patterns
Chapter 10: Parallel LINQ - PLINQ
Chapter 11: The Asynchronous Programming Model

Descarga:
C#_Multithreaded_and_Parallel_Programming