觀察程序設計模式

觀察者設計模式使訂閱者可以向提供程序註冊並接收相關通知。它適合全部須要推送通知的方案。該模式定義一個提供程序（也稱爲主題或觀察對象）以及零個、一個或多個觀察者。觀察者向提供程序註冊，而且當任何預約義的條件、事件或狀態更改發生時，提供程序就會調用觀察者中的一種方法，自動通知全部觀察者。在此方法調用中，提供程序還能夠向觀察者提供當前的狀態信息。在 .NET Framework 中，經過實現泛型 System.IObservable<T> 和 System.IObserver<T> 接口來應用觀察者設計模式。泛型類型參數表示提供通知信息的類型。編程

應用模式

觀察者設計模式適用於分佈式推送通知，由於它支持兩種不一樣的組件或應用程序層之間的絕對分離，例如數據源（業務邏輯）層和用戶界面（顯示）層。每當提供程序使用回調向其客戶端提供當前信息時，便可實現該模式。設計模式

實現該模式須要您提供如下內容：promise

提供程序或主體，即將通知發送給觀察者的對象。提供程序是一個實現 IObservable<T> 接口的類或結構。提供程序必須實現一個方法 (IObservable<T>.Subscribe)，但願接收提供程序通知的觀察者會調用該方法。安全
觀察者，即接收提供程序通知的對象。觀察者是一個實現 IObserver<T> 接口的類或結構。觀察者必須實現三個方法，提供程序將調用全部這些方法：多線程
- IObserver<T>.OnNext ，向觀察者提供新信息或當前信息。併發
- IObserver<T>.OnError ，通知觀察者發生錯誤。app
- IObserver<T>.OnCompleted ，指示提供程序已完成通知發送。異步
容許提供程序跟蹤觀察者的機制。一般狀況下，提供程序使用容器對象（例如 System.Collections.Generic.List<T> 對象）存放對已訂閱通知的 IObserver<T> 實現的引用。所以目的而使用存儲容器時，提供程序可以處理零到無限數量的觀察者。不定義觀察者接收通知的順序；提供程序能夠自由選擇任何方法來肯定該順序。async
容許提供程序在完成通知時移除觀察者的 IDisposable 實現。觀察者從 Subscribe 方法接收對 IDisposable 實現的引用，因此它們還能夠調用 IDisposable.Dispose 方法以在提供程序完成通知發送以前取消訂閱。分佈式
包含提供程序向其觀察者發送的數據的對象。該對象的類型對應於 IObservable<T> 和 IObserver<T> 接口的泛型類型參數。儘管該對象能夠與 IObservable<T> 實現相同，但在一般狀況下，該對象爲不一樣的類型。

注意
除實現觀察者設計模式外，您可能會對探索使用 IObservable<T> 和 IObserver<T> 接口構建的庫感興趣。例如，Reactive Extensions for .NET (Rx) 包含一組支持異步編程的擴展方法和 LINQ 標準序列運算符。

實現模式

下面的示例使用觀察者設計模式實現機場行李提取信息系統。 BaggageInfo 類提供有關到達航班和提取各次航班行李所用轉盤的信息。如如下示例中所示。

using System;
using System.Collections.Generic;

public class BaggageInfo
{
   private int flightNo;
   private string origin;
   private int location;

   internal BaggageInfo(int flight, string from, int carousel)
   {
      this.flightNo = flight;
      this.origin = from;
      this.location = carousel;
   }

   public int FlightNumber {
      get { return this.flightNo; }
   }

   public string From {
      get { return this.origin; }
   }

   public int Carousel {
      get { return this.location; }
   }
}

BaggageHandler 類負責接收有關到達航班和行李提取轉盤的信息。在內部，它包含兩個集合：

observers - 接收更新信息的客戶端集合。
flights - 航班及其指派的轉盤的集合。

兩個集合都由 BaggageHandler 類構造函數中實例化的泛型 List<T> 對象表示。下面的示例中顯示 BaggageHandler 類的源代碼。

public class BaggageHandler : IObservable<BaggageInfo>
{
   private List<IObserver<BaggageInfo>> observers;
   private List<BaggageInfo> flights;

   public BaggageHandler()
   {
      observers = new List<IObserver<BaggageInfo>>();
      flights = new List<BaggageInfo>();
   }

   public IDisposable Subscribe(IObserver<BaggageInfo> observer)
   {
      // Check whether observer is already registered. If not, add it
      if (! observers.Contains(observer)) {
         observers.Add(observer);
         // Provide observer with existing data.
         foreach (var item in flights)
            observer.OnNext(item);
      }
      return new Unsubscriber<BaggageInfo>(observers, observer);
   }

   // Called to indicate all baggage is now unloaded.
   public void BaggageStatus(int flightNo)
   {
      BaggageStatus(flightNo, String.Empty, 0);
   }

   public void BaggageStatus(int flightNo, string from, int carousel)
   {
      var info = new BaggageInfo(flightNo, from, carousel);

      // Carousel is assigned, so add new info object to list.
      if (carousel > 0 && ! flights.Contains(info)) {
         flights.Add(info);
         foreach (var observer in observers)
            observer.OnNext(info);
      }
      else if (carousel == 0) {
         // Baggage claim for flight is done
         var flightsToRemove = new List<BaggageInfo>();
         foreach (var flight in flights) {
            if (info.FlightNumber == flight.FlightNumber) {
               flightsToRemove.Add(flight);
               foreach (var observer in observers)
                  observer.OnNext(info);
            }
         }
         foreach (var flightToRemove in flightsToRemove)
            flights.Remove(flightToRemove);

         flightsToRemove.Clear();
      }
   }

   public void LastBaggageClaimed()
   {
      foreach (var observer in observers)
         observer.OnCompleted();

      observers.Clear();
   }
}

但願接收更新信息的客戶端調用 BaggageInfo.Subscribe 方法。若是客戶端以前沒有訂閱過通知，則會將對客戶端 IObserver<T> 實現的引用添加到 observers 集合中。

能夠調用重載的 BaggageHandler.BaggageStatus 方法以指示是正在卸載仍是已卸載航班行李。在第一種狀況中，向該方法傳遞航班號、航班起飛的機場，以及卸載行李的轉盤。在第二種狀況中，僅向該方法傳遞航班號。對於正在卸載的行李，該方法檢查傳遞給方法的 BaggageInfo 信息是否位於 flights 集合中。若是沒有，該方法將添加相應信息並調用每一個觀察者的 OnNext 方法。對於完成行李卸載的航班，該方法會檢查有關此航班的信息是否位於 flights 集合中。若是在該集合中，該方法會調用每一個觀察者的 OnNext 方法並從 flights 集合中移除 BaggageInfo 對象。

當天最後一趟航班着陸並處理完其行李後，將調用 BaggageHandler.LastBaggageClaimed 方法。該方法調用每一個觀察者的 OnCompleted 方法以指示已完成全部通知，而後清除 observers 集合。

提供程序的 Subscribe 方法返回使觀察者能夠在調用 OnCompleted 方法以前中止接收通知的 IDisposable 實現。下面的示例中顯示該 Unsubscriber(Of BaggageInfo) 類的源代碼。當類在 BaggageHandler.Subscribe 方法中實例化時，將向其傳遞對 observers 集合的引用以及對添加至該集合的觀察者的引用。這些引用將指派給局部變量。當調用對象的 Dispose 方法時，它會檢查觀察者是否仍在 observers 集合中，若是在，則移除觀察者。

internal class Unsubscriber<BaggageInfo> : IDisposable
{
   private List<IObserver<BaggageInfo>> _observers;
   private IObserver<BaggageInfo> _observer;

   internal Unsubscriber(List<IObserver<BaggageInfo>> observers, IObserver<BaggageInfo> observer)
   {
      this._observers = observers;
      this._observer = observer;
   }

   public void Dispose() 
   {
      if (_observers.Contains(_observer))
         _observers.Remove(_observer);
   }
}

下面的示例提供名爲 ArrivalsMonitor 的 IObserver<T> 實現，它是顯示行李提取信息的基類。該信息按起飛城市名稱的字母順序顯示。 ArrivalsMonitor 的方法標記爲 overridable (Visual Basic) 或 virtual (C#)，因此它們可所有由派生類重寫。

using System;
using System.Collections.Generic;

public class ArrivalsMonitor : IObserver<BaggageInfo>
{
   private string name;
   private List<string> flightInfos = new List<string>();
   private IDisposable cancellation;
   private string fmt = "{0,-20} {1,5}  {2, 3}";

   public ArrivalsMonitor(string name)
   {
      if (String.IsNullOrEmpty(name))
         throw new ArgumentNullException("The observer must be assigned a name.");

      this.name = name;
   }

   public virtual void Subscribe(BaggageHandler provider)
   {
      cancellation = provider.Subscribe(this);
   }

   public virtual void Unsubscribe()
   {
      cancellation.Dispose();
      flightInfos.Clear();
   }

   public virtual void OnCompleted() 
   {
      flightInfos.Clear();
   }

   // No implementation needed: Method is not called by the BaggageHandler class.
   public virtual void OnError(Exception e)
   {
      // No implementation.
   }

   // Update information.
   public virtual void OnNext(BaggageInfo info) 
   {
      bool updated = false;

      // Flight has unloaded its baggage; remove from the monitor.
      if (info.Carousel == 0) {
         var flightsToRemove = new List<string>();
         string flightNo = String.Format("{0,5}", info.FlightNumber);

         foreach (var flightInfo in flightInfos) {
            if (flightInfo.Substring(21, 5).Equals(flightNo)) {
               flightsToRemove.Add(flightInfo);
               updated = true;
            }
         }
         foreach (var flightToRemove in flightsToRemove)
            flightInfos.Remove(flightToRemove);

         flightsToRemove.Clear();
      }
      else {
         // Add flight if it does not exist in the collection.
         string flightInfo = String.Format(fmt, info.From, info.FlightNumber, info.Carousel);
         if (! flightInfos.Contains(flightInfo)) {
            flightInfos.Add(flightInfo);
            updated = true;
         }
      }
      if (updated) {
         flightInfos.Sort();
         Console.WriteLine("Arrivals information from {0}", this.name);
         foreach (var flightInfo in flightInfos)
            Console.WriteLine(flightInfo);

         Console.WriteLine();
      }
   }
}

ArrivalsMonitor 類包括 Subscribe 和 Unsubscribe 方法。 Subscribe 方法容許類將由對 Subscribe 的調用返回的 IDisposable 實現保存至私有變量中。 Unsubscribe 方法容許類經過調用提供程序的 Dispose 實現來取消訂閱通知。 ArrivalsMonitor 還提供 OnNext、OnError 和 OnCompleted 方法的實現。僅 OnNext 實現包含大量代碼。該方法使用已排序的私有泛型 List<T> 對象，此對象維護到達航班的起飛機場及其行李使用的轉盤的信息。若是 BaggageHandler 類報告有新航班到達，則 OnNext 方法實現會將有關該航班的信息添加到列表中。若是 BaggageHandler 類報告已卸載航班行李，則 OnNext 方法會從列表中移除該航班。不管什麼時候進行更改，都會對列表進行排序，並將其顯示在控制檯上。

下面的示例包含實例化 BaggageHandler 類的應用程序入口點，以及兩個 ArrivalsMonitor 類的實例，並使用 BaggageHandler.BaggageStatus 方法添加和移除有關到達航班的信息。在每種狀況下，觀察者都接收更新並正確顯示行李提取信息。

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      BaggageHandler provider = new BaggageHandler();
      ArrivalsMonitor observer1 = new ArrivalsMonitor("BaggageClaimMonitor1");
      ArrivalsMonitor observer2 = new ArrivalsMonitor("SecurityExit");

      provider.BaggageStatus(712, "Detroit", 3);
      observer1.Subscribe(provider);
      provider.BaggageStatus(712, "Kalamazoo", 3);
      provider.BaggageStatus(400, "New York-Kennedy", 1);
      provider.BaggageStatus(712, "Detroit", 3);
      observer2.Subscribe(provider);
      provider.BaggageStatus(511, "San Francisco", 2);
      provider.BaggageStatus(712);
      observer2.Unsubscribe();
      provider.BaggageStatus(400);
      provider.LastBaggageClaimed();
   }
}
// The example displays the following output:
//      Arrivals information from BaggageClaimMonitor1
//      Detroit                712    3
//
//      Arrivals information from BaggageClaimMonitor1
//      Detroit                712    3
//      Kalamazoo              712    3
//
//      Arrivals information from BaggageClaimMonitor1
//      Detroit                712    3
//      Kalamazoo              712    3
//      New York-Kennedy       400    1
//
//      Arrivals information from SecurityExit
//      Detroit                712    3
//
//      Arrivals information from SecurityExit
//      Detroit                712    3
//      Kalamazoo              712    3
//
//      Arrivals information from SecurityExit
//      Detroit                712    3
//      Kalamazoo              712    3
//      New York-Kennedy       400    1
//
//      Arrivals information from BaggageClaimMonitor1
//      Detroit                712    3
//      Kalamazoo              712    3
//      New York-Kennedy       400    1
//      San Francisco          511    2
//
//      Arrivals information from SecurityExit
//      Detroit                712    3
//      Kalamazoo              712    3
//      New York-Kennedy       400    1
//      San Francisco          511    2
//
//      Arrivals information from BaggageClaimMonitor1
//      New York-Kennedy       400    1
//      San Francisco          511    2
//
//      Arrivals information from SecurityExit
//      New York-Kennedy       400    1
//      San Francisco          511    2
//
//      Arrivals information from BaggageClaimMonitor1
//      San Francisco          511    2

觀察程序設計模式最佳作法

在 .NET Framework 中，以一組接口的形式實現觀察者設計模式。 System.IObserver<T> 接口表示數據提供程序，還負責提供容許觀察者取消訂閱通知的 IDisposable 實現。 System.IObserver<T> 接口表示觀察者。本主題介紹開發人員使用這些接口實現觀察者設計模式時應遵循的最佳作法。

線程處理

一般，提供程序經過將特定的觀察者添加到由某些集合對象表示的訂閱者列表中來實現 IObservable<T>.Subscribe 方法，並經過從訂閱者列表中移除特定的觀察者來實現 IDisposable.Dispose 方法。觀察者能夠隨時調用這些方法。另外，因爲提供程序/觀察者協定並未指定誰負責在 IObserver<T>.OnCompleted 回調方法以後取消訂閱，所以提供程序和觀察者可能都會嘗試從列表中移除相同成員。由於有可能出現這種狀況，因此 Subscribe 和 Dispose 方法都應是線程安全的。一般，這會涉及使用併發集合或鎖。非線程安全的實現應顯式註明它們不是線程安全的。

除提供程序/觀察者協定外，還必須在層中指定任何其餘保證。當實施者強加其餘要求時應進行明確說明，以免用戶對觀察者協定產生混淆。

處理異常

因爲數據提供程序和觀察者之間存在鬆耦合，所以觀察者設計模式中的異常主要用於提供信息。這會影響提供程序和觀察者在觀察者設計模式中處理異常的方式。

提供程序 -- 調用 OnError 方法

OnError 方法旨在爲觀察者提供信息性消息，它與 IObserver<T>.OnNext 方法類似。可是，OnNext 方法旨在向觀察者提供當前數據或更新的數據，而 OnError 方法旨在指示提供程序沒法提供有效數據。

提供程序在處理異常和調用 OnError 方法時應遵循如下最佳作法：

若是提供程序具備任何特定的要求，則必須處理本身的異常。
提供程序不該期待或要求觀察者以任何特殊的方式處理異常。
當提供程序處理有損其更新提供能力的異常時，應調用 OnError 方法。可將此類異常的信息傳遞給觀察者。在其餘狀況下，則無需向觀察者通知異常。

提供程序調用 OnError 或 IObserver<T>.OnCompleted 方法後，不該有進一步的通知，而且提供程序能夠取消訂閱其觀察者。可是，觀察者也能夠隨時取消訂閱本身，包括在接收 OnError 或 IObserver<T>.OnCompleted 通知的以前和以後。因爲觀察者設計模式不指明是提供程序仍是觀察者負責取消訂閱，所以有可能二者都嘗試執行取消訂閱操做。一般，當觀察者取消訂閱時，會從訂閱者集合中移除它們。在單一線程的應用程序中，IDisposable.Dispose 實如今嘗試移除對象以前應先確保對象引用有效，而且對象是訂閱者集合中的成員。對於多線程應用程序，應使用線程安全的集合對象，如 System.Collections.Concurrent.BlockingCollection<T> 對象。

觀察者 -- 實現 OnError 方法

當觀察者收到來自提供程序的錯誤通知時，觀察者應將異常做爲信息處理，而且不該被要求執行任何特殊的操做。

觀察者在響應來自提供程序的 OnError 方法調用時應遵循如下最佳作法：

觀察者不該從其接口實現引起異常，例如 OnNext 或 OnError。可是，若是觀察者確實引起了異常，則應指望這些異常處於未處理狀態。
若要保留調用堆棧，但願引起傳遞給其 OnError 方法的 Exception 對象的觀察者，應在引起以前對異常進行包裝。爲此，應使用標準異常對象。

其餘最佳作法

在 IObservable<T>.Subscribe 方法中嘗試取消註冊可能致使 null 引用。所以，建議您避免使用這種作法。

儘管能夠將一個觀察者附加到多個提供程序，但建議的模式是將一個 IObserver<T> 實例僅附加到一個 IObservable<T> 實例。

如何：實現提供程序

觀察者設計模式要求在提供程序（監視數據和發送通知）和一個或多個觀察者（接收提供程序的通知，即回調）之間進行區分。本主題討論如何建立提供程序。相關主題如何：實現觀察程序討論如何建立觀察者。

建立提供程序

定義提供程序負責發送給觀察者的數據。儘管提供程序和它發送給觀察者的數據能夠爲一個類型，可是一般它們都採用不一樣的類型表示。例如，在溫度監控應用程序中，Temperature 結構定義提供程序（由下一步中定義的 TemperatureMonitor 類表示）監控的數據和觀察者訂閱的數據。

using System;

public struct Temperature
{
   private decimal temp;
   private DateTime tempDate;

   public Temperature(decimal temperature, DateTime dateAndTime)
   {
      this.temp = temperature;
      this.tempDate = dateAndTime;
   }

   public decimal Degrees
   { get { return this.temp; } }

   public DateTime Date
   { get { return this.tempDate; } }
}

定義數據提供程序，這是實現 System.IObservable<T> 接口的類型。提供程序的泛型類型參數是提供程序發送給觀察者的類型。下面的示例定義了一個 TemperatureMonitor 類，它是具備 Temperature 泛型類型參數的構造 System.IObservable<T> 實現。
複製
using System; using System.Collections.Generic; public class TemperatureMonitor : IObservable<Temperature> { ... }
肯定提供程序存儲觀察者引用的方式，以便每一個觀察者都能在適當的時候獲得通知。最經常使用於此目的是集合對象，如泛型 List<T> 對象。下面的示例定義了一個專用的 List<T> 對象，它在 TemperatureMonitor 類構造函數中實例化。
複製
using System; using System.Collections.Generic; public class TemperatureMonitor : IObservable<Temperature> { List<IObserver<Temperature>> observers; public TemperatureMonitor() { observers = new List<IObserver<Temperature>>(); } ... }

定義提供程序能夠返回至訂閱者的 IDisposable 實現，以便它們可以隨時中止接收通知。下面的示例定義了一個嵌套的 Unsubscriber 類，在實例化類時，會向該類傳遞對訂閱者集合和訂閱者的引用。此代碼容許訂閱者調用對象的 IDisposable.Dispose 實現，以將其自身從訂閱者集合中移除。

private class Unsubscriber : IDisposable
{
   private List<IObserver<Temperature>> _observers;
   private IObserver<Temperature> _observer;

   public Unsubscriber(List<IObserver<Temperature>> observers, IObserver<Temperature> observer)
   {
      this._observers = observers;
      this._observer = observer;
   }

   public void Dispose() 
   {
      if (! (_observer == null)) _observers.Remove(_observer);
   }
}

實現 IObservable<T>.Subscribe 方法。將向該方法傳遞對 System.IObserver<T> 接口的引用，而且該方法應存儲在步驟 3 中爲該目的而設計的對象中。而後，該方法應該返回步驟 4 中開發的 IDisposable 實現。下面的示例演示 TemperatureMonitor 類中 Subscribe 方法的實現。
複製
public IDisposable Subscribe(IObserver<Temperature> observer) { if (! observers.Contains(observer)) observers.Add(observer); return new Unsubscriber(observers, observer); }

經過調用觀察者的 IObserver<T>.OnNext、IObserver<T>.OnError 和 IObserver<T>.OnCompleted 實現，根據須要通知觀察者。在某些狀況下，提供程序在發生錯誤時可能不會調用 OnError 方法。例如，下面的 GetTemperature 方法模擬一個監視器，它每五秒讀取一次溫度數據，並對照以前的讀數，若是溫度的變化大於或等於 0.1 度則通知觀察者。若是設備不報告溫度（即其值爲 null），則提供程序會通知觀察者傳輸已完成。請注意，除調用每一個觀察者的 OnCompleted 方法外，GetTemperature 方法還會清除 List<T> 集合。在這種狀況下，提供程序不調用其觀察者的 OnError 方法。

public void GetTemperature()
{
   // Create an array of sample data to mimic a temperature device.
   Nullable<Decimal>[] temps = {14.6m, 14.65m, 14.7m, 14.9m, 14.9m, 15.2m, 15.25m, 15.2m,
                                15.4m, 15.45m, null };
   // Store the previous temperature, so notification is only sent after at least .1 change.
   Nullable<Decimal> previous = null;
   bool start = true;

   foreach (var temp in temps) {
      System.Threading.Thread.Sleep(2500);
      if (temp.HasValue) {
         if (start || (Math.Abs(temp.Value - previous.Value) >= 0.1m )) {
            Temperature tempData = new Temperature(temp.Value, DateTime.Now);
            foreach (var observer in observers)
               observer.OnNext(tempData);
            previous = temp;
            if (start) start = false;
         }
      }
      else {
         foreach (var observer in observers.ToArray())
            if (observer != null) observer.OnCompleted();

         observers.Clear();
         break;
      }
   }
}

示例

下面的示例包含定義溫度監控應用程序的 IObservable<T> 實現的完整源代碼。它包括 Temperature 結構（發送給觀察者的數據）和 TemperatureMonitor 類（即 IObservable<T> 實現）。

using System.Threading;
using System;
using System.Collections.Generic;

public class TemperatureMonitor : IObservable<Temperature>
{
   List<IObserver<Temperature>> observers;

   public TemperatureMonitor()
   {
      observers = new List<IObserver<Temperature>>();
   }

   private class Unsubscriber : IDisposable
   {
      private List<IObserver<Temperature>> _observers;
      private IObserver<Temperature> _observer;

      public Unsubscriber(List<IObserver<Temperature>> observers, IObserver<Temperature> observer)
      {
         this._observers = observers;
         this._observer = observer;
      }

      public void Dispose() 
      {
         if (! (_observer == null)) _observers.Remove(_observer);
      }
   }

   public IDisposable Subscribe(IObserver<Temperature> observer)
   {
      if (! observers.Contains(observer))
         observers.Add(observer);

      return new Unsubscriber(observers, observer);
   }

   public void GetTemperature()
   {
      // Create an array of sample data to mimic a temperature device.
      Nullable<Decimal>[] temps = {14.6m, 14.65m, 14.7m, 14.9m, 14.9m, 15.2m, 15.25m, 15.2m,
                                   15.4m, 15.45m, null };
      // Store the previous temperature, so notification is only sent after at least .1 change.
      Nullable<Decimal> previous = null;
      bool start = true;

      foreach (var temp in temps) {
         System.Threading.Thread.Sleep(2500);
         if (temp.HasValue) {
            if (start || (Math.Abs(temp.Value - previous.Value) >= 0.1m )) {
               Temperature tempData = new Temperature(temp.Value, DateTime.Now);
               foreach (var observer in observers)
                  observer.OnNext(tempData);
               previous = temp;
               if (start) start = false;
            }
         }
         else {
            foreach (var observer in observers.ToArray())
               if (observer != null) observer.OnCompleted();

            observers.Clear();
            break;
         }
      }
   }
}

如何：實現觀察程序

觀察者設計模式要求在觀察者（註冊通知）和提供程序（監視數據並將通知發送至一個或多個觀察者）之間插入分隔符。本主題討論如何建立觀察者。相關主題如何：實現提供程序討論如何建立提供程序。

建立觀察者

定義做爲實現 System.IObserver<T> 接口的類型的觀察者。例如，下面的代碼定義一個名爲 TemperatureReporter 的類型，它是使用 Temperature 泛型類型參數構造的 System.IObserver<T> 實現。
複製
public class TemperatureReporter : IObserver<Temperature>
若是觀察者能夠在提供程序調用其 IObserver<T>.OnCompleted 實現以前中止接收通知，請定義保留提供程序的 IObservable<T>.Subscribe 方法返回的 IDisposable 實現的私有變量。還應定義調用提供程序的 Subscribe 方法並存儲返回的 IDisposable 對象的訂閱方法。例如，下面的代碼定義一個名爲 unsubscriber 的私有變量，並定義一個調用提供程序的 Subscribe 方法並將返回的對象指派給 unsubscriber 變量的 Subscribe 方法。
複製
public class TemperatureReporter : IObserver<Temperature> { private IDisposable unsubscriber; private bool first = true; private Temperature last; public virtual void Subscribe(IObservable<Temperature> provider) { unsubscriber = provider.Subscribe(this); } ... }
定義使觀察者能夠在提供程序調用其 IObserver<T>.OnCompleted 實現以前中止接收通知的方法（若是須要此功能）。下面的示例定義 Unsubscribe 方法。
複製
public virtual void Unsubscribe() { unsubscriber.Dispose(); }

提供由 IObserver<T> 接口定義的三種方法的實現：IObserver<T>.OnNext、IObserver<T>.OnError 和 IObserver<T>.OnCompleted。根據提供程序和應用程序的需求，OnError 和 OnCompleted 方法能夠爲存根實現。注意，OnError 方法不該將傳遞的 Exception 對象做爲異常處理，而 OnCompleted 方法能夠自由調用提供程序的 IDisposable.Dispose 實現。下面的示例演示 TemperatureReporter 類的 IObserver<T> 實現。

public virtual void OnCompleted() 
{
   Console.WriteLine("Additional temperature data will not be transmitted.");
}

public virtual void OnError(Exception error)
{
   // Do nothing.
}

public virtual void OnNext(Temperature value)
{
   Console.WriteLine("The temperature is {0}°C at {1:g}", value.Degrees, value.Date);
   if (first)
   {
      last = value;
      first = false;
   }
   else
   {
      Console.WriteLine("   Change: {0}° in {1:g}", value.Degrees - last.Degrees,
                                                    value.Date.ToUniversalTime() - last.Date.ToUniversalTime());
   }
}

示例

下面的示例包含 TemperatureReporter 類（提供溫度監控應用程序的 IObserver<T> 實現）的完整源代碼。

public class TemperatureReporter : IObserver<Temperature>
{
   private IDisposable unsubscriber;
   private bool first = true;
   private Temperature last;

   public virtual void Subscribe(IObservable<Temperature> provider)
   {
      unsubscriber = provider.Subscribe(this);
   }

   public virtual void Unsubscribe()
   {
      unsubscriber.Dispose();
   }

   public virtual void OnCompleted() 
   {
      Console.WriteLine("Additional temperature data will not be transmitted.");
   }

   public virtual void OnError(Exception error)
   {
      // Do nothing.
   }

   public virtual void OnNext(Temperature value)
   {
      Console.WriteLine("The temperature is {0}°C at {1:g}", value.Degrees, value.Date);
      if (first)
      {
         last = value;
         first = false;
      }
      else
      {
         Console.WriteLine("   Change: {0}° in {1:g}", value.Degrees - last.Degrees,
                                                       value.Date.ToUniversalTime() - last.Date.ToUniversalTime());
      }
   }
}