Como implementar um provedor

O padrão de design do observador requer uma divisão entre um provedor, que monitora dados e envia notificações e um ou mais observadores, que recebem notificações (retornos de chamada) do provedor. Este artigo mostra como criar um provedor. Para obter informações sobre como criar um observador, consulte Como implementar um observador.

Definir o tipo de dados

Defina os dados que o provedor envia aos observadores. Embora o provedor e os dados enviados aos observadores possam ser um único tipo, um tipo diferente normalmente representa cada um. Por exemplo, em um aplicativo de monitoramento de temperatura, a estrutura Temperature define os dados que a classe TemperatureMonitor (definida na próxima seção) monitora e aos quais os observadores se inscrevem.

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

Criar um provedor

O provedor de dados é um tipo que implementa a System.IObservable<T> interface. O argumento de tipo genérico do provedor é o tipo que ele envia aos observadores.

1. Defina a classe de provedor. O exemplo a seguir define uma TemperatureMonitor classe, que é uma implementação construída System.IObservable<T> com um argumento de tipo genérico de 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)
   

2. Adicione um campo para armazenar referências de observador.

   O provedor precisa acompanhar cada observador registrado para que ele possa enviar notificações posteriormente. Normalmente, use um objeto de coleção, como um objeto genérico List<T> . O exemplo a seguir define um objeto privado List<T> instanciado no construtor de TemperatureMonitor classe.

   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()
   

3. Defina uma implementação IDisposable para cancelar a assinatura.

   O provedor retorna essa implementação aos assinantes para que eles possam parar de receber notificações a qualquer momento. O exemplo a seguir define uma classe aninhada Unsubscriber que recebe uma referência à coleção de assinantes e ao assinante quando instanciada. A Unsubscriber classe permite que o assinante chame a implementação do IDisposable.Dispose objeto para se remover da coleção de assinantes.

   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
   

4. Implemente o método IObservable<T>.Subscribe.

   O método recebe uma referência à System.IObserver<T> interface. Armazene essa referência na coleção de observadores da etapa anterior e retorne a implementação de IDisposable de cancelamento da assinatura. O exemplo a seguir mostra a Subscribe implementação na 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
   

5. Implemente a lógica de notificação chamando os métodos IObserver<T>.OnNext, IObserver<T>.OnError e IObserver<T>.OnCompleted dos observadores.

   Em alguns casos, um provedor pode não chamar OnError quando ocorrer um erro. GetTemperature O método a seguir simula um monitor que lê dados de temperatura a cada cinco segundos e notifica os observadores se a temperatura foi alterada em pelo menos 0,1 grau desde a leitura anterior. Se o dispositivo não informar uma temperatura (ou seja, se seu valor for nulo), o provedor notifica os observadores de que a transmissão foi concluída chamando o método OnCompleted de cada observador e limpa a coleção List<T>. Neste exemplo, o provedor nunca chama 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
   

Example

O exemplo a seguir contém o código-fonte completo para uma IObservable<T> implementação para um aplicativo de monitoramento de temperatura. Ele inclui a Temperature estrutura, que são os dados que o provedor envia aos observadores e a TemperatureMonitor classe, que é a IObservable<T> implementação.

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

Conteúdo relacionado

• IObservable<T>
• Padrão de design do Observador
• Como implementar um observador
• Práticas recomendadas para o padrão de design do observador