Come implementare un provider

Il modello di progettazione osservatore richiede una divisione tra un provider, che monitora i dati e invia notifiche e uno o più osservatori, che ricevono notifiche (callback) dal provider. Questo articolo illustra come creare un provider. Per informazioni sulla creazione di un osservatore, vedere Come implementare un osservatore.

Definire il tipo di dati

Definire i dati inviati dal provider agli osservatori. Anche se il provider e i dati inviati agli osservatori possono essere un singolo tipo, un tipo diverso rappresenta in genere ognuno di essi. Ad esempio, in un'applicazione di monitoraggio della temperatura, la Temperature struttura definisce i dati monitorati dalla TemperatureMonitor classe (definita nella sezione successiva) e da cui gli osservatori sottoscrivono.

namespace TemperatureSample;

public readonly record struct Temperature(decimal Degrees, DateTime Date);

Namespace Global.TemperatureSample

    Public Structure Temperature
        Public ReadOnly Property Degrees As Decimal
        Public ReadOnly Property [Date] As Date

        Public Sub New(degrees As Decimal, [date] As Date)
            Me.Degrees = degrees
            Me.Date = [date]
        End Sub
    End Structure

End Namespace

Crea un provider

Il provider di dati è un tipo che implementa l'interfaccia System.IObservable<T> . L'argomento di tipo generico specificato del provider è il tipo che invia agli osservatori.

Definire la classe del provider. Nell'esempio seguente viene definita una TemperatureMonitor classe , che è un'implementazione costruita System.IObservable<T> con un argomento di tipo generico di Temperature.

namespace TemperatureSample;

public sealed class TemperatureMonitor : IObservable<Temperature>
{

Imports System.Threading
Imports System.Threading.Tasks

Namespace Global.TemperatureSample

    Public NotInheritable Class TemperatureMonitor
        Implements IObservable(Of Temperature)

Aggiungere un campo per archiviare i riferimenti degli osservatori.

Il provider deve tenere traccia di ogni osservatore registrato in modo che possa inviare notifiche in un secondo momento. In genere, utilizzare un oggetto raccolta, ad esempio un oggetto generico List<T> . L'esempio seguente definisce un oggetto privato List<T>, istanziato nel costruttore della classe TemperatureMonitor.

namespace TemperatureSample;

public sealed class TemperatureMonitor : IObservable<Temperature>
{
    private readonly List<IObserver<Temperature>> _observers = [];
    private readonly Lock _sync = new();

Imports System.Threading
Imports System.Threading.Tasks

Namespace Global.TemperatureSample

    Public NotInheritable Class TemperatureMonitor
        Implements IObservable(Of Temperature)

        Private ReadOnly _observers As New List(Of IObserver(Of Temperature))()
        Private ReadOnly _sync As New Object()

Definire un'implementazione IDisposable per annullare la sottoscrizione.

Il provider restituisce questa implementazione ai sottoscrittori in modo che possano interrompere la ricezione di notifiche in qualsiasi momento. L'esempio seguente definisce una classe annidata Unsubscriber che riceve un riferimento alla raccolta dei sottoscrittori e al sottoscrittore quando viene istanziata. La Unsubscriber classe consente al sottoscrittore di chiamare l'implementazione dell'oggetto IDisposable.Dispose per rimuoverla dall'insieme sottoscrittori.

private sealed class Unsubscriber(
    List<IObserver<Temperature>> observers,
    IObserver<Temperature> observer,
    Lock sync) : IDisposable
{
    public void Dispose()
    {
        lock (sync)
        {
            observers.Remove(observer);
        }
    }
}

Private NotInheritable Class Unsubscriber
    Implements IDisposable

    Private ReadOnly _observers As List(Of IObserver(Of Temperature))
    Private ReadOnly _observer As IObserver(Of Temperature)
    Private ReadOnly _sync As Object

    Public Sub New(observers As List(Of IObserver(Of Temperature)),
                   observer As IObserver(Of Temperature),
                   sync As Object)
        _observers = observers
        _observer = observer
        _sync = sync
    End Sub

    Public Sub Dispose() Implements IDisposable.Dispose
        SyncLock _sync
            _observers.Remove(_observer)
        End SyncLock
    End Sub
End Class

Implementa il metodo IObservable<T>.Subscribe.

Il metodo riceve un riferimento all'interfaccia System.IObserver<T> . Memorizza il riferimento nella raccolta di osservatori della fase precedente, quindi restituisci l'implementazione per annullare la sottoscrizione IDisposable. Nell'esempio seguente viene illustrata l'implementazione Subscribe nella TemperatureMonitor classe .

public IDisposable Subscribe(IObserver<Temperature> observer)
{
    ArgumentNullException.ThrowIfNull(observer);

    lock (_sync)
    {
        if (!_observers.Contains(observer))
            _observers.Add(observer);
    }

    return new Unsubscriber(_observers, observer, _sync);
}

Public Function Subscribe(observer As IObserver(Of Temperature)) As IDisposable _
    Implements IObservable(Of Temperature).Subscribe

    ArgumentNullException.ThrowIfNull(observer)

    SyncLock _sync
        If Not _observers.Contains(observer) Then
            _observers.Add(observer)
        End If
    End SyncLock

    Return New Unsubscriber(_observers, observer, _sync)
End Function

Implementa la logica di notifica chiamando i metodi IObserver<T>.OnNext, IObserver<T>.OnError e IObserver<T>.OnCompleted degli osservatori.

In alcuni casi, un provider potrebbe non chiamare OnError quando si verifica un errore. Il metodo seguente GetTemperature simula un monitoraggio che legge i dati relativi alla temperatura ogni cinque secondi e notifica agli osservatori se la temperatura è cambiata di almeno 1 grado rispetto alla lettura precedente. Se il dispositivo non segnala una temperatura (ovvero se il relativo valore è null), il provider notifica agli osservatori che la trasmissione è completa chiamando il metodo OnCompleted di ogni osservatore e svuota la raccolta List<T>. In questo esempio, il provider non chiama mai OnError.

public async Task GetTemperatureAsync(CancellationToken cancellationToken = default)
{
    // Sample data that mimics a temperature device. A null value signals the end of transmission.
    decimal?[] temps =
    [
        14.6m, 14.65m, 14.7m, 14.9m, 14.9m, 15.2m,
        15.25m, 15.2m, 15.4m, 15.45m, null
    ];

    decimal? previous = null;

    foreach (decimal? temp in temps)
    {
        await Task.Delay(TimeSpan.FromSeconds(2.5), cancellationToken);

        if (temp is decimal value)
        {
            // Notify only after at least a 0.1° change.
            if (previous is null || Math.Abs(value - previous.Value) >= 0.1m)
            {
                NotifyAll(new Temperature(value, DateTime.Now));
                previous = value;
            }
        }
        else
        {
            CompleteAll();
            break;
        }
    }
}

private void NotifyAll(Temperature data)
{
    IObserver<Temperature>[] snapshot;
    lock (_sync)
    {
        snapshot = [.. _observers];
    }

    foreach (IObserver<Temperature> observer in snapshot)
        observer.OnNext(data);
}

private void CompleteAll()
{
    IObserver<Temperature>[] snapshot;
    lock (_sync)
    {
        snapshot = [.. _observers];
        _observers.Clear();
    }

    foreach (IObserver<Temperature> observer in snapshot)
        observer.OnCompleted();
}

Public Async Function GetTemperatureAsync(Optional cancellationToken As CancellationToken = Nothing) As Task
    ' Sample data that mimics a temperature device. A Nothing value signals the end of transmission.
    Dim temps As Decimal?() = {
        14.6D, 14.65D, 14.7D, 14.9D, 14.9D, 15.2D,
        15.25D, 15.2D, 15.4D, 15.45D, Nothing
    }

    Dim previous As Decimal? = Nothing

    For Each temp As Decimal? In temps
        Await Task.Delay(TimeSpan.FromSeconds(2.5), cancellationToken)

        If temp.HasValue Then
            ' Notify only after at least a 0.1° change.
            If Not previous.HasValue OrElse Math.Abs(temp.Value - previous.Value) >= 0.1D Then
                NotifyAll(New Temperature(temp.Value, Date.Now))
                previous = temp
            End If
        Else
            CompleteAll()
            Exit For
        End If
    Next
End Function

Private Sub NotifyAll(data As Temperature)
    Dim snapshot As IObserver(Of Temperature)()
    SyncLock _sync
        snapshot = _observers.ToArray()
    End SyncLock

    For Each observer In snapshot
        observer.OnNext(data)
    Next
End Sub

Private Sub CompleteAll()
    Dim snapshot As IObserver(Of Temperature)()
    SyncLock _sync
        snapshot = _observers.ToArray()
        _observers.Clear()
    End SyncLock

    For Each observer In snapshot
        observer.OnCompleted()
    Next
End Sub

Esempio

L'esempio seguente contiene il codice sorgente completo per un'implementazione IObservable<T> per un'applicazione di monitoraggio della temperatura. Include la Temperature struttura, ovvero i dati inviati dal provider agli osservatori e la TemperatureMonitor classe , che è l'implementazione IObservable<T> .

namespace TemperatureSample;

public sealed class TemperatureMonitor : IObservable<Temperature>
{
    private readonly List<IObserver<Temperature>> _observers = [];
    private readonly Lock _sync = new();

    private sealed class Unsubscriber(
        List<IObserver<Temperature>> observers,
        IObserver<Temperature> observer,
        Lock sync) : IDisposable
    {
        public void Dispose()
        {
            lock (sync)
            {
                observers.Remove(observer);
            }
        }
    }

    public IDisposable Subscribe(IObserver<Temperature> observer)
    {
        ArgumentNullException.ThrowIfNull(observer);

        lock (_sync)
        {
            if (!_observers.Contains(observer))
                _observers.Add(observer);
        }

        return new Unsubscriber(_observers, observer, _sync);
    }

    public async Task GetTemperatureAsync(CancellationToken cancellationToken = default)
    {
        // Sample data that mimics a temperature device. A null value signals the end of transmission.
        decimal?[] temps =
        [
            14.6m, 14.65m, 14.7m, 14.9m, 14.9m, 15.2m,
            15.25m, 15.2m, 15.4m, 15.45m, null
        ];

        decimal? previous = null;

        foreach (decimal? temp in temps)
        {
            await Task.Delay(TimeSpan.FromSeconds(2.5), cancellationToken);

            if (temp is decimal value)
            {
                // Notify only after at least a 0.1° change.
                if (previous is null || Math.Abs(value - previous.Value) >= 0.1m)
                {
                    NotifyAll(new Temperature(value, DateTime.Now));
                    previous = value;
                }
            }
            else
            {
                CompleteAll();
                break;
            }
        }
    }

    private void NotifyAll(Temperature data)
    {
        IObserver<Temperature>[] snapshot;
        lock (_sync)
        {
            snapshot = [.. _observers];
        }

        foreach (IObserver<Temperature> observer in snapshot)
            observer.OnNext(data);
    }

    private void CompleteAll()
    {
        IObserver<Temperature>[] snapshot;
        lock (_sync)
        {
            snapshot = [.. _observers];
            _observers.Clear();
        }

        foreach (IObserver<Temperature> observer in snapshot)
            observer.OnCompleted();
    }
}

Imports System.Threading
Imports System.Threading.Tasks

Namespace Global.TemperatureSample

    Public NotInheritable Class TemperatureMonitor
        Implements IObservable(Of Temperature)

        Private ReadOnly _observers As New List(Of IObserver(Of Temperature))()
        Private ReadOnly _sync As New Object()

        Private NotInheritable Class Unsubscriber
            Implements IDisposable

            Private ReadOnly _observers As List(Of IObserver(Of Temperature))
            Private ReadOnly _observer As IObserver(Of Temperature)
            Private ReadOnly _sync As Object

            Public Sub New(observers As List(Of IObserver(Of Temperature)),
                           observer As IObserver(Of Temperature),
                           sync As Object)
                _observers = observers
                _observer = observer
                _sync = sync
            End Sub

            Public Sub Dispose() Implements IDisposable.Dispose
                SyncLock _sync
                    _observers.Remove(_observer)
                End SyncLock
            End Sub
        End Class

        Public Function Subscribe(observer As IObserver(Of Temperature)) As IDisposable _
            Implements IObservable(Of Temperature).Subscribe

            ArgumentNullException.ThrowIfNull(observer)

            SyncLock _sync
                If Not _observers.Contains(observer) Then
                    _observers.Add(observer)
                End If
            End SyncLock

            Return New Unsubscriber(_observers, observer, _sync)
        End Function

        Public Async Function GetTemperatureAsync(Optional cancellationToken As CancellationToken = Nothing) As Task
            ' Sample data that mimics a temperature device. A Nothing value signals the end of transmission.
            Dim temps As Decimal?() = {
                14.6D, 14.65D, 14.7D, 14.9D, 14.9D, 15.2D,
                15.25D, 15.2D, 15.4D, 15.45D, Nothing
            }

            Dim previous As Decimal? = Nothing

            For Each temp As Decimal? In temps
                Await Task.Delay(TimeSpan.FromSeconds(2.5), cancellationToken)

                If temp.HasValue Then
                    ' Notify only after at least a 0.1° change.
                    If Not previous.HasValue OrElse Math.Abs(temp.Value - previous.Value) >= 0.1D Then
                        NotifyAll(New Temperature(temp.Value, Date.Now))
                        previous = temp
                    End If
                Else
                    CompleteAll()
                    Exit For
                End If
            Next
        End Function

        Private Sub NotifyAll(data As Temperature)
            Dim snapshot As IObserver(Of Temperature)()
            SyncLock _sync
                snapshot = _observers.ToArray()
            End SyncLock

            For Each observer In snapshot
                observer.OnNext(data)
            Next
        End Sub

        Private Sub CompleteAll()
            Dim snapshot As IObserver(Of Temperature)()
            SyncLock _sync
                snapshot = _observers.ToArray()
                _observers.Clear()
            End SyncLock

            For Each observer In snapshot
                observer.OnCompleted()
            Next
        End Sub
    End Class

End Namespace

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2026-06-03