class/System.ServiceModel.Discovery/System.ServiceModel.Discovery/AnnouncementClient.cs

   1 using System;
   2 using System.Collections.Generic;
   3 using System.Collections.ObjectModel;
   4 using System.ComponentModel;
   5 using System.ServiceModel;
   6 using System.ServiceModel.Channels;
   7 using System.ServiceModel.Description;
   8 using System.ServiceModel.Dispatcher;
   9
  10 namespace System.ServiceModel.Discovery
  11 {
  12         [MonoTODO]
  13         public sealed class AnnouncementClient : ICommunicationObject, IDisposable
  14         {
  15                 public AnnouncementClient ()
  16                 {
  17                 }
  18
  19                 public AnnouncementClient (AnnouncementEndpoint announcementEndpoint)
  20                 {
  21                 }
  22
  23                 public AnnouncementClient (string endpointConfigurationName)
  24                 {
  25                 }
  26
  27                 public ChannelFactory ChannelFactory { get; private set; }
  28                 public ClientCredentials ClientCredentials { get; private set; }
  29                 public ServiceEndpoint Endpoint { get; private set; }
  30                 public IClientChannel InnerChannel { get; private set; }
  31                 public DiscoveryMessageSequenceGenerator MessageSequenceGenerator { get; set; }
  32
  33                 CommunicationState ICommunicationObject.State {
  34                         get { return InnerChannel.State; }
  35                 }
  36
  37                 public event EventHandler<AsyncCompletedEventArgs> AnnounceOfflineCompleted;
  38                 public event EventHandler<AsyncCompletedEventArgs> AnnounceOnlineCompleted;
  39
  40                 event EventHandler ICommunicationObject.Closed {
  41                         add { InnerChannel.Closed += value; }
  42                         remove { InnerChannel.Closed -= value; }
  43                 }
  44                 event EventHandler ICommunicationObject.Closing {
  45                         add { InnerChannel.Closing += value; }
  46                         remove { InnerChannel.Closing -= value; }
  47                 }
  48                 event EventHandler ICommunicationObject.Faulted {
  49                         add { InnerChannel.Faulted += value; }
  50                         remove { InnerChannel.Faulted -= value; }
  51                 }
  52                 event EventHandler ICommunicationObject.Opened {
  53                         add { InnerChannel.Opened += value; }
  54                         remove { InnerChannel.Opened -= value; }
  55                 }
  56                 event EventHandler ICommunicationObject.Opening {
  57                         add { InnerChannel.Opening += value; }
  58                         remove { InnerChannel.Opening -= value; }
  59                 }
  60
  61                 public void AnnounceOffline (EndpointDiscoveryMetadata discoveryMetadata)
  62                 {
  63                         throw new NotImplementedException ();
  64                 }
  65
  66                 public void AnnounceOfflineAsync (EndpointDiscoveryMetadata discoveryMetadata)
  67                 {
  68                         throw new NotImplementedException ();
  69                 }
  70
  71                 public void AnnounceOfflineAsync (EndpointDiscoveryMetadata discoveryMetadata, object userState)
  72                 {
  73                         throw new NotImplementedException ();
  74                 }
  75
  76                 public void AnnounceOnline (EndpointDiscoveryMetadata discoveryMetadata)
  77                 {
  78                         throw new NotImplementedException ();
  79                 }
  80
  81                 public void AnnounceOnlineAsync (EndpointDiscoveryMetadata discoveryMetadata)
  82                 {
  83                         throw new NotImplementedException ();
  84                 }
  85
  86                 public void AnnounceOnlineAsync (EndpointDiscoveryMetadata discoveryMetadata, object userState)
  87                 {
  88                         throw new NotImplementedException ();
  89                 }
  90
  91                 public IAsyncResult BeginAnnounceOffline (EndpointDiscoveryMetadata discoveryMetadata, AsyncCallback callback, object state)
  92                 {
  93                         throw new NotImplementedException ();
  94                 }
  95
  96                 public IAsyncResult BeginAnnounceOnline (EndpointDiscoveryMetadata discoveryMetadata, AsyncCallback callback, object state)
  97                 {
  98                         throw new NotImplementedException ();
  99                 }
 100
 101                 public void EndAnnounceOffline (IAsyncResult result)
 102                 {
 103                         throw new NotImplementedException ();
 104                 }
 105
 106                 public void EndAnnounceOnline (IAsyncResult result)
 107                 {
 108                         throw new NotImplementedException ();
 109                 }
 110
 111                 public void Close ()
 112                 {
 113                         throw new NotImplementedException ();
 114                 }
 115
 116                 public void Open ()
 117                 {
 118                         throw new NotImplementedException ();
 119                 }
 120
 121                 // explicit interface impl.
 122
 123                 void ICommunicationObject.Open ()
 124                 {
 125                         InnerChannel.Open ();
 126                 }
 127
 128                 void ICommunicationObject.Open (TimeSpan timeout)
 129                 {
 130                         InnerChannel.Open (timeout);
 131                 }
 132
 133                 void ICommunicationObject.Close ()
 134                 {
 135                         InnerChannel.Close ();
 136                 }
 137
 138                 void ICommunicationObject.Close (TimeSpan timeout)
 139                 {
 140                         InnerChannel.Close (timeout);
 141                 }
 142
 143                 IAsyncResult ICommunicationObject.BeginOpen (AsyncCallback callback, object state)
 144                 {
 145                         return InnerChannel.BeginOpen (callback, state);
 146                 }
 147
 148                 IAsyncResult ICommunicationObject.BeginOpen (TimeSpan timeout, AsyncCallback callback, object state)
 149                 {
 150                         return InnerChannel.BeginOpen (timeout, callback, state);
 151                 }
 152
 153                 IAsyncResult ICommunicationObject.BeginClose (AsyncCallback callback, object state)
 154                 {
 155                         return InnerChannel.BeginClose (callback, state);
 156                 }
 157
 158                 IAsyncResult ICommunicationObject.BeginClose (TimeSpan timeout, AsyncCallback callback, object state)
 159                 {
 160                         return InnerChannel.BeginClose (timeout, callback, state);
 161                 }
 162
 163                 void ICommunicationObject.EndOpen (IAsyncResult result)
 164                 {
 165                         InnerChannel.EndOpen (result);
 166                 }
 167
 168                 void ICommunicationObject.EndClose (IAsyncResult result)
 169                 {
 170                         InnerChannel.EndClose (result);
 171                 }
 172
 173                 void ICommunicationObject.Abort ()
 174                 {
 175                         InnerChannel.Abort ();
 176                 }
 177
 178                 void IDisposable.Dispose ()
 179                 {
 180                         InnerChannel.Dispose ();
 181                 }
 182         }
 183 }