static void Main(string[] args)
{
IPHostEntry entry = Dns.GetHostEntry("");
string addr = "localhost";
for (int i = 0; i < entry.AddressList.Length; i++)
{
if (entry.AddressList[i].AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
{
addr = entry.AddressList[i].ToString();
break;
}
}
Uri baseAddress = new Uri("http://" + addr + ":8084/319D0A4D-2253-47DC-AC4A-C1951FF6667D");
ServiceHost serviceHost = new ServiceHost(typeof(ServiceHelloWCF), baseAddress);
try
{
ServiceEndpoint wsEndpoint = serviceHost.AddServiceEndpoint(typeof(IServiceHelloWCF), new WSHttpBinding(SecurityMode.None), string.Empty);
EndpointDiscoveryBehavior endpointDiscoveryBehavior = new EndpointDiscoveryBehavior();
// Add the discovery behavior to the endpoint.
wsEndpoint.Behaviors.Add(endpointDiscoveryBehavior);
// Make the service discoverable over UDP multicast
serviceHost.Description.Behaviors.Add(new ServiceDiscoveryBehavior());
serviceHost.AddServiceEndpoint(new UdpDiscoveryEndpoint(DiscoveryVersion.WSDiscovery11));
ServiceMetadataBehavior smb = new ServiceMetadataBehavior();
smb.HttpGetEnabled = true;
smb.HttpGetUrl = baseAddress;
serviceHost.Description.Behaviors.Add(smb);
serviceHost.Open();
Console.WriteLine("Hello World WCF Service started at {0}", baseAddress);
Console.WriteLine();
Console.WriteLine("Press <ENTER> to terminate the service.");
Console.WriteLine();
Console.ReadLine();
serviceHost.Close();
}
catch (CommunicationException e)
{
Console.WriteLine(e.Message);
}
catch (TimeoutException e)
{
Console.WriteLine(e.Message);
}
if (serviceHost.State != CommunicationState.Closed)
{
Console.WriteLine("Aborting service...");
serviceHost.Abort();
}
}
protected override void Opening(ServiceHost serviceHost)
{
var serviceDiscovery = serviceHost.Description.Behaviors.Find<ServiceDiscoveryBehavior>();
if (serviceDiscovery == null)
{
serviceHost.Description.Behaviors.Add(new ServiceDiscoveryBehavior());
}
foreach (var endpoint in serviceHost.Description.NonSystemEndpoints())
{
var discovery = endpoint.Behaviors.Find<EndpointDiscoveryBehavior>();
if (discovery == null)
{
discovery = new EndpointDiscoveryBehavior();
endpoint.Behaviors.Add(discovery);
}
discovery.Scopes.AddAll(scopes);
discovery.Extensions.AddAll(metadata);
AddAdditionalMetadata(serviceHost, discovery);
if (strict == false)
{
ExportMetadata(endpoint, discovery);
}
}
AddDiscoveryEndpoint(serviceHost);
}
/// <summary>
/// Starts the module for the given host.
/// </summary>
/// <param name="host">The host.</param>
public void Start(AgentHost host)
{
discoveryBehavior = host.Endpoint.Behaviors.Find<EndpointDiscoveryBehavior>();
if (discoveryBehavior == null)
{
discoveryBehavior = new EndpointDiscoveryBehavior();
host.Endpoint.Behaviors.Add(discoveryBehavior);
}
discoveryBehavior.Scopes.Add(scope);
host.TestRunnerHost.Description.Behaviors.Add(new ServiceDiscoveryBehavior());
host.TestRunnerHost.AddServiceEndpoint(new UdpDiscoveryEndpoint());
host.TestRunner.CommunicationStarted += (sender, args) =>
{
lock (this)
{
counter++;
discoveryBehavior.Enabled = false;
}
};
host.TestRunner.CommunicationFinished += (sender, args) =>
{
lock (this)
{
counter--;
if (counter == 0)
discoveryBehavior.Enabled = true;
}
};
}
public static void Main()
{
Uri baseAddress = new Uri("http://localhost:8000/" + Guid.NewGuid().ToString());
ServiceHost serviceHost = new ServiceHost(typeof(CalculatorService), baseAddress);
try
{
// Add an endpoint to the service
ServiceEndpoint discoverableCalculatorEndpoint = serviceHost.AddServiceEndpoint(
typeof(ICalculatorService),
new WSHttpBinding(),
"/DiscoverableEndpoint");
// Add a Scope to the endpoint
EndpointDiscoveryBehavior discoverableEndpointBehavior = new EndpointDiscoveryBehavior();
discoverableEndpointBehavior.Scopes.Add(new Uri("ldap:///ou=engineering,o=exampleorg,c=us"));
discoverableCalculatorEndpoint.Behaviors.Add(discoverableEndpointBehavior);
// Add an endpoint to the service
ServiceEndpoint nonDiscoverableCalculatorEndpoint = serviceHost.AddServiceEndpoint
(typeof(ICalculatorService),
new WSHttpBinding(),
"/NonDiscoverableEndpoint");
// Disable discoverability of the endpoint
EndpointDiscoveryBehavior nonDiscoverableEndpointBehavior = new EndpointDiscoveryBehavior();
nonDiscoverableEndpointBehavior.Scopes.Add(new Uri("ldap:///ou=engineering,o=exampleorg,c=us"));
nonDiscoverableEndpointBehavior.Enabled = false;
nonDiscoverableCalculatorEndpoint.Behaviors.Add(nonDiscoverableEndpointBehavior);
// Make the service discoverable over UDP multicast
serviceHost.Description.Behaviors.Add(new ServiceDiscoveryBehavior());
serviceHost.AddServiceEndpoint(new UdpDiscoveryEndpoint());
serviceHost.Open();
Console.WriteLine("Calculator Service started at {0}", baseAddress);
Console.WriteLine();
Console.WriteLine("Press <ENTER> to terminate the service.");
Console.WriteLine();
Console.ReadLine();
serviceHost.Close();
}
catch (CommunicationException e)
{
Console.WriteLine(e.Message);
}
catch (TimeoutException e)
{
Console.WriteLine(e.Message);
}
if (serviceHost.State != CommunicationState.Closed)
{
Console.WriteLine("Aborting the service...");
serviceHost.Abort();
}
}
static EndpointDiscoveryMetadata GetEndpointDiscoveryMetadata(ServiceEndpoint endpoint, Uri listenUri)
{
EndpointDiscoveryMetadata endpointDiscoveryMetadata = new EndpointDiscoveryMetadata();
endpointDiscoveryMetadata.Address = endpoint.Address;
endpointDiscoveryMetadata.ListenUris.Add(listenUri);
EndpointDiscoveryBehavior endpointDiscoveryBehavior = endpoint.Behaviors.Find <EndpointDiscoveryBehavior>();
if (endpointDiscoveryBehavior != null)
{
if (!endpointDiscoveryBehavior.Enabled)
{
if (TD.EndpointDiscoverabilityDisabledIsEnabled())
{
TD.EndpointDiscoverabilityDisabled(endpoint.Address.ToString(), listenUri.ToString());
}
return(null);
}
if (TD.EndpointDiscoverabilityEnabledIsEnabled())
{
TD.EndpointDiscoverabilityEnabled(endpoint.Address.ToString(), listenUri.ToString());
}
if (endpointDiscoveryBehavior.InternalContractTypeNames != null)
{
foreach (XmlQualifiedName contractTypeName in endpointDiscoveryBehavior.InternalContractTypeNames)
{
endpointDiscoveryMetadata.ContractTypeNames.Add(contractTypeName);
}
}
if (endpointDiscoveryBehavior.InternalScopes != null)
{
foreach (Uri scope in endpointDiscoveryBehavior.InternalScopes)
{
endpointDiscoveryMetadata.Scopes.Add(scope);
}
}
if (endpointDiscoveryBehavior.InternalExtensions != null)
{
foreach (XElement xElement in endpointDiscoveryBehavior.InternalExtensions)
{
endpointDiscoveryMetadata.Extensions.Add(xElement);
}
}
}
XmlQualifiedName defaultContractTypeName = new XmlQualifiedName(endpoint.Contract.Name, endpoint.Contract.Namespace);
if (!endpointDiscoveryMetadata.ContractTypeNames.Contains(defaultContractTypeName))
{
endpointDiscoveryMetadata.ContractTypeNames.Add(defaultContractTypeName);
}
return(endpointDiscoveryMetadata);
}
public static void Main()
{
Uri baseAddress = new Uri("net.tcp://localhost:8000/" + Guid.NewGuid().ToString());
ServiceHost serviceHost = new ServiceHost(typeof(CalculatorService), baseAddress);
try
{
ServiceEndpoint netTcpEndpoint = serviceHost.AddServiceEndpoint(typeof(ICalculatorService), new NetTcpBinding(), string.Empty);
EndpointDiscoveryBehavior endpointDiscoveryBehavior = new EndpointDiscoveryBehavior();
// Create XML metadata to add to the service endpoint
XElement endpointMetadata = new XElement(
"Root",
new XElement("Information", "This endpoint is for a service of type: ICalculatorService."),
new XElement("Time", System.DateTime.Now.ToString("MM/dd/yyyy HH:mm")));
// Add the XML metadata to the endpoint discovery behavior.
endpointDiscoveryBehavior.Extensions.Add(endpointMetadata);
// Add the discovery behavior to the endpoint.
netTcpEndpoint.Behaviors.Add(endpointDiscoveryBehavior);
// Make the service discoverable over UDP multicast
serviceHost.Description.Behaviors.Add(new ServiceDiscoveryBehavior());
serviceHost.AddServiceEndpoint(new UdpDiscoveryEndpoint());
serviceHost.Open();
Console.WriteLine("Calculator Service started at {0}", baseAddress);
Console.WriteLine();
Console.WriteLine("Added the following metadata to the endpoint: \n{0}", endpointMetadata);
Console.WriteLine("Press <ENTER> to terminate the service.");
Console.WriteLine();
Console.ReadLine();
serviceHost.Close();
}
catch (CommunicationException e)
{
Console.WriteLine(e.Message);
}
catch (TimeoutException e)
{
Console.WriteLine(e.Message);
}
if (serviceHost.State != CommunicationState.Closed)
{
Console.WriteLine("Aborting service...");
serviceHost.Abort();
}
}
public static void Main()
{
Uri baseAddress = new Uri("net.tcp://localhost:8000/CalculatorSvc/");
Uri redmondScope = new Uri("net.tcp://Microsoft.Samples.Discovery/RedmondLocation");
ServiceHost serviceHost = new ServiceHost(typeof(CalculatorService), baseAddress);
try
{
ServiceEndpoint tcpEndpoint = serviceHost.AddServiceEndpoint(typeof(ICalculatorService), new NetTcpBinding(), "TCPEndpoint");
// Add a scope
EndpointDiscoveryBehavior tcpEndpointBehavior = new EndpointDiscoveryBehavior();
tcpEndpointBehavior.Scopes.Add(redmondScope);
tcpEndpoint.Behaviors.Add(tcpEndpointBehavior);
// Make the service discoverable
serviceHost.Description.Behaviors.Add(new ServiceDiscoveryBehavior());
// Listen for discovery messages over UDP multicast
serviceHost.AddServiceEndpoint(new UdpDiscoveryEndpoint());
// Hook up a custom discovery service implementation through extensions
serviceHost.Extensions.Add(new CustomDiscoveryExtension());
serviceHost.Open();
Console.WriteLine("Calculator Service started at: \n {0}", baseAddress);
Console.WriteLine("Endpoint is decorated with the following scope: \n {0}", redmondScope);
Console.WriteLine();
Console.WriteLine("Press <ENTER> to terminate the service.");
Console.WriteLine();
Console.ReadLine();
serviceHost.Close();
}
catch (CommunicationException e)
{
Console.WriteLine(e.Message);
}
catch (TimeoutException e)
{
Console.WriteLine(e.Message);
}
if (serviceHost.State != CommunicationState.Closed)
{
Console.WriteLine("Aborting the service...");
serviceHost.Abort();
}
}
public void Use2 ()
{
// This time with ServiceDiscoveryBehavior.
var b = new EndpointDiscoveryBehavior ();
IEndpointBehavior eb = b;
var host = new ServiceHost (typeof (TestService));
var se = host.AddServiceEndpoint (typeof (ITestService), new BasicHttpBinding (), new Uri ("http://localhost:37564"));
var sdb = new ServiceDiscoveryBehavior ();
sdb.AnnouncementEndpoints.Add (new UdpAnnouncementEndpoint ());
IServiceBehavior sb = sdb;
se.Behaviors.Add (b);
var bc = new BindingParameterCollection ();
sb.AddBindingParameters (host.Description, host, host.Description.Endpoints, bc);
eb.AddBindingParameters (se, bc);
Assert.AreEqual (0, bc.Count, "#1");
Assert.AreEqual (0, host.Extensions.Count, "#1-2");
sb.Validate (host.Description, host);
eb.Validate (se);
// ... should "validate" not "apply dispatch behavior" do "add host extension" job? I doubt that.
Assert.AreEqual (1, host.Extensions.Count, "#2-2");
var dse = host.Extensions.Find<DiscoveryServiceExtension> ();
Assert.IsNotNull (dse, "#2-3");
Assert.AreEqual (0, dse.PublishedEndpoints.Count, "#2-4");
Assert.AreEqual (2, se.Behaviors.Count, "#2-5"); // EndpointDiscoveryBehavior + discovery initializer.
Assert.AreEqual (0, host.ChannelDispatchers.Count, "#3-1");
Assert.AreEqual (1, host.Description.Endpoints.Count, "#3-2");
Assert.AreEqual (0, dse.PublishedEndpoints.Count, "#3-4");
// The IEndpointBehavior from EndpointDiscoveryBehavior, when ApplyDispatchBehavior() is invoked, publishes an endpoint.
sb.ApplyDispatchBehavior (host.Description, host);
Assert.AreEqual (0, dse.PublishedEndpoints.Count, "#3-5"); // not yet published
eb.ApplyDispatchBehavior (se, new EndpointDispatcher (new EndpointAddress ("http://localhost:37564"), "ITestService", "http://tempuri.org/"));
Assert.AreEqual (2, host.ChannelDispatchers.Count, "#3-6-1"); // for online and offline announcements
Assert.AreEqual (0, dse.PublishedEndpoints.Count, "#3-6-2"); // still not published.
host.Open ();
try {
Assert.AreEqual (3, host.ChannelDispatchers.Count, "#4-1"); // for online and offline announcements
Assert.AreEqual (1, dse.PublishedEndpoints.Count, "#4-2"); // The endpoint is published again. (Not sure if it's worthy of testing.)
} finally {
host.Close ();
}
}
public void Use ()
{
// Without ServiceDiscoveryBehavior.
var b = new EndpointDiscoveryBehavior ();
IEndpointBehavior eb = b;
var host = new ServiceHost (typeof (TestService));
var se = host.AddServiceEndpoint (typeof (ITestService), new BasicHttpBinding (), new Uri ("http://localhost:37564"));
se.Behaviors.Add (b);
var bc = new BindingParameterCollection ();
eb.AddBindingParameters (se, bc);
Assert.AreEqual (0, bc.Count, "#1");
Assert.AreEqual (0, host.Extensions.Count, "#1-2");
eb.Validate (se);
// This behavior itself does not populate discovery extension. It just configures the extension.
Assert.AreEqual (0, host.Extensions.Count, "#2-2");
}
public static void Main()
{
Uri baseAddress = new Uri("net.tcp://localhost:5555/CalculatorService/" + Guid.NewGuid().ToString());
ServiceHost serviceHost = new ServiceHost(typeof(CalculatorService), baseAddress);
try
{
ServiceEndpoint netTcpEndpoint = serviceHost.AddServiceEndpoint(typeof(ICalculatorService), new NetTcpBinding(), string.Empty);
// Add a scope to the endpoint
EndpointDiscoveryBehavior netTcpEndpointBehavior = new EndpointDiscoveryBehavior();
netTcpEndpointBehavior.Scopes.Add(new Uri("ldap:///ou=engineering,o=exampleorg,c=us"));
netTcpEndpoint.Behaviors.Add(netTcpEndpointBehavior);
// Service discovery is enabled through configuration
serviceHost.Open();
Console.WriteLine("Calculator Service started at: \n {0}", baseAddress);
Console.WriteLine();
Console.WriteLine("Press <ENTER> to terminate the service.");
Console.WriteLine();
Console.ReadLine();
serviceHost.Close();
}
catch (CommunicationException e)
{
Console.WriteLine(e.Message);
}
catch (TimeoutException e)
{
Console.WriteLine(e.Message);
}
if (serviceHost.State != CommunicationState.Closed)
{
Console.WriteLine("Aborting the service...");
serviceHost.Abort();
}
}
/// <summary>
/// Start new broadcast service
/// </summary>
/// <param name="type">Type of discovery</param>
/// <param name="nameToBroadcast">The name of the service that needs to be broadcasted</param>
/// <param name="physicalLocation">The physical location of the service that needs to be broadcasted</param>
/// <param name="code">code to be broadcasted (e.g. device id)</param>
/// <param name="addressToBroadcast">The address of the service that needs to be broadcasted</param>
public void Start( DiscoveryType type, string nameToBroadcast, string physicalLocation, string code, Uri addressToBroadcast)
{
DiscoveryType = type;
switch ( DiscoveryType )
{
case DiscoveryType.WsDiscovery:
{
Ip = Net.GetIp( IpType.All );
Port = 7985;
Address = "http://" + Ip + ":" + Port + "/";
_discoveryHost = new ServiceHost( new DiscoveyService() );
var serviceEndpoint = _discoveryHost.AddServiceEndpoint( typeof( IDiscovery ), new WebHttpBinding(),
Net.GetUrl( Ip, Port, "" ) );
serviceEndpoint.Behaviors.Add( new WebHttpBehavior() );
var broadcaster = new EndpointDiscoveryBehavior();
broadcaster.Extensions.Add( nameToBroadcast.ToXElement<string>() );
broadcaster.Extensions.Add( physicalLocation.ToXElement<string>() );
broadcaster.Extensions.Add( addressToBroadcast.ToString().ToXElement<string>() );
broadcaster.Extensions.Add( code.ToXElement<string>() );
serviceEndpoint.Behaviors.Add( broadcaster );
_discoveryHost.Description.Behaviors.Add( new ServiceDiscoveryBehavior() );
_discoveryHost.Description.Endpoints.Add( new UdpDiscoveryEndpoint() );
_discoveryHost.Open();
IsRunning = true;
Debug.WriteLine( DiscoveryType.ToString() + " is started" );
}
break;
case DiscoveryType.Zeroconf:
{
_service = new RegisterService { Name = nameToBroadcast, RegType = "_am._tcp", ReplyDomain = "local", Port = 3689 };
// TxtRecords are optional
var txtRecord = new TxtRecord
{
{ "name", nameToBroadcast },
{ "addr", addressToBroadcast.ToString() },
{ "loc", physicalLocation },
{ "code", code }
};
_service.TxtRecord = txtRecord;
_service.Response += service_Response;
_service.Register();
Debug.WriteLine(DiscoveryType.ToString() + " is started");
}
break;
}
}
public void ApplyDispatchBehavior(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase)
{
var disServiceEndpoints = new List<PluginContext.DiscoverableServiceEndpoint>();
// apply the service discovery behavior opertaion
_serviceDiscoveryBehavior.ApplyDispatchBehavior(serviceDescription, serviceHostBase);
// add the additional information into the endpoint metadata extension through the endpoint discovery binding for each endpoints
foreach (var endpoint in serviceDescription.Endpoints)
{
var endpointDiscoveryBehavior = new EndpointDiscoveryBehavior();
// check if the contract or endpoint should be ignored
// set the extensions
endpoint.SetExtensions(endpointDiscoveryBehavior, behavior => behavior.Extensions, _ignoredContractTypeNames, _ignoredEndpoints);
endpoint.Behaviors.Add(endpointDiscoveryBehavior);
// save the plugin context
disServiceEndpoints.Add(new PluginContext.DiscoverableServiceEndpoint(endpoint, endpointDiscoveryBehavior.Extensions));
}
// invoke the plugins
var context = new PluginContext(disServiceEndpoints, _announcementEndpoint);
foreach (var plugin in _plugins)
{
plugin.Apply(context);
}
}
public void Open(string announcementConnectionUri, int announcementTimerSec, bool enableAnnouncement)
{
try
{
ServiceDiscoveryBehavior serviceDiscoveryBehavior = new ServiceDiscoveryBehavior();
EndpointDiscoveryBehavior endpointDiscoveryBehavior = new EndpointDiscoveryBehavior();
XElement endpointMetadata = new XElement("Root", new XElement(_metaDataElement, _metaDataElementValue));
XElement aliasMetadata = new XElement("Root", new XElement(_metaDataAlias, _metaDataAliasValue));
XElement LoginMetadata = new XElement("Root", new XElement(_metaDataLogIn, _metaDataLogInValue));
endpointDiscoveryBehavior.Extensions.Add(endpointMetadata);
endpointDiscoveryBehavior.Extensions.Add(aliasMetadata);
endpointDiscoveryBehavior.Extensions.Add(LoginMetadata);
_netTcpEndpoint.Behaviors.Add(endpointDiscoveryBehavior);
_serviceHost.Description.Behaviors.Add(serviceDiscoveryBehavior);
_serviceHost.AddServiceEndpoint(new UdpDiscoveryEndpoint());
_serviceHost.Open();
if (enableAnnouncement)
{
Uri announcementEndpointUri = new Uri(announcementConnectionUri);
EndpointAddress announcementEndpointAddress = new EndpointAddress(announcementEndpointUri);
NetTcpBinding binding = new NetTcpBinding();
binding.Security.Mode = SecurityMode.None;
_announcementEndpoint = new AnnouncementEndpoint(binding, announcementEndpointAddress);
_announcementClient = new AnnouncementClient(_announcementEndpoint);
_endpointDiscoveryMetadata = EndpointDiscoveryMetadata.FromServiceEndpoint(_netTcpEndpoint);
//Start a timer that send announcement message
_announcementTimer = new Timer(announcementTimerSec * 1000);
_announcementTimer.AutoReset = true;
_announcementTimer.Elapsed += new ElapsedEventHandler(_announcementTimer_Elapsed);
_announcementTimer.Start();
_announcementClient.Open();
}
IsRunning = true;
}
catch (EndpointNotFoundException ex)
{
//this error occurs when announcement endpoint is not on the network
}
catch (CommunicationException ex)
{
_serviceHost.Abort();
// customize this exception to be more specific
throw;
}
}
private static void ExportMetadata(ServiceEndpoint endpoint, EndpointDiscoveryBehavior discovery)
{
var exporter = new WsdlExporter();
exporter.ExportEndpoint(endpoint);
var metadata = exporter.GetGeneratedMetadata();
var document = new XDocument();
using (var xmlWriter = document.CreateWriter())
{
xmlWriter.WriteStartElement(WcfConstants.EndpointMetadata.LocalName,
WcfConstants.EndpointMetadata.Namespace.NamespaceName);
metadata.WriteTo(xmlWriter);
xmlWriter.WriteEndElement();
xmlWriter.Flush();
}
discovery.Extensions.Add(document.Element(WcfConstants.EndpointMetadata));
}
private static void AddAdditionalMetadata(ServiceHost serviceHost, EndpointDiscoveryBehavior discovery)
{
var meatadata = serviceHost.Extensions.FindAll<IWcfMetadataProvider>();
discovery.Scopes.AddAll(meatadata.SelectMany(meta => meta.Scopes));
discovery.Extensions.AddAll(meatadata.SelectMany(meta => meta.Extensions));
}
private void OpenServices()
{
// Create a singleton instance for the host
ChatService chatService = new ChatService(this);
chatServiceHost = new ServiceHost(chatService, this.localAddress);
// Create a discovery behavior
EndpointDiscoveryBehavior endpointDiscoveryBehavior = new EndpointDiscoveryBehavior();
// Add an extension element with the username
endpointDiscoveryBehavior.Extensions.Add(
new XElement(
"root",
new XElement("Name", this.userName)));
// Find the endpoint
ServiceEndpoint simpleEndpoint =
this.chatServiceHost.Description.Endpoints.Find(typeof(ISimpleChatService));
// Add our behavior to the endpoint before opening it
simpleEndpoint.Behaviors.Add(endpointDiscoveryBehavior);
ShowStatus("Opening chat service...");
chatServiceHost.BeginOpen(
(result) =>
{
chatServiceHost.EndOpen(result);
ShowStatus("Chat service ready");
},
null);
OpenAnnouncementService();
}
static void Main(string[] args)
{
IPHostEntry entry = Dns.GetHostEntry("");
string addr = "localhost";
for (int i = 0; i < entry.AddressList.Length; i++)
{
if (entry.AddressList[i].AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
{
addr = entry.AddressList[i].ToString();
break;
}
}
Uri baseAddress = new Uri("http://" + addr + ":8084/319D0A4D-2253-47DC-AC4A-C1951FF6667D");
ServiceHost serviceHost = new ServiceHost(typeof(ServiceHelloWCF), baseAddress);
try
{
Binding binding;
DiscoveryVersion ver;
ver = DiscoveryVersion.WSDiscovery11;
binding = new WSHttpBinding(SecurityMode.None);
// To enable WSDiscoveryApril2005 and Soap12WSAddressingAugust2004
//ver = DiscoveryVersion.WSDiscoveryApril2005;
//binding = new CustomBinding(new TextMessageEncodingBindingElement(MessageVersion.Soap12WSAddressingAugust2004, Encoding.UTF8), new HttpTransportBindingElement());
ServiceEndpoint wsEndpoint = serviceHost.AddServiceEndpoint(typeof(IServiceHelloWCF), binding, "");
EndpointDiscoveryBehavior endpointDiscoveryBehavior = new EndpointDiscoveryBehavior();
// Add the discovery behavior to the endpoint.
wsEndpoint.Behaviors.Add(endpointDiscoveryBehavior);
// Make the service discoverable over UDP multicast
ServiceDiscoveryBehavior serviceDiscoveryBehavior = new ServiceDiscoveryBehavior();
// Announce the availability of the service over UDP multicast
serviceDiscoveryBehavior.AnnouncementEndpoints.Add(new UdpAnnouncementEndpoint(ver));
// Make the service discoverable over UDP multicast.
serviceHost.Description.Behaviors.Add(serviceDiscoveryBehavior);
serviceHost.AddServiceEndpoint(new UdpDiscoveryEndpoint(ver));
// Announce the availability of the service over UDP multicast
ServiceMetadataBehavior smb = new ServiceMetadataBehavior();
smb.HttpGetEnabled = true;
smb.HttpGetUrl = baseAddress;
serviceHost.Description.Behaviors.Add(smb);
serviceHost.Open();
Console.WriteLine("Hello World WCF Service started at {0}", baseAddress);
Console.WriteLine();
Console.WriteLine("Press <ENTER> to terminate the service.");
Console.WriteLine();
Console.ReadLine();
serviceHost.Close();
}
catch (CommunicationException e)
{
Console.WriteLine(e.Message);
}
catch (TimeoutException e)
{
Console.WriteLine(e.Message);
}
if (serviceHost.State != CommunicationState.Closed)
{
Console.WriteLine("Aborting service...");
serviceHost.Abort();
}
}
protected override void Opening(ServiceHost serviceHost)
{
var serviceDiscovery = serviceHost.Description.Behaviors.Find<ServiceDiscoveryBehavior>();
if (serviceDiscovery == null)
{
serviceDiscovery = new ServiceDiscoveryBehavior();
serviceHost.Description.Behaviors.Add(serviceDiscovery);
}
if (announceEndpoints != null)
{
serviceDiscovery.AnnouncementEndpoints.AddAll(announceEndpoints);
}
var serviceMetadata = serviceHost.Extensions.OfType<IWcfDiscoveryMetadata>().ToArray();
foreach (var endpoint in serviceHost.Description.NonSystemEndpoints())
{
var discovery = endpoint.Behaviors.Find<EndpointDiscoveryBehavior>();
if (discovery == null)
{
discovery = new EndpointDiscoveryBehavior();
endpoint.Behaviors.Add(discovery);
}
discovery.Scopes.AddAll(scopes);
discovery.Extensions.AddAll(metadata);
var discoveryMetaadata = endpoint.Behaviors.OfType<IWcfDiscoveryMetadata>();
AddDiscoveryMetadata(discoveryMetaadata, discovery);
AddDiscoveryMetadata(serviceMetadata, discovery);
if (strict == false)
{
ExportMetadata(endpoint, discovery);
}
}
AddDiscoveryEndpoint(serviceHost);
}
private static void AddDiscoveryMetadata(IEnumerable<IWcfDiscoveryMetadata> metadata, EndpointDiscoveryBehavior discovery)
{
foreach (var meta in metadata)
{
discovery.Scopes.AddAll(meta.Scopes);
discovery.Extensions.AddAll(meta.Extensions);
}
}
void EnableServiceBusDiscovery(Uri scope,bool enableMEX,Uri[] baseAddresses)
{
Debug.Assert(baseAddresses.Any(address=>address.Scheme == "sb"));
if(Description.Endpoints.Count == 0)
{
this.AddServiceBusDefaultEndpoints(baseAddresses);
}
AddServiceEndpoint(new UdpDiscoveryEndpoint());
ServiceDiscoveryBehavior discovery = new ServiceDiscoveryBehavior();
discovery.AnnouncementEndpoints.Add(new UdpAnnouncementEndpoint());
Description.Behaviors.Add(discovery);
if(enableMEX == true)
{
Description.Behaviors.Add(new ServiceMetadataBehavior());
foreach(Uri baseAddress in baseAddresses)
{
if(baseAddress.Scheme == "sb")
{
string address = baseAddress.AbsoluteUri;
if(address.EndsWith("/") == false)
{
address += "/";
}
address += "MEX";
AddServiceEndpoint(typeof(IMetadataExchange),new NetTcpRelayBinding(),address);
break;
}
}
if(scope != null)
{
EndpointDiscoveryBehavior behavior = new EndpointDiscoveryBehavior();
behavior.Scopes.Add(scope);
foreach(ServiceEndpoint endpoint in Description.Endpoints)
{
if(endpoint.IsSystemEndpoint ||
endpoint is DiscoveryEndpoint ||
endpoint is AnnouncementEndpoint ||
endpoint is ServiceMetadataEndpoint)
{
continue;
}
endpoint.Behaviors.Add(behavior);
}
}
}
}
