Comando y cadena de responsabilidad - Gonzalez Valenzuela Exxon | C# Online Compiler

Comando y cadena de responsabilidad - Gonzalez Valenzuela Exxon by Gonzalez Valenzuela Exxon Alejandro

// CADENA DE RESPONSABILIDAD

// Gonzalez Valenzuela Exxon Alejandro -- 20210573

/*
Se define una interfaz ICommand que declara métodos Execute y Undo. 
Las clases concretas BrightnessCommand, ContrastCommand, SepiaFilterCommand y BlurFilterCommand implementan esta interfaz y encapsulan las operaciones de edición de imagen como objetos de comando.
La clase CommandManager actúa como el invocador y almacena una lista de comandos ejecutados, permitiendo deshacer y rehacer operaciones.

La clase ImageReceiver actúa como el receptor de los comandos y es responsable de aplicar los ajustes y filtros a la imagen.
Cada comando concreto aplica su efecto directamente sobre el receptor (ImageReceiver), lo que crea una cadena de responsabilidad en la que cada filtro o ajuste es procesado de manera secuencial.
La aplicación de filtros como el filtro sepia y el filtro de desenfoque es manejada directamente por los comandos, lo que forma una cadena de procesamiento de filtros.
*/

using System;
using System.Collections.Generic;

// Interfaz Comando
public interface ICommand
{
    void Execute(ImageReceiver receiver);
    void Undo(ImageReceiver receiver);
}

// Clases de comandos concretos
public class BrightnessCommand : ICommand
{
    private readonly int _amount;
    private int _previousBrightness;

    public BrightnessCommand(int amount)
    {
        _amount = amount;
    }

    public void Execute(ImageReceiver receiver)
    {
        _previousBrightness = receiver.Brightness;
        receiver.AdjustBrightness(_amount);
    }

    public void Undo(ImageReceiver receiver)
    {
        receiver.SetBrightness(_previousBrightness);
    }
}

public class ContrastCommand : ICommand
{
    private readonly int _amount;
    private int _previousContrast;

    public ContrastCommand(int amount)
    {
        _amount = amount;
    }

    public void Execute(ImageReceiver receiver)
    {
        _previousContrast = receiver.Contrast;
        receiver.AdjustContrast(_amount);
    }

    public void Undo(ImageReceiver receiver)
    {
        receiver.SetContrast(_previousContrast);
    }
}

public class SepiaFilterCommand : ICommand
{
    public void Execute(ImageReceiver receiver)
    {
        receiver.ApplySepiaFilter();
    }

    public void Undo(ImageReceiver receiver)
    {
        receiver.RemoveSepiaFilter();
    }
}

public class BlurFilterCommand : ICommand
{
    public void Execute(ImageReceiver receiver)
    {
        receiver.ApplyBlurFilter();
    }

    public void Undo(ImageReceiver receiver)
    {
        receiver.RemoveBlurFilter();
    }
}

// Clase GestorComandos
public class CommandManager
{
    private readonly Stack<ICommand> _undoStack = new Stack<ICommand>();
    private readonly Stack<ICommand> _redoStack = new Stack<ICommand>();

    public void ExecuteCommand(ICommand command, ImageReceiver receiver)
    {
        command.Execute(receiver);
        _undoStack.Push(command);
        _redoStack.Clear(); // Limpiar el stack de rehacer cuando se ejecuta un nuevo comando
    }

    public void Undo(ImageReceiver receiver)
    {
        if (_undoStack.Count > 0)
        {
            ICommand command = _undoStack.Pop();
            command.Undo(receiver);
            _redoStack.Push(command);
        }
        else
        {
            Console.WriteLine("No hay comandos para deshacer.");
        }
    }

    public void Redo(ImageReceiver receiver)
    {
        if (_redoStack.Count > 0)
        {
            ICommand command = _redoStack.Pop();
            command.Execute(receiver);
            _undoStack.Push(command);
        }
        else
        {
            Console.WriteLine("No hay comandos para rehacer.");
        }
    }
}

// Clase Filtro (Cadena de Responsabilidad)
public class ImageReceiver
{
    public int Brightness { get; private set; }
    public int Contrast { get; private set; }
    public bool SepiaFilterApplied { get; private set; }
    public bool BlurFilterApplied { get; private set; }

    public ImageReceiver(int brightness, int contrast)
    {
        Brightness = brightness;
        Contrast = contrast;
    }

    public void AdjustBrightness(int amount)
    {
        Brightness += amount;
        Console.WriteLine($"Brillo ajustado a: {Brightness}");
    }

    public void SetBrightness(int brightness)
    {
        Brightness = brightness;
        Console.WriteLine($"Brillo restablecido a: {Brightness}");
    }

    public void AdjustContrast(int amount)
    {
        Contrast += amount;
        Console.WriteLine($"Contraste ajustado a: {Contrast}");
    }

    public void SetContrast(int contrast)
    {
        Contrast = contrast;
        Console.WriteLine($"Contraste restablecido a: {Contrast}");
    }

    public void ApplySepiaFilter()
    {
        SepiaFilterApplied = true;
        Console.WriteLine("Filtro sepia aplicado.");
    }

    public void RemoveSepiaFilter()
    {
        SepiaFilterApplied = false;
        Console.WriteLine("Filtro sepia retirado.");
    }

    public void ApplyBlurFilter()
    {
        BlurFilterApplied = true;
        Console.WriteLine("Filtro de desenfoque aplicado.");
    }

    public void RemoveBlurFilter()
    {
        BlurFilterApplied = false;
        Console.WriteLine("Filtro de desenfoque retirado.");
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Inicializar objetos
        ImageReceiver image = new ImageReceiver(100, 100);
        CommandManager commandManager = new CommandManager();

        // Interfaz de usuario
        while (true)
        {
            Console.WriteLine("Seleccione una opción:");
            Console.WriteLine("1. Ajustar brillo");
            Console.WriteLine("2. Ajustar contraste");
            Console.WriteLine("3. Aplicar filtro sepia");
            Console.WriteLine("4. Aplicar filtro de desenfoque");
            Console.WriteLine("5. Deshacer");
            Console.WriteLine("6. Rehacer");
            Console.WriteLine("7. Salir");

            string input = Console.ReadLine();
            switch (input)
            {
                case "1":
                    Console.WriteLine("Introduzca el valor de ajuste de brillo:");
                    if (int.TryParse(Console.ReadLine(), out int brightnessAmount))
                    {
                        commandManager.ExecuteCommand(new BrightnessCommand(brightnessAmount), image);
                    }
                    break;
                case "2":
                    Console.WriteLine("Introduzca el valor de ajuste de contraste:");
                    if (int.TryParse(Console.ReadLine(), out int contrastAmount))
                    {
                        commandManager.ExecuteCommand(new ContrastCommand(contrastAmount), image);
                    }
                    break;
                case "3":
                    commandManager.ExecuteCommand(new SepiaFilterCommand(), image);
                    break;
                case "4":
                    commandManager.ExecuteCommand(new BlurFilterCommand(), image);
                    break;
                case "5":
                    commandManager.Undo(image);
                    break;
                case "6":
                    commandManager.Redo(image);
                    break;
                case "7":
                    Console.WriteLine("Saliendo del programa...");
                    return;
                default:
                    Console.WriteLine("Opción no válida.");
                    break;
            }
        }
    }
}

​x
 
// CADENA DE RESPONSABILIDAD
​
// Gonzalez Valenzuela Exxon Alejandro -- 20210573
​
/*
Se define una interfaz ICommand que declara métodos Execute y Undo. 
Las clases concretas BrightnessCommand, ContrastCommand, SepiaFilterCommand y BlurFilterCommand implementan esta interfaz y encapsulan las operaciones de edición de imagen como objetos de comando.
La clase CommandManager actúa como el invocador y almacena una lista de comandos ejecutados, permitiendo deshacer y rehacer operaciones.
​
La clase ImageReceiver actúa como el receptor de los comandos y es responsable de aplicar los ajustes y filtros a la imagen.
Cada comando concreto aplica su efecto directamente sobre el receptor (ImageReceiver), lo que crea una cadena de responsabilidad en la que cada filtro o ajuste es procesado de manera secuencial.
La aplicación de filtros como el filtro sepia y el filtro de desenfoque es manejada directamente por los comandos, lo que forma una cadena de procesamiento de filtros.
*/
​
using System;
using System.Collections.Generic;
​
// Interfaz Comando
public interface ICommand
{
    void Execute(ImageReceiver receiver);
    void Undo(ImageReceiver receiver);
}
​
// Clases de comandos concretos
public class BrightnessCommand : ICommand
{
    private readonly int _amount;
    private int _previousBrightness;
​
    public BrightnessCommand(int amount)
    {
        _amount = amount;
    }
​
    public void Execute(ImageReceiver receiver)
    {
        _previousBrightness = receiver.Brightness;
        receiver.AdjustBrightness(_amount);
    }
​
    public void Undo(ImageReceiver receiver)
    {
        receiver.SetBrightness(_previousBrightness);
    }
}
​
public class ContrastCommand : ICommand
{
    private readonly int _amount;
    private int _previousContrast;
​
    public ContrastCommand(int amount)
    {
        _amount = amount;
    }
​
    public void Execute(ImageReceiver receiver)
    {
        _previousContrast = receiver.Contrast;
        receiver.AdjustContrast(_amount);
    }
​
    public void Undo(ImageReceiver receiver)
    {
        receiver.SetContrast(_previousContrast);
    }
}
​
public class SepiaFilterCommand : ICommand
{
    public void Execute(ImageReceiver receiver)
    {
        receiver.ApplySepiaFilter();
    }
​
    public void Undo(ImageReceiver receiver)
    {
        receiver.RemoveSepiaFilter();
    }
}
​
public class BlurFilterCommand : ICommand
{
    public void Execute(ImageReceiver receiver)
    {
        receiver.ApplyBlurFilter();
    }
​
    public void Undo(ImageReceiver receiver)
    {
        receiver.RemoveBlurFilter();
    }
}
​
// Clase GestorComandos
public class CommandManager
{
    private readonly Stack<ICommand> _undoStack = new Stack<ICommand>();
    private readonly Stack<ICommand> _redoStack = new Stack<ICommand>();
​
    public void ExecuteCommand(ICommand command, ImageReceiver receiver)
    {
        command.Execute(receiver);
        _undoStack.Push(command);
        _redoStack.Clear(); // Limpiar el stack de rehacer cuando se ejecuta un nuevo comando
    }
​
    public void Undo(ImageReceiver receiver)
    {
        if (_undoStack.Count > 0)
        {
            ICommand command = _undoStack.Pop();
            command.Undo(receiver);
            _redoStack.Push(command);
        }
        else
        {
            Console.WriteLine("No hay comandos para deshacer.");
        }
    }
​
    public void Redo(ImageReceiver receiver)
    {
        if (_redoStack.Count > 0)
        {
            ICommand command = _redoStack.Pop();
            command.Execute(receiver);
            _undoStack.Push(command);
        }
        else
        {
            Console.WriteLine("No hay comandos para rehacer.");
        }
    }
}
​
// Clase Filtro (Cadena de Responsabilidad)
public class ImageReceiver
{
    public int Brightness { get; private set; }
    public int Contrast { get; private set; }
    public bool SepiaFilterApplied { get; private set; }
    public bool BlurFilterApplied { get; private set; }
​
    public ImageReceiver(int brightness, int contrast)
    {
        Brightness = brightness;
        Contrast = contrast;
    }
​
    public void AdjustBrightness(int amount)
    {
        Brightness += amount;
        Console.WriteLine($"Brillo ajustado a: {Brightness}");
    }
​
    public void SetBrightness(int brightness)
    {
        Brightness = brightness;
        Console.WriteLine($"Brillo restablecido a: {Brightness}");
    }
​
    public void AdjustContrast(int amount)
    {
        Contrast += amount;
        Console.WriteLine($"Contraste ajustado a: {Contrast}");
    }
​
    public void SetContrast(int contrast)
    {
        Contrast = contrast;
        Console.WriteLine($"Contraste restablecido a: {Contrast}");
    }
​
    public void ApplySepiaFilter()
    {
        SepiaFilterApplied = true;
        Console.WriteLine("Filtro sepia aplicado.");
    }
​
    public void RemoveSepiaFilter()
    {
        SepiaFilterApplied = false;
        Console.WriteLine("Filtro sepia retirado.");
    }
​
    public void ApplyBlurFilter()
    {
        BlurFilterApplied = true;
        Console.WriteLine("Filtro de desenfoque aplicado.");
    }
​
    public void RemoveBlurFilter()
    {
        BlurFilterApplied = false;
        Console.WriteLine("Filtro de desenfoque retirado.");
    }
}
​
class Program
{
    static void Main(string[] args)
    {
        // Inicializar objetos
        ImageReceiver image = new ImageReceiver(100, 100);
        CommandManager commandManager = new CommandManager();
​
        // Interfaz de usuario
        while (true)
        {
            Console.WriteLine("Seleccione una opción:");
            Console.WriteLine("1. Ajustar brillo");
            Console.WriteLine("2. Ajustar contraste");
            Console.WriteLine("3. Aplicar filtro sepia");
            Console.WriteLine("4. Aplicar filtro de desenfoque");
            Console.WriteLine("5. Deshacer");
            Console.WriteLine("6. Rehacer");
            Console.WriteLine("7. Salir");
​
            string input = Console.ReadLine();
            switch (input)
            {
                case "1":
                    Console.WriteLine("Introduzca el valor de ajuste de brillo:");
                    if (int.TryParse(Console.ReadLine(), out int brightnessAmount))
                    {
                        commandManager.ExecuteCommand(new BrightnessCommand(brightnessAmount), image);
                    }
                    break;
                case "2":
                    Console.WriteLine("Introduzca el valor de ajuste de contraste:");
                    if (int.TryParse(Console.ReadLine(), out int contrastAmount))
                    {
                        commandManager.ExecuteCommand(new ContrastCommand(contrastAmount), image);
                    }
                    break;
                case "3":
                    commandManager.ExecuteCommand(new SepiaFilterCommand(), image);
                    break;
                case "4":
                    commandManager.ExecuteCommand(new BlurFilterCommand(), image);
                    break;
                case "5":
                    commandManager.Undo(image);
                    break;
                case "6":
                    commandManager.Redo(image);
                    break;
                case "7":
                    Console.WriteLine("Saliendo del programa...");
                    return;
                default:
                    Console.WriteLine("Opción no válida.");
                    break;
            }
        }
    }
}
​
​

Poodle is a medium dog.
Bear is not a dog at all.
Yorkie is a small dog.
German Shepard is a large dog.

Last Run:	7:46:49 am
Compile:	0.007s
Execute:	0.05s
Memory:	2.85Mb
CPU:	0.057s

View IL Code