es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

Patrón de diseño para implementar el enfoque de polling en c#

27 Jul, 2023 Programación

Quiero implementar el enfoque de encuesta en c# utilizando patrones de diseño con algún código genérico con el siguiente escenario.

Tengo 3 aplicaciones de consola llamadas Employee, Orders, Salary y desde la aplicación Employee estoy iniciando las aplicaciones de consola Orders y Salary. Una vez que inicio las aplicaciones, Orders y Salary son aplicaciones de larga duración que continuarán en ejecución y estamos actualizando un archivo de texto local con el estado de finalización para cada una de las aplicaciones.

Desde la aplicación Employee, he creado un objeto Timers y estoy utilizando el evento Elapsed durante 2 segundos para verificar el texto del archivo y ver si se ha completado el estado de ambos archivos o no.

Entonces quiero hacer la siguiente implementación de una manera más genérica o utilizando otro enfoque/patrones de diseño para poder lograr un concepto similar de encuesta, ya que tengo una situación más compleja donde tengo que usar el mismo código repetitivo cada vez. ¿Algún consejo al respecto?

var poolingTimer = new Timer(2 * 1000);
poolingTimer.AutoReset = false;
poolingTimer.Elapsed += async delegate {
   if (lógica para verificar si el archivo de texto tiene el estado de finalización de la aplicación de consola) {
      poolingTimer.Stop();
   } else {
      poolingTimer.Start();
   }
};
poolingTimer.Start();
Tags:  , , , ,

Answer

  1. Avatar for davy.ai
    davy.ai

    Para implementar un enfoque más genérico utilizando patrones de diseño, podemos utilizar el patrón Observer.

    Aquí está cómo podemos modificar el código para utilizar el patrón Observer:

    1. Definir una interfaz “Subject” para las aplicaciones que necesitan ser monitoreadas. Esta interfaz debería definir métodos para suscribirse y cancelar la suscripción a actualizaciones, así como para notificar a los suscriptores cuando ocurran actualizaciones.

    2. Implementar una clase concreta “Subject” para cada aplicación de consola (es decir, Orders y Salary) que implementa la interfaz Subject. Esta clase debe realizar un seguimiento del estado de finalización de la aplicación y notificar a sus suscriptores cuando cambie el estado.

    3. Implementar una interfaz “Observer” para la aplicación Employee para suscribirse a las aplicaciones Orders y Salary.

    4. Modificar la aplicación Employee para mantener una lista de “Observers” (es decir, las aplicaciones Orders y Salary) y suscribirse a sus actualizaciones.

    5. Implementar la lógica del Temporizador dentro de las clases concretas “Observer”, de modo que verifiquen periódicamente el estado de finalización y notifiquen a sus suscriptores si es necesario.

    Aquí hay un código de ejemplo que ilustra el enfoque:

    // Define la interfaz Subject
public interface IApplicationStatus
{
    void Subscribe(IObserver observer);
    void Unsubscribe(IObserver observer);
    void UpdateStatus(bool isCompleted);
}

// Implementa una clase concreta Subject para cada aplicación
public class OrdersApplication : IApplicationStatus
{
    private readonly List<iobserver> _observers = new List<iobserver>();
    private bool _isCompleted;

    public void Subscribe(IObserver observer)
    {
        _observers.Add(observer);
    }

    public void Unsubscribe(IObserver observer)
    {
        _observers.Remove(observer);
    }

    public void UpdateStatus(bool isCompleted)
    {
        _isCompleted = isCompleted;
        NotifyObservers();
    }

    private void NotifyObservers()
    {
        foreach (var observer in _observers)
        {
            observer.Update(_isCompleted);
        }
    }

    // Implementa aquí la lógica de Temporizador
}

// Implementa una interfaz Observer para la aplicación Employee
public interface IObserver
{
    void Update(bool status);
}

// Modifica la aplicación Employee para suscribirse a las aplicaciones Orders y Salary
public class EmployeeApplication : IObserver
{
    private readonly OrdersApplication _ordersApplication;
    private readonly SalaryApplication _salaryApplication;

    public EmployeeApplication()
    {
        _ordersApplication = new OrdersApplication();
        _salaryApplication = new SalaryApplication();

        _ordersApplication.Subscribe(this);
        _salaryApplication.Subscribe(this);
    }

    // Implementa el método Update para verificar el estado de ambas aplicaciones
}

// Utiliza las clases Observer y Subject
var employeeApplication = new EmployeeApplication();

    Este enfoque te permite añadir fácilmente más aplicaciones para monitorear mediante la implementación de una nueva clase concreta de Subject y suscribiéndola a la aplicación Employee. Además, la lógica del Temporizador se mantiene dentro de las clases concretas de Subject, lo que la hace más modular y reutilizable.

Comments are closed.