When designing a service oriented architecture (SOA) system, there will be a lot of services with many service contracts, endpoints and behaviors. Besides
the client calling
the service, in a large distributed system a service may invoke other services. In this case, one service might need
to know
the endpoints it invokes. This might not be a problem in a small system. But when you have more than 10 services this might be a problem. For example in my current product, there are around 10 services, such as
the user authentication service, UI integration service, location service, license service, device monitor service, event monitor service, schedule job service, accounting service, player management service, etc.. Benefit of Discovery Service Since almost all my services need
to invoke at least one other service. This would be a difficult task
to make sure all services endpoints are configured correctly in every service. And furthermore, it would be a nightmare when a service changed its endpoint at runtime. Hence, we need a discovery service
to remove
the dependency (configuration dependency). A discovery service plays as a service dictionary which stores
the relationship between
the contracts and
the endpoints for every service. By using
the discovery service, when service X wants
to invoke service Y, it just need
to ask
the discovery service where is service Y, then
the discovery service will return all proper endpoints of service Y, then service X can use
the endpoint
to send
the request
to service Y. And when some services changed their endpoint address, all need
to do is
to update its records in
the discovery service then all others will know its new endpoint. In WCF 4.0 Discovery it supports both managed proxy discovery mode and ad-hoc discovery mode. In ad-hoc mode there is no standalone discovery service. When a client wanted
to invoke a service, it will broadcast an message (normally in UDP protocol)
to the entire network with
the service match criteria. All services which enabled
the discovery behavior will receive this message and only those matched services will send their endpoint
back to the client.
The managed proxy discovery service works as I described above. In this post I will only cover
the managed proxy mode, where there’s a discovery service. For more information about
the ad-hoc mode please refer
to the MSDN. Service Announcement and Probe
The main functionality of discovery service should be return
the proper endpoint addresses
back to the service who is looking for. In most cases
the consume service (as a client) will send
the contract which it wanted
to request
to the discovery service. And then
the discovery service will find
the endpoint and respond. Sometimes
the contract and endpoint are not enough. It also contains versioning, extensions attributes. This post I will only cover
the case includes contract and endpoint. When a client (or sometimes a service who need
to invoke another service) need
to connect
to a target service, it will firstly request
the discovery service through
the “Probe” method with
the criteria. Basically
the criteria contains
the contract type name of
the target service. Then
the discovery service will search its endpoint repository by
the criteria.
The repository might be a database, a distributed cache or a flat XML file. If it matches,
the discovery service will grab
the endpoint information (it’s called discovery endpoint metadata in WCF) and send
back. And this is called “Probe”. Finally
the client received
the discovery endpoint metadata and will use
the endpoint
to connect
to the target service. Besides
the probe, discovery service should take
the responsible
to know there is a new service available when it goes online, as well as stopped when it goes offline. This feature is named “Announcement”. When a service started and stopped, it will announce
to the discovery service. So
the basic functionality of a discovery service should includes: 1, An endpoint which receive
the service online message, and add
the service endpoint information in
the discovery repository. 2, An endpoint which receive
the service offline message, and remove
the service endpoint information from
the discovery repository. 3, An endpoint which receive
the client probe message, and return
the matches service endpoints, and return
the discovery endpoint metadata. WCF 4.0 discovery service just covers all these features in it's infrastructure classes. Discovery Service in WCF 4.0 WCF 4.0 introduced a new assembly named System.ServiceModel.Discovery which has all necessary classes and interfaces
to build a WS-Discovery compliant discovery service. It supports ad-hoc and managed proxy modes. For
the case mentioned in this post, what we need
to build is a standalone discovery service, which is
the managed proxy discovery service mode.
To build a managed discovery service in WCF 4.0 just create a new class inherits from
the abstract class System.ServiceModel.Discovery.DiscoveryProxy. This class implemented and abstracted
the procedures of service announcement and probe. And it exposes 8 abstract methods where we can implement our own endpoint register, unregister and find logic. These 8 methods are asynchronized, which means all invokes
to the discovery service are asynchronously, for better service capability and performance. 1, OnBeginOnlineAnnouncement, OnEndOnlineAnnouncement: Invoked when a service sent
the online announcement message. We need
to add
the endpoint information
to the repository in this method. 2, OnBeginOfflineAnnouncement, OnEndOfflineAnnouncement: Invoked when a service sent
the offline announcement message. We need
to remove
the endpoint information from
the repository in this method. 3, OnBeginFind, OnEndFind: Invoked when a client sent
the probe message that want
to find
the service endpoint information. We need
to look for
the proper endpoints by matching
the client’s criteria through
the repository in this method. 4, OnBeginResolve, OnEndResolve: Invoked then a client sent
the resolve message. Different from
the find method, when using resolve method
the discovery service will return
the exactly one service endpoint metadata
to the client. In our example we will NOT implement this method. Let’s create our own discovery service, inherit
the base System.ServiceModel.Discovery.DiscoveryProxy. We also need
to specify
the service behavior in this class. Since
the build-in discovery service host class only support
the singleton mode, we must set its instance context mode
to single. 1: using System;
2: using System.Collections.Generic;
3: using System.Linq;
4: using System.Text;
5: using System.ServiceModel.Discovery;
6: using System.ServiceModel;
7:
8: namespace Phare.Service
9: {
10: [ServiceBehavior(InstanceContextMode = InstanceContextMode.Single, ConcurrencyMode = ConcurrencyMode.Multiple)]
11: public class ManagedProxyDiscoveryService : DiscoveryProxy
12: {
13: protected override IAsyncResult OnBeginFind(FindRequestContext findRequestContext, AsyncCallback callback, object state)
14: {
15: throw new NotImplementedException();
16: }
17:
18: protected override IAsyncResult OnBeginOfflineAnnouncement(DiscoveryMessageSequence messageSequence, EndpointDiscoveryMetadata endpointDiscoveryMetadata, AsyncCallback callback, object state)
19: {
20: throw new NotImplementedException();
21: }
22:
23: protected override IAsyncResult OnBeginOnlineAnnouncement(DiscoveryMessageSequence messageSequence, EndpointDiscoveryMetadata endpointDiscoveryMetadata, AsyncCallback callback, object state)
24: {
25: throw new NotImplementedException();
26: }
27:
28: protected override IAsyncResult OnBeginResolve(ResolveCriteria resolveCriteria, AsyncCallback callback, object state)
29: {
30: throw new NotImplementedException();
31: }
32:
33: protected override void OnEndFind(IAsyncResult result)
34: {
35: throw new NotImplementedException();
36: }
37:
38: protected override void OnEndOfflineAnnouncement(IAsyncResult result)
39: {
40: throw new NotImplementedException();
41: }
42:
43: protected override void OnEndOnlineAnnouncement(IAsyncResult result)
44: {
45: throw new NotImplementedException();
46: }
47:
48: protected override EndpointDiscoveryMetadata OnEndResolve(IAsyncResult result)
49: {
50: throw new NotImplementedException();
51: }
52: }
53: }
Then let’s implement
the online, offline and find methods one by one. WCF discovery service gives us full flexibility
to implement
the endpoint add, remove and find logic. For
the demo purpose we will use an internal dictionary
to store
the services’ endpoint metadata.
In
the next post we will see how
to serialize and store these information in database.
Define a concurrent dictionary inside
the service class since our it will be used in
the multiple threads scenario.
1: [ServiceBehavior(InstanceContextMode = InstanceContextMode.Single, ConcurrencyMode = ConcurrencyMode.Multiple)]
2: public class ManagedProxyDiscoveryService : DiscoveryProxy
3: {
4: private ConcurrentDictionary<EndpointAddress, EndpointDiscoveryMetadata> _services;
5:
6: public ManagedProxyDiscoveryService()
7: {
8: _services = new ConcurrentDictionary<EndpointAddress, EndpointDiscoveryMetadata>();
9: }
10: }
Then we can simply implement
the logic of service online and offline.
1: protected override IAsyncResult OnBeginOnlineAnnouncement(DiscoveryMessageSequence messageSequence, EndpointDiscoveryMetadata endpointDiscoveryMetadata, AsyncCallback callback, object state)
2: {
3: _services.AddOrUpdate(endpointDiscoveryMetadata.Address, endpointDiscoveryMetadata, (key, value) => endpointDiscoveryMetadata);
4: return new OnOnlineAnnouncementAsyncResult(callback, state);
5: }
6:
7: protected override void OnEndOnlineAnnouncement(IAsyncResult result)
8: {
9: OnOnlineAnnouncementAsyncResult.End(result);
10: }
11:
12: protected override IAsyncResult OnBeginOfflineAnnouncement(DiscoveryMessageSequence messageSequence, EndpointDiscoveryMetadata endpointDiscoveryMetadata, AsyncCallback callback, object state)
13: {
14: EndpointDiscoveryMetadata endpoint = null;
15: _services.TryRemove(endpointDiscoveryMetadata.Address, out endpoint);
16: return new OnOfflineAnnouncementAsyncResult(callback, state);
17: }
18:
19: protected override void OnEndOfflineAnnouncement(IAsyncResult result)
20: {
21: OnOfflineAnnouncementAsyncResult.End(result);
22: }
Regards
the find method,
the parameter FindRequestContext.Criteria has a method named IsMatch, which can be use for us
to evaluate which service metadata is satisfied with
the criteria. So
the implementation of find method would be like this.
1: protected override IAsyncResult OnBeginFind(FindRequestContext findRequestContext, AsyncCallback callback, object state)
2: {
3: _services.Where(s => findRequestContext.Criteria.IsMatch(s.Value))
4: .Select(s => s.Value)
5: .All(meta =>
6: {
7: findRequestContext.AddMatchingEndpoint(meta);
8: return true;
9: });
10: return new OnFindAsyncResult(callback, state);
11: }
12:
13: protected override void OnEndFind(IAsyncResult result)
14: {
15: OnFindAsyncResult.End(result);
16: }
As you can see, we checked all endpoints metadata in repository by invoking
the IsMatch method. Then add all proper endpoints metadata into
the parameter.
Finally since all these methods are asynchronized we need some AsyncResult classes as well. Below are
the base class and
the inherited classes used in previous methods.
1: using System;
2: using System.Collections.Generic;
3: using System.Linq;
4: using System.Text;
5: using System.Threading;
6:
7: namespace Phare.Service
8: {
9: abstract internal class AsyncResult : IAsyncResult
10: {
11: AsyncCallback callback;
12: bool completedSynchronously;
13: bool endCalled;
14: Exception exception;
15: bool isCompleted;
16: ManualResetEvent manualResetEvent;
17: object state;
18: object thisLock;
19:
20: protected AsyncResult(AsyncCallback callback, object state)
21: {
22: this.callback = callback;
23: this.state = state;
24: this.thisLock = new object();
25: }
26:
27: public object AsyncState
28: {
29: get
30: {
31: return state;
32: }
33: }
34:
35: public WaitHandle AsyncWaitHandle
36: {
37: get
38: {
39: if (manualResetEvent != null)
40: {
41: return manualResetEvent;
42: }
43: lock (ThisLock)
44: {
45: if (manualResetEvent == null)
46: {
47: manualResetEvent = new ManualResetEvent(isCompleted);
48: }
49: }
50: return manualResetEvent;
51: }
52: }
53:
54: public bool CompletedSynchronously
55: {
56: get
57: {
58: return completedSynchronously;
59: }
60: }
61:
62: public bool IsCompleted
63: {
64: get
65: {
66: return isCompleted;
67: }
68: }
69:
70: object ThisLock
71: {
72: get
73: {
74: return this.thisLock;
75: }
76: }
77:
78: protected static TAsyncResult End<TAsyncResult>(IAsyncResult result)
79: where TAsyncResult : AsyncResult
80: {
81: if (result == null)
82: {
83: throw new ArgumentNullException("result");
84: }
85:
86: TAsyncResult asyncResult = result as TAsyncResult;
87:
88: if (asyncResult == null)
89: {
90: throw new ArgumentException("Invalid async result.", "result");
91: }
92:
93: if (asyncResult.endCalled)
94: {
95: throw new InvalidOperationException("Async object already ended.");
96: }
97:
98: asyncResult.endCalled = true;
99:
100: if (!asyncResult.isCompleted)
101: {
102: asyncResult.AsyncWaitHandle.WaitOne();
103: }
104:
105: if (asyncResult.manualResetEvent != null)
106: {
107: asyncResult.manualResetEvent.Close();
108: }
109:
110: if (asyncResult.exception != null)
111: {
112: throw asyncResult.exception;
113: }
114:
115: return asyncResult;
116: }
117:
118: protected void Complete(bool completedSynchronously)
119: {
120: if (isCompleted)
121: {
122: throw new InvalidOperationException("This async result is already completed.");
123: }
124:
125: this.completedSynchronously = completedSynchronously;
126:
127: if (completedSynchronously)
128: {
129: this.isCompleted = true;
130: }
131: else
132: {
133: lock (ThisLock)
134: {
135: this.isCompleted = true;
136: if (this.manualResetEvent != null)
137: {
138: this.manualResetEvent.Set();
139: }
140: }
141: }
142:
143: if (callback != null)
144: {
145: callback(this);
146: }
147: }
148:
149: protected void Complete(bool completedSynchronously, Exception exception)
150: {
151: this.exception = exception;
152: Complete(completedSynchronously);
153: }
154: }
155: }
1: using System;
2: using System.Collections.Generic;
3: using System.Linq;
4: using System.Text;
5: using System.ServiceModel.Discovery;
6: using Phare.Service;
7:
8: namespace Phare.Service
9: {
10: internal sealed class OnOnlineAnnouncementAsyncResult : AsyncResult
11: {
12: public OnOnlineAnnouncementAsyncResult(AsyncCallback callback, object state)
13: : base(callback, state)
14: {
15: this.Complete(true);
16: }
17:
18: public static void End(IAsyncResult result)
19: {
20: AsyncResult.End<OnOnlineAnnouncementAsyncResult>(result);
21: }
22:
23: }
24:
25: sealed class OnOfflineAnnouncementAsyncResult : AsyncResult
26: {
27: public OnOfflineAnnouncementAsyncResult(AsyncCallback callback, object state)
28: : base(callback, state)
29: {
30: this.Complete(true);
31: }
32:
33: public static void End(IAsyncResult result)
34: {
35: AsyncResult.End<OnOfflineAnnouncementAsyncResult>(result);
36: }
37: }
38:
39: sealed class OnFindAsyncResult : AsyncResult
40: {
41: public OnFindAsyncResult(AsyncCallback callback, object state)
42: : base(callback, state)
43: {
44: this.Complete(true);
45: }
46:
47: public static void End(IAsyncResult result)
48: {
49: AsyncResult.End<OnFindAsyncResult>(result);
50: }
51: }
52:
53: sealed class OnResolveAsyncResult : AsyncResult
54: {
55: EndpointDiscoveryMetadata matchingEndpoint;
56:
57: public OnResolveAsyncResult(EndpointDiscoveryMetadata matchingEndpoint, AsyncCallback callback, object state)
58: : base(callback, state)
59: {
60: this.matchingEndpoint = matchingEndpoint;
61: this.Complete(true);
62: }
63:
64: public static EndpointDiscoveryMetadata End(IAsyncResult result)
65: {
66: OnResolveAsyncResult thisPtr = AsyncResult.End<OnResolveAsyncResult>(result);
67: return thisPtr.matchingEndpoint;
68: }
69: }
70: }
Now we have finished
the discovery service.
The next step is
to host it.
The discovery service is a standard WCF service. So we can use ServiceHost on a console application, windows service, or in IIS as usual.
The following code is how
to host
the discovery service we had just created in a console application.
1: static void Main(string[] args)
2: {
3: using (var host = new ServiceHost(new ManagedProxyDiscoveryService()))
4: {
5: host.Opened += (sender, e) =>
6: {
7: host.Description.Endpoints.All((ep) =>
8: {
9: Console.WriteLine(ep.ListenUri);
10: return true;
11: });
12: };
13:
14: try
15: {
16: // retrieve
the announcement, probe endpoint and binding from configuration
17: var announcementEndpointAddress = new EndpointAddress(ConfigurationManager.AppSettings["announcementEndpointAddress"]);
18: var probeEndpointAddress = new EndpointAddress(ConfigurationManager.AppSettings["probeEndpointAddress"]);
19: var binding = Activator.CreateInstance(Type.GetType(ConfigurationManager.AppSettings["bindingType"], true, true)) as Binding;
20: var announcementEndpoint = new AnnouncementEndpoint(binding, announcementEndpointAddress);
21: var probeEndpoint = new DiscoveryEndpoint(binding, probeEndpointAddress);
22: probeEndpoint.IsSystemEndpoint = false;
23: // append
the service endpoint for announcement and probe
24: host.AddServiceEndpoint(announcementEndpoint);
25: host.AddServiceEndpoint(probeEndpoint);
26:
27: host.Open();
28:
29: Console.WriteLine("Press any key
to exit.");
30: Console.ReadKey();
31: }
32: catch (Exception ex)
33: {
34: Console.WriteLine(ex.ToString());
35: }
36: }
37:
38: Console.WriteLine("Done.");
39: Console.ReadKey();
40: }
What we need
to notice is that,
the discovery service needs two endpoints for announcement and probe. In this example I just retrieve them from
the configuration file. I also specified
the binding of these two endpoints in configuration file as well.
1: <?xml version="1.0"?>
2: <configuration>
3: <startup>
4: <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0"/>
5: </startup>
6: <appSettings>
7: <add key="announcementEndpointAddress" value="net.tcp://localhost:10010/announcement"/>
8: <add key="probeEndpointAddress" value="net.tcp://localhost:10011/probe"/>
9: <add key="bindingType" value="System.ServiceModel.NetTcpBinding, System.ServiceModel, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"/>
10: </appSettings>
11: </configuration>
And this is
the console screen when I ran my discovery service. As you can see there are two endpoints listening for announcement message and probe message.
Discoverable Service and Client
Next, let’s create a WCF service that is discoverable, which means it can be found by
the discovery service.
To do so, we need
to let
the service send
the online announcement message
to the discovery service, as well as offline message before it shutdown.
Just create a simple service which can make
the incoming string
to upper.
The service contract and implementation would be like this.
1: [ServiceContract]
2: public interface IStringService
3: {
4: [OperationContract]
5: string ToUpper(string content);
6: }
1: public class StringService : IStringService
2: {
3: public string ToUpper(string content)
4: {
5: return content.ToUpper();
6: }
7: }
Then host this service in
the console application. In order
to make
the discovery service easy
to be tested
the service address will be changed each time it’s started.
1: static void Main(string[] args)
2: {
3: var baseAddress = new Uri(string.Format("net.tcp://localhost:11001/stringservice/{0}/", Guid.NewGuid().ToString()));
4:
5: using (var host = new ServiceHost(typeof(StringService), baseAddress))
6: {
7: host.Opened += (sender, e) =>
8: {
9: Console.WriteLine("Service opened at {0}", host.Description.Endpoints.First().ListenUri);
10: };
11:
12: host.AddServiceEndpoint(typeof(IStringService), new NetTcpBinding(), string.Empty);
13:
14: host.Open();
15:
16: Console.WriteLine("Press any key
to exit.");
17: Console.ReadKey();
18: }
19: }
Currently this service is NOT discoverable. We need
to add a special service behavior so that it could send
the online and offline message
to the discovery service announcement endpoint when
the host is opened and closed. WCF 4.0 introduced a service behavior named ServiceDiscoveryBehavior. When we specified
the announcement endpoint address and appended it
to the service behaviors this service will be discoverable.
1: var announcementAddress = new EndpointAddress(ConfigurationManager.AppSettings["announcementEndpointAddress"]);
2: var announcementBinding = Activator.CreateInstance(Type.GetType(ConfigurationManager.AppSettings["bindingType"], true, true)) as Binding;
3: var announcementEndpoint = new AnnouncementEndpoint(announcementBinding, announcementAddress);
4: var discoveryBehavior = new ServiceDiscoveryBehavior();
5: discoveryBehavior.AnnouncementEndpoints.Add(announcementEndpoint);
6: host.Description.Behaviors.Add(discoveryBehavior);
The ServiceDiscoveryBehavior utilizes
the service extension and channel dispatcher
to implement
the online and offline announcement logic. In short, it injected
the channel open and close procedure and send
the online and offline message
to the announcement endpoint.
On client side, when we have
the discovery service, a client can invoke a service without knowing its endpoint. WCF discovery assembly provides a class named DiscoveryClient, which can be used
to find
the proper service endpoint by passing
the criteria.
In
the code below I initialized
the DiscoveryClient, specified
the discovery service probe endpoint address. Then I created
the find criteria by specifying
the service contract I wanted
to use and invoke
the Find method. This will send
the probe message
to the discovery service and it will find
the endpoints
back to me.
The discovery service will return all endpoints that matches
the find criteria, which means in
the result of
the find method there might be more than one endpoints. In this example I just returned
the first matched one
back. In
the next post I will show how
to extend our discovery service
to make it work like a service load balancer.
1: static EndpointAddress FindServiceEndpoint()
2: {
3: var probeEndpointAddress = new EndpointAddress(ConfigurationManager.AppSettings["probeEndpointAddress"]);
4: var probeBinding = Activator.CreateInstance(Type.GetType(ConfigurationManager.AppSettings["bindingType"], true, true)) as Binding;
5: var discoveryEndpoint = new DiscoveryEndpoint(probeBinding, probeEndpointAddress);
6:
7: EndpointAddress address = null;
8: FindResponse result = null;
9: using (var discoveryClient = new DiscoveryClient(discoveryEndpoint))
10: {
11: result = discoveryClient.Find(new FindCriteria(typeof(IStringService)));
12: }
13:
14: if (result != null && result.Endpoints.Any())
15: {
16: var endpointMetadata = result.Endpoints.First();
17: address = endpointMetadata.Address;
18: }
19: return address;
20: }
Once we probed
the discovery service we will receive
the endpoint. So in
the client code we can created
the channel factory from
the endpoint and binding, and invoke
to the service.
When creating
the client side channel factory we need
to make sure that
the client side binding should be
the same as
the service side. WCF discovery service can be used
to find
the endpoint for a service contract, but
the binding is NOT included. This is because
the binding was not in
the WS-Discovery specification.
In
the next post I will demonstrate how
to add
the binding information into
the discovery service. At that moment
the client don’t need
to create
the binding by itself. Instead it will use
the binding received from
the discovery service.
1: static void Main(string[] args)
2: {
3: Console.WriteLine("Say something...");
4: var content = Console.ReadLine();
5: while (!string.IsNullOrWhiteSpace(content))
6: {
7: Console.WriteLine("Finding
the service endpoint...");
8: var address = FindServiceEndpoint();
9: if (address == null)
10: {
11: Console.WriteLine("There is no endpoint matches
the criteria.");
12: }
13: else
14: {
15: Console.WriteLine("Found
the endpoint {0}", address.Uri);
16:
17: var factory = new ChannelFactory<IStringService>(new NetTcpBinding(), address);
18: factory.Opened += (sender, e) =>
19: {
20: Console.WriteLine("Connecting
to {0}.", factory.Endpoint.ListenUri);
21: };
22: var proxy = factory.CreateChannel();
23: using (proxy as IDisposable)
24: {
25: Console.WriteLine("ToUpper: {0} => {1}", content, proxy.ToUpper(content));
26: }
27: }
28:
29: Console.WriteLine("Say something...");
30: content = Console.ReadLine();
31: }
32: }
Similarly,
the discovery service probe endpoint and binding were defined in
the configuration file.
1: <?xml version="1.0"?>
2: <configuration>
3: <startup>
4: <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0"/>
5: </startup>
6: <appSettings>
7: <add key="announcementEndpointAddress" value="net.tcp://localhost:10010/announcement"/>
8: <add key="probeEndpointAddress" value="net.tcp://localhost:10011/probe"/>
9: <add key="bindingType" value="System.ServiceModel.NetTcpBinding, System.ServiceModel, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"/>
10: </appSettings>
11: </configuration>
OK, now let’s have a test. Firstly start
the discovery service, and then start our discoverable service. When it started it will announced
to the discovery service and registered its endpoint into
the repository, which is
the local dictionary. And then start
the client and type something. As you can see
the client asked
the discovery service for
the endpoint and then establish
the connection
to the discoverable service.
And more interesting, do NOT close
the client console but terminate
the discoverable service but press
the enter key. This will make
the service send
the offline message
to the discovery service. Then start
the discoverable service again. Since we made it use a different address each time it started, currently it should be hosted on another address. If we enter something in
the client we could see that it asked
the discovery service and retrieve
the new endpoint, and connect
the the service.
Summary
In this post I discussed
the benefit of using
the discovery service and
the procedures of service announcement and probe. I also demonstrated how
to leverage
the WCF Discovery feature in WCF 4.0
to build a simple managed discovery service.
For test purpose, in this example I used
the in memory dictionary as
the discovery endpoint metadata repository. And when finding I also just return
the first matched endpoint
back. I also hard coded
the bindings between
the discoverable service and
the client.
In next post I will show you how
to solve
the problem mentioned above, as well as some additional feature for production usage.
You can download
the code here.
Hope this helps,
Shaun
All documents and related graphics, codes are provided "AS IS" without warranty of any kind.
Copyright © Shaun Ziyan Xu. This work is licensed under
the Creative Commons License.
