1 //----------------------------------------------------------------
2 // Copyright (c) Microsoft Corporation.  All rights reserved.
3 //----------------------------------------------------------------
4 
5 namespace System.ServiceModel.Discovery.VersionCD1
6 {
7     using System;
8     using System.Runtime;
9     using System.ServiceModel.Description;
10 
11     class DiscoveryInnerClientAdhocCD1 : IDiscoveryInnerClient, IDiscoveryResponseContractCD1
12     {
13         IDiscoveryInnerClientResponse responseReceiver;
14         DuplexClientCD1 duplexInnerClient;
15 
DiscoveryInnerClientAdhocCD1(DiscoveryEndpoint discoveryEndpoint, IDiscoveryInnerClientResponse responseReceiver)16         public DiscoveryInnerClientAdhocCD1(DiscoveryEndpoint discoveryEndpoint, IDiscoveryInnerClientResponse responseReceiver)
17         {
18             Fx.Assert(discoveryEndpoint != null, "The discoveryEndpoint parameter cannot be null");
19             Fx.Assert(responseReceiver != null, "The responseReceiver parameter cannot be null");
20 
21             this.responseReceiver = responseReceiver;
22             if (discoveryEndpoint.Behaviors.Find<DiscoveryCallbackBehavior>() == null)
23             {
24                 discoveryEndpoint.Behaviors.Insert(0, new DiscoveryCallbackBehavior());
25             }
26 
27             this.duplexInnerClient = new DuplexClientCD1(this, discoveryEndpoint);
28         }
29 
30         public ClientCredentials ClientCredentials
31         {
32             get
33             {
34                 return this.duplexInnerClient.ClientCredentials;
35             }
36         }
37 
38         public ChannelFactory ChannelFactory
39         {
40             get
41             {
42                 return this.duplexInnerClient.ChannelFactory;
43             }
44         }
45 
46         public IClientChannel InnerChannel
47         {
48             get
49             {
50                 return this.duplexInnerClient.InnerChannel;
51             }
52         }
53 
54         public ServiceEndpoint Endpoint
55         {
56             get
57             {
58                 return this.duplexInnerClient.Endpoint;
59             }
60         }
61 
62         public ICommunicationObject InnerCommunicationObject
63         {
64             get
65             {
66                 return this.duplexInnerClient as ICommunicationObject;
67             }
68         }
69 
70         public bool IsRequestResponse
71         {
72             get
73             {
74                 return false;
75             }
76         }
77 
BeginProbeOperation(FindCriteria findCriteria, AsyncCallback callback, object state)78         public IAsyncResult BeginProbeOperation(FindCriteria findCriteria, AsyncCallback callback, object state)
79         {
80             ProbeMessageCD1 request = new ProbeMessageCD1();
81             request.Probe = FindCriteriaCD1.FromFindCriteria(findCriteria);
82             return this.duplexInnerClient.BeginProbeOperation(request, callback, state);
83         }
84 
BeginResolveOperation(ResolveCriteria resolveCriteria, AsyncCallback callback, object state)85         public IAsyncResult BeginResolveOperation(ResolveCriteria resolveCriteria, AsyncCallback callback, object state)
86         {
87             ResolveMessageCD1 request = new ResolveMessageCD1();
88             request.Resolve = ResolveCriteriaCD1.FromResolveCriteria(resolveCriteria);
89             return this.duplexInnerClient.BeginResolveOperation(request, callback, state);
90         }
91 
EndProbeOperation(IAsyncResult result)92         public void EndProbeOperation(IAsyncResult result)
93         {
94             this.duplexInnerClient.EndProbeOperation(result);
95         }
96 
EndResolveOperation(IAsyncResult result)97         public void EndResolveOperation(IAsyncResult result)
98         {
99             this.duplexInnerClient.EndResolveOperation(result);
100         }
101 
ProbeOperation(FindCriteria findCriteria)102         public void ProbeOperation(FindCriteria findCriteria)
103         {
104             ProbeMessageCD1 request = new ProbeMessageCD1();
105             request.Probe = FindCriteriaCD1.FromFindCriteria(findCriteria);
106             this.duplexInnerClient.ProbeOperation(request);
107         }
108 
ResolveOperation(ResolveCriteria resolveCriteria)109         public void ResolveOperation(ResolveCriteria resolveCriteria)
110         {
111             ResolveMessageCD1 request = new ResolveMessageCD1();
112             request.Resolve = ResolveCriteriaCD1.FromResolveCriteria(resolveCriteria);
113             this.duplexInnerClient.ResolveOperation(request);
114         }
115 
BeginProbeMatchOperation(ProbeMatchesMessageCD1 response, AsyncCallback callback, object state)116         public IAsyncResult BeginProbeMatchOperation(ProbeMatchesMessageCD1 response, AsyncCallback callback, object state)
117         {
118             Fx.Assert(response != null, "The response message cannot be null.");
119             if ((response.MessageSequence != null) && (response.ProbeMatches != null))
120             {
121                 this.responseReceiver.ProbeMatchOperation(
122                     OperationContext.Current.IncomingMessageHeaders.RelatesTo,
123                     response.MessageSequence.ToDiscoveryMessageSequence(),
124                     DiscoveryUtility.ToEndpointDiscoveryMetadataCollection(response.ProbeMatches),
125                     false);
126             }
127             else
128             {
129                 if (response.MessageSequence == null && TD.DiscoveryMessageWithNullMessageSequenceIsEnabled())
130                 {
131                     TD.DiscoveryMessageWithNullMessageSequence(
132                         ProtocolStrings.TracingStrings.ProbeMatches,
133                         OperationContext.Current.IncomingMessageHeaders.MessageId.ToString());
134                 }
135             }
136 
137             return new CompletedAsyncResult(callback, state);
138         }
139 
EndProbeMatchOperation(IAsyncResult result)140         public void EndProbeMatchOperation(IAsyncResult result)
141         {
142             CompletedAsyncResult.End(result);
143         }
144 
BeginResolveMatchOperation(ResolveMatchesMessageCD1 response, AsyncCallback callback, object state)145         public IAsyncResult BeginResolveMatchOperation(ResolveMatchesMessageCD1 response, AsyncCallback callback, object state)
146         {
147             Fx.Assert(response != null, "The response message cannot be null.");
148             if ((response.MessageSequence != null) && (response.ResolveMatches != null) && (response.ResolveMatches.ResolveMatch != null))
149             {
150                 this.responseReceiver.ResolveMatchOperation(
151                     OperationContext.Current.IncomingMessageHeaders.RelatesTo,
152                     response.MessageSequence.ToDiscoveryMessageSequence(),
153                     response.ResolveMatches.ResolveMatch.ToEndpointDiscoveryMetadata());
154             }
155             else
156             {
157                 if (response.MessageSequence == null && TD.DiscoveryMessageWithNullMessageSequenceIsEnabled())
158                 {
159                     TD.DiscoveryMessageWithNullMessageSequence(
160                         ProtocolStrings.TracingStrings.ResolveMatches,
161                         OperationContext.Current.IncomingMessageHeaders.MessageId.ToString());
162                 }
163             }
164             return new CompletedAsyncResult(callback, state);
165         }
166 
EndResolveMatchOperation(IAsyncResult result)167         public void EndResolveMatchOperation(IAsyncResult result)
168         {
169             CompletedAsyncResult.End(result);
170         }
171 
BeginHelloOperation(HelloMessageCD1 message, AsyncCallback callback, object state)172         public IAsyncResult BeginHelloOperation(HelloMessageCD1 message, AsyncCallback callback, object state)
173         {
174             Fx.Assert(message != null, "The message cannot be null.");
175             if ((message.MessageSequence != null) && (message.Hello != null))
176             {
177                 this.responseReceiver.HelloOperation(
178                     OperationContext.Current.IncomingMessageHeaders.RelatesTo,
179                     message.MessageSequence.ToDiscoveryMessageSequence(),
180                     message.Hello.ToEndpointDiscoveryMetadata());
181             }
182             else
183             {
184                 if (message.MessageSequence == null && TD.DiscoveryMessageWithNullMessageSequenceIsEnabled())
185                 {
186                     TD.DiscoveryMessageWithNullMessageSequence(
187                         ProtocolStrings.TracingStrings.Hello,
188                         OperationContext.Current.IncomingMessageHeaders.MessageId.ToString());
189                 }
190             }
191             return new CompletedAsyncResult(callback, state);
192         }
193 
EndHelloOperation(IAsyncResult result)194         public void EndHelloOperation(IAsyncResult result)
195         {
196             CompletedAsyncResult.End(result);
197         }
198 
199         class DuplexClientCD1 : DuplexClientBase<IDiscoveryContractAdhocCD1>
200         {
DuplexClientCD1(object callbackInstance, DiscoveryEndpoint discoveryEndpoint)201             public DuplexClientCD1(object callbackInstance, DiscoveryEndpoint discoveryEndpoint)
202                 : base(callbackInstance, discoveryEndpoint)
203             {
204             }
205 
ProbeOperation(ProbeMessageCD1 request)206             public void ProbeOperation(ProbeMessageCD1 request)
207             {
208                 base.Channel.ProbeOperation(request);
209             }
210 
ResolveOperation(ResolveMessageCD1 request)211             public void ResolveOperation(ResolveMessageCD1 request)
212             {
213                 base.Channel.ResolveOperation(request);
214             }
215 
BeginProbeOperation(ProbeMessageCD1 request, AsyncCallback callback, object state)216             public IAsyncResult BeginProbeOperation(ProbeMessageCD1 request, AsyncCallback callback, object state)
217             {
218                 return base.Channel.BeginProbeOperation(request, callback, state);
219             }
220 
BeginResolveOperation(ResolveMessageCD1 request, AsyncCallback callback, object state)221             public IAsyncResult BeginResolveOperation(ResolveMessageCD1 request, AsyncCallback callback, object state)
222             {
223                 return base.Channel.BeginResolveOperation(request, callback, state);
224             }
225 
EndProbeOperation(IAsyncResult result)226             public void EndProbeOperation(IAsyncResult result)
227             {
228                 base.Channel.EndProbeOperation(result);
229             }
230 
EndResolveOperation(IAsyncResult result)231             public void EndResolveOperation(IAsyncResult result)
232             {
233                 base.Channel.EndResolveOperation(result);
234             }
235         }
236     }
237 }
238