Uso de delegado con métodos estáticos y métodos de instancia en C#.

Conjunto.cs

// ===++===
//
//    OrtizOL
//
// ===--===
/*============================================================
//
// Clase: Conjunto.cs
//
// Propósito: Uso de delegados en C#.
//
============================================================*/

using System;
using System.Collections;
using System.Windows.Forms;
using System.IO;

namespace Articulos.Cap03
{
    ///<summary>
    /// Clase que represente un conjunto de elementos enteros.
    ///</summary>
    internal class Conjunto
    {
        // Arreglo con elementos de datos.
        private Object[] elementos;
        
        ///<summary>
        /// Crea un instancia de `Conjunto` con 
        /// una cantidad de elementos.
        ///</summary>
        ///<param value="cantidadElementos">Cantidad de elementos de 
        /// a cargar en el arreglo.</param>
        public Conjunto(Int32 cantidadElementos)
        {
            elementos = new Object[cantidadElementos];
            
            for(Int32 i = 0; i < cantidadElementos; ++i)
            {
                elementos[i] = i;
            }
        }
        
        // Delegado con firma para presentación de contenido 
        // de un arreglo de elementos.
        public delegate void Presentador(Object valor, Int32 item, Int32 numeroElementos);
        
        ///<summary>
        /// Se encarga de procesar los elementos de 
        /// datos según el delegado `Presentador`.
        ///<summary>
        ///<param value="presentador">Delegado para presentación de contenido.</param>
        public void ProcesarElementos(Presentador presentador)
        {
            for(Int32 elemento = 0; elemento < elementos.Length; ++elemento)
            {
                if (presentador != null)
                {
                    presentador(elementos[elemento], elemento + 1, elementos.Length);
                }
            }
        }
    }
    
    // Clase de pruebas
    internal class Aplicacion
    {
        // Punto de entrada a la aplicación:
        public static void Main()
        {
            LlamadasEstaticas();
            LlamadasInstancias();
            
            Console.WriteLine();
        }
        
        // Demostración de delegados con métodos 
        // estáticos:
        public static void LlamadasEstaticas()
        {
            // Crea una instancia de `Conjunto` con 
            // cinco (5) elementos de datos:
            Conjunto elementosConjunto = new Conjunto(5);
            
            // Primera prueba de delegado con una referencia null:
            elementosConjunto.ProcesarElementos(null);
            Console.WriteLine();
            
            // Segunda prueba con un delegado en donde se 
            // delega la presentación por la salida estándar:
            elementosConjunto.ProcesarElementos(new Conjunto.Presentador(Aplicacion.PresentacionConsola));
            Console.WriteLine();
            
            // Tercera con un delegado en donde se 
            // delega la presentación con controles visuales:
            elementosConjunto.ProcesarElementos(new Conjunto.Presentador(Aplicacion.PresentacionMessageBox));
            Console.WriteLine();
            
            // Cuarta prueba en donde se 'encadena' un 
            // conjunto de modos (multicast) de presentación al 
            // delegado:
            Conjunto.Presentador retro = null;
            
            retro += PresentacionConsola;
            retro += PresentacionMessageBox;
            
            elementosConjunto.ProcesarElementos(retro);
        }
        
        // Presentación a través de la salida estándar (pantalla):
        public static void PresentacionConsola(Object valor, Int32 elemento, Int32 numeroElementos)
        {
            Console.WriteLine("Procesando elemento {0}/{1}: {2}", elemento, numeroElementos, valor);
        }
        
        // Presentación a través de un control visual:
        public static void PresentacionMessageBox(Object valor, Int32 elemento, Int32 numeroElementos)
        {
            MessageBox.Show(String.Format("Procesando elemento {0}/{1}: {2}", elemento, numeroElementos, valor));
        }
        
        // Demostración de delegados con con métodos de instancia:
        public static void LlamadasInstancias()
        {
            Aplicacion app = new Aplicacion();
            
            Conjunto c = new Conjunto(5);
            
            // Delegado con método de instancia:
            Conjunto.Presentador delegadoRetroalimentacion = app.PresentacionArchivo;
            
            c.ProcesarElementos(delegadoRetroalimentacion);
        }
        
        // Presentación a través de un flujo de caractres:
        public void PresentacionArchivo(Object valor, Int32 elemento, Int32 numeroElementos)
        {
            StreamWriter sw = new StreamWriter("Salida.txt", true);
            
            sw.WriteLine("Procesando elemento {0}/{1}: {2}", elemento, numeroElementos, valor);
            sw.Close();
        }
    }
}