Modello di bandiera auto-modificante e implementazione standard

Question

Modello di bandiera auto-modificante e implementazione standard

#1 da (3 voti)

3

Sto lavorando su un pezzo di codice che elabora un sacco di messaggi e li passa a un altro servizio. Questo processo potrebbe non riuscire, causando un riferimento errato al servizio. Ogni volta che si verifica un errore, il messaggio che accetta il codice dovrebbe continuare ad accettare messaggi, ma semplicemente scartarli per un periodo di tempo predefinito dopo il quale viene creato un nuovo riferimento di servizio. Ho implementato il seguente costrutto;

class MessageProcesser
{
    private CircuitBreak _circuitBreak = new CircuitBreak();

    public async Task ProcessMessageAsync(string message)
    {
        if (_circuitBreak.IsOpen)
        {
            try
            {
                await DoSomethingAsync(message);
            }
            catch (Exception)
            {
                _circuitBreak = new CircuitBreak(5000);
            }
        }
    }
}

Con un "blocco" auto-aperto come;

class CircuitBreak
{
    private readonly DateTimeOffset _willOpenAfter;

    public bool IsOpen { get { return DateTimeOffset.UtcNow > _willOpenAfter; } }

    public CircuitBreak(double milliSeconds = 0.0d)
    {
        _willOpenAfter = DateTimeOffset.UtcNow.AddMilliseconds(milliSeconds);
    }
}

Quando guardo tutte le classi di sincronizzazione nel framework .NET (Semaphore, Barrier, ecc.) mi aspetto che alcune classi che si adattino alle mie esigenze dovrebbero anche essere da qualche parte nel framework. Esiste un nome per un pattern come il mio ed esiste già un'implementazione di un flag che si modifica automaticamente nel framework .NET?

c# design-patterns .net

posta Michiel T 16.03.2017 - 19:11

fonte

1 risposta

Leggi altre domande sui tag c# design-patterns .net

Progettazione API REST: come suddividere l'oggetto API per rendere l'API più scalabile e robusta Progettare un'implementazione efficiente di una coda di accesso casuale basata su una lista collegata

score 3 · Accepted Answer

Che ne dici di qualcosa del genere? Utilizzare un timer per impostare un evento, incapsulare in un generico.

class TemporaryValue<T>
{
    volatile private T _value;

    public TemporaryValue(T initialValue, int millisecondWait, T nextValue)
    {
        _value = initialValue;
        var timer = new System.Timers.Timer
        {
            Interval = milliseconds,
            AutoReset = false,
            Elapsed += () => { _value = nextValue; timer.Dispose(); }
        }.Start();
    }

    public Value
    {
        get { return _value; }
    }

    public static implicit operator T(TemporaryValue<T> tv)
    {
        return tv.Value;
    }
}

A causa dell'operatore implicito, puoi assegnare a bool .

bool flag = new TemporaryValue<bool>(true, 10000, false);