static EndpointAddress FindCalculatorServiceAddress() { // Create DiscoveryClient DiscoveryEndpoint discoveryEndpoint = new DiscoveryEndpoint(new NetTcpBinding(), new EndpointAddress("net.tcp://localhost:8001/DiscoveryRouter/")); DiscoveryClient discoveryClient = new DiscoveryClient(discoveryEndpoint); Console.WriteLine("Finding ICalculatorService endpoints..."); Console.WriteLine(); // Find ICalculatorService endpoints FindCriteria findCriteria = new FindCriteria(typeof(ICalculatorService)); findCriteria.Duration = TimeSpan.FromSeconds(10); FindResponse findResponse = discoveryClient.Find(findCriteria); Console.WriteLine("Found {0} ICalculatorService endpoint(s).", findResponse.Endpoints.Count); Console.WriteLine(); if (findResponse.Endpoints.Count > 0) { return findResponse.Endpoints[0].Address; } else { return null; } }
internal FindCriteria Clone() { FindCriteria findCriteriaClone = new FindCriteria(); foreach (Uri scope in this.Scopes) { findCriteriaClone.Scopes.Add(scope); } foreach (XmlQualifiedName contractTypeName in this.ContractTypeNames) { findCriteriaClone.ContractTypeNames.Add(new XmlQualifiedName(contractTypeName.Name, contractTypeName.Namespace)); } foreach (XElement extension in this.Extensions) { findCriteriaClone.Extensions.Add(new XElement(extension)); } findCriteriaClone.ScopeMatchBy = this.ScopeMatchBy; findCriteriaClone.Duration = this.Duration; findCriteriaClone.MaxResults = this.MaxResults; return(findCriteriaClone); }
protected override IEnumerable<MatchedEndpointDiscoveryMetadata> OnMatchEndpoints(FindCriteria criteria) { return _endpoints .Where(meta => criteria.IsMatch(meta.Value)) .Select(meta => new MatchedEndpointDiscoveryMetadata(meta.Value)) .ToList(); }
private DiscoveryEndpoint DiscoverEndpoint(DiscoveryEndpoint endpoint, bool required) { using (var discover = new DiscoveryClient(UdpDiscoveryEndpoint ?? new UdpDiscoveryEndpoint())) { var criteria = new FindCriteria(endpoint.Contract.ContractType) { MaxResults = 1 }; if (DiscoveryDuration.HasValue) { criteria.Duration = DiscoveryDuration.Value; } var discovered = discover.Find(criteria); if (discovered.Endpoints.Count > 0) { var endpointMetadata = discovered.Endpoints[0]; var binding = Binding ?? AbstractChannelBuilder.GetBindingFromMetadata(endpointMetadata); return new DiscoveryEndpoint(binding, endpointMetadata.Address); } if (required) { throw new EndpointNotFoundException("Unable to locate a ServiceCatalog on the network."); } return null; } }
public static MediaDevice[] GetAvailableMediaDevices() { DiscoveryClient discoveryClient = new DiscoveryClient(new UdpDiscoveryEndpoint(DiscoveryVersion.WSDiscoveryApril2005)); FindCriteria findCriteria = new FindCriteria { Duration = TimeSpan.FromSeconds(1), MaxResults = 15 }; findCriteria.ContractTypeNames.Add(new XmlQualifiedName("NetworkVideoTransmitter", @"http://www.onvif.org/ver10/network/wsdl")); FindResponse findResponse = discoveryClient.Find(findCriteria); List<MediaDevice> cameras = new List<MediaDevice>(); foreach (var point in findResponse.Endpoints) { Uri uri = point.ListenUris.FirstOrDefault(u => u.HostNameType == UriHostNameType.IPv4); if (uri != null) { string name = ONVIFAgent.GetDeviceInformation(uri); cameras.Add(new MediaDevice(name, uri)); } } return cameras.ToArray(); }
protected override IAsyncResult OnBeginOfflineAnnouncement(DiscoveryMessageSequence messageSequence, EndpointDiscoveryMetadata endpointDiscoveryMetadata, AsyncCallback callback, object state) { try { if (endpointDiscoveryMetadata == null) { throw new ArgumentNullException("endpointDiscoveryMetadata"); } // We care only about ISimpleChatService services FindCriteria criteria = new FindCriteria(typeof(ISimpleChatService)); if (criteria.IsMatch(endpointDiscoveryMetadata)) { endpointDiscoveryMetadata.WriteLine("Removing"); Cache.Remove(endpointDiscoveryMetadata.Address.Uri); } } catch (KeyNotFoundException) { // No problem if it does not exist in the cache } return new CompletedAsyncResult(callback, state); }
void Match(FindRequestContext findRequestContext) { FindCriteria criteria = findRequestContext.Criteria; if (!ScopeCompiler.IsSupportedMatchingRule(criteria.ScopeMatchBy)) { return; } CompiledScopeCriteria[] compiledScopeCriterias = ScopeCompiler.CompileMatchCriteria( criteria.InternalScopes, criteria.ScopeMatchBy); int matchingEndpointCount = 0; for (int i = 0; i < this.publishedEndpoints.Count; i++) { if (criteria.IsMatch(this.publishedEndpoints[i], compiledScopeCriterias)) { findRequestContext.AddMatchingEndpoint(this.publishedEndpoints[i]); matchingEndpointCount++; if (matchingEndpointCount == criteria.MaxResults) { break; } } } }
public virtual EndpointDiscoveryMetadata[] FindEndpoints(FindCriteria criteria) { using (@lock.ForReading()) { return MatchTargets(criteria).ToArray(); } }
protected FindRequestContext (FindCriteria criteria) { if (criteria == null) throw new ArgumentNullException ("criteria"); Criteria = criteria; Endpoints = new Collection<EndpointDiscoveryMetadata> (); }
public static FindCriteria CreateMetadataExchangeEndpointCriteria (IEnumerable<XmlQualifiedName> contractTypeNames) { var fc = new FindCriteria (); foreach (var type in contractTypeNames) fc.ContractTypeNames.Add (type); return fc; }
public static LobbyWindow lanGame(UserAccount account, ILobbyGUI gui) { DiscoveryClient dc = new DiscoveryClient(new UdpDiscoveryEndpoint()); FindCriteria fc = new FindCriteria(typeof(IDiscoveryTest)); fc.Duration = TimeSpan.FromSeconds(5); FindResponse fr = dc.Find(fc); if (fr.Endpoints.Count > 0) { ip = fr.Endpoints[0].Address.Uri.Host.ToString(); } else { string HostName = System.Net.Dns.GetHostName(); System.Net.IPHostEntry hostInfo = System.Net.Dns.GetHostByName(HostName); string IpAdresse = hostInfo.AddressList[0].ToString(); ip = IpAdresse; Server server = new Server(new WCFTCPServiceFactory(),ip); server.run(); } factory = new WCFTCPConnectionFactory(); lobbyWindow = new LobbyWindow(account, gui, factory); factory.connectToLobby(ip, lobbyWindow); return lobbyWindow; }
public static void Main() { // Create DiscoveryClient DiscoveryClient discoveryClient = new DiscoveryClient(new UdpDiscoveryEndpoint()); Console.WriteLine("Finding ICalculatorService endpoints..."); Console.WriteLine(); // Find ICalculatorService endpoints FindCriteria findCriteria = new FindCriteria(typeof(ICalculatorService)); findCriteria.Duration = TimeSpan.FromSeconds(5); FindResponse findResponse = discoveryClient.Find(findCriteria); Console.WriteLine("Found {0} ICalculatorService endpoint(s).", findResponse.Endpoints.Count); Console.WriteLine(); // Check to see if endpoints were found & print the XML metadata in them. if (findResponse.Endpoints.Count > 0) { foreach (XElement xElement in findResponse.Endpoints[0].Extensions) { Console.WriteLine("Printing Metadata from ServiceEndpoint:"); Console.WriteLine("Endpoint Information: " + xElement.Element("Information").Value); Console.WriteLine("Endpoint Started at Time: " + xElement.Element("Time").Value); Console.WriteLine(); } InvokeCalculatorService(findResponse.Endpoints[0].Address); } Console.WriteLine("Press <ENTER> to exit."); Console.ReadLine(); }
static EndpointAddress FindCalculatorServiceAddress() { // Create a discovery client using the secure endpoint that applies and checks the compact signature DiscoveryClient discoveryClient = new DiscoveryClient("udpSecureDiscoveryEndpoint"); Console.WriteLine("Finding ICalculatorService endpoints..."); Console.WriteLine(); FindCriteria findCriteria = new FindCriteria(typeof(ICalculatorService)); findCriteria.Duration = TimeSpan.FromSeconds(5); // Find ICalculatorService endpoints FindResponse findResponse = discoveryClient.Find(findCriteria); Console.WriteLine("Found {0} ICalculatorService endpoint(s).", findResponse.Endpoints.Count); Console.WriteLine(); if (findResponse.Endpoints.Count > 0) { return findResponse.Endpoints[0].Address; } else { return null; } }
static EndpointAddress FindCalculatorServiceAddress() { // Create DiscoveryClient DiscoveryClient discoveryClient = new DiscoveryClient(new UdpDiscoveryEndpoint()); // Find ICalculatorService endpoints in the specified scope Uri scope = new Uri("ldap:///ou=engineering,o=exampleorg,c=us"); FindCriteria findCriteria = new FindCriteria(typeof(ICalculatorService)); findCriteria.Scopes.Add(scope); findCriteria.MaxResults = 1; Console.WriteLine("Finding ICalculatorService endpoints within {0} scope...", scope); Console.WriteLine(); FindResponse findResponse = discoveryClient.Find(findCriteria); Console.WriteLine("Found {0} ICalculatorService endpoint(s).", findResponse.Endpoints.Count); Console.WriteLine(); if (findResponse.Endpoints.Count > 0) { return findResponse.Endpoints[0].Address; } else { return null; } }
public FindRequestResponseContext( FindCriteria criteria, ProbeRequestResponseAsyncResult <TProbeMessage, TResponseMessage> probeRequestResponseAsyncResult) : base(criteria) { this.matchingEndpoints = new Collection <EndpointDiscoveryMetadata>(); this.probeRequestResponseAsyncResult = probeRequestResponseAsyncResult; }
public DynamicEndpoint (ContractDescription contract, Binding binding) : base (contract, binding, new EndpointAddress ("http://schemas.microsoft.com/discovery/dynamic")) { if (binding == null) throw new ArgumentNullException ("binding"); DiscoveryEndpointProvider = new UdpDiscoveryEndpointProvider (); FindCriteria = new FindCriteria (contract.ContractType); }
public static FindCriteria CreateMetadataExchangeEndpointCriteria(Type contractType) { FindCriteria criteria = CreateMetadataExchangeEndpointCriteria(); criteria.Scopes.Add(GetContractTypeNameScope(GetContractTypeName(contractType))); return(criteria); }
public DiscoveryClientDuplexChannel( ChannelManagerBase channelManagerBase, IChannelFactory <TChannel> innerChannelFactory, FindCriteria findCriteria, DiscoveryEndpointProvider discoveryEndpointProvider) : base(channelManagerBase, innerChannelFactory, findCriteria, discoveryEndpointProvider) { }
public static FindCriteria CreateMetadataExchangeEndpointCriteria() { FindCriteria criteria = new FindCriteria(); criteria.ContractTypeNames.Add(EndpointDiscoveryMetadata.MetadataContractName); return(criteria); }
public DiscoveryClientRequestSessionChannel( ChannelManagerBase channelManagerBase, IChannelFactory <IRequestSessionChannel> innerChannelFactory, FindCriteria findCriteria, DiscoveryEndpointProvider discoveryEndpointProvider) : base(channelManagerBase, innerChannelFactory, findCriteria, discoveryEndpointProvider) { }
public void DefaultValues () { var fc = new FindCriteria (); Assert.AreEqual (int.MaxValue, fc.MaxResults, "#1"); Assert.IsNotNull (fc.ContractTypeNames, "#2"); Assert.IsNotNull (fc.Scopes, "#3"); Assert.AreEqual (FindCriteria.ScopeMatchByPrefix, fc.ScopeMatchBy, "#4"); Assert.AreEqual (TimeSpan.FromSeconds (20), fc.Duration, "#5"); }
private void RestrictDomain(FindCriteria criteria) { if (string.IsNullOrEmpty(Domain) == false) { var domain = new WcfDiscoveryDomain(Domain); criteria.Scopes.AddAll(domain.Scopes); criteria.Extensions.AddAll(domain.Extensions); } }
protected FindRequestContext(FindCriteria criteria) { if (criteria == null) { throw new ArgumentNullException("criteria"); } Criteria = criteria; Endpoints = new Collection <EndpointDiscoveryMetadata> (); }
public DynamicEndpoint (ContractDescription contract, Binding binding) : base (contract, CreateBinding (binding), new EndpointAddress ("http://schemas.microsoft.com/discovery/dynamic")) { if (binding == null) throw new ArgumentNullException ("binding"); DiscoveryEndpointProvider = DiscoveryEndpointProvider.CreateDefault (); FindCriteria = new FindCriteria (contract.ContractType); IsSystemEndpoint = true; }
public static FindCriteria CreateMetadataExchangeEndpointCriteria(IEnumerable <XmlQualifiedName> contractTypeNames) { var fc = new FindCriteria(); foreach (var type in contractTypeNames) { fc.ContractTypeNames.Add(type); } return(fc); }
public DiscoveryClientChannelFactory(IChannelFactory <TChannel> innerChannelFactory, FindCriteria findCriteria, DiscoveryEndpointProvider discoveryEndpointProvider) { Fx.Assert(findCriteria != null, "The findCriteria must be non null."); Fx.Assert(discoveryEndpointProvider != null, "The discoveryEndpointProvider must be non null."); Fx.Assert(innerChannelFactory != null, "The innerChannelFactory must be non null."); this.findCriteria = findCriteria; this.discoveryEndpointProvider = discoveryEndpointProvider; this.innerChannelFactory = innerChannelFactory; }
public EndpointAddress FindNotifierServiceAddress(int secondsTimeout) { DiscoveryClient discoveryClient = new DiscoveryClient(new UdpDiscoveryEndpoint()); FindCriteria criteria = new FindCriteria(typeof(INotifierService)) { Duration = new TimeSpan(0, 0, 0, secondsTimeout) }; FindResponse findResponse = discoveryClient.Find(criteria); if (findResponse.Endpoints.Count > 0) { return findResponse.Endpoints[0].Address; } return null; }
public DynamicEndpoint(ContractDescription contract, Binding binding) : base(contract, CreateBinding(binding), new EndpointAddress("http://schemas.microsoft.com/discovery/dynamic")) { if (binding == null) { throw new ArgumentNullException("binding"); } DiscoveryEndpointProvider = DiscoveryEndpointProvider.CreateDefault(); FindCriteria = new FindCriteria(contract.ContractType); IsSystemEndpoint = true; }
/// <summary> /// Starts this instance. /// </summary> public void Start() { findCriteria = new FindCriteria(typeof(IAgent)) { Scopes = { connectionsHostOptions.Scope }, Duration = TimeSpan.FromMilliseconds(options.DiscoveryIntervalInMiliseconds) }; discoveryClient = GetInitilizedDisoveryClient(); log.Info("Starting clients tracking"); Discover(); }
private void OnOfflineAnnouncement(object sender, AnnouncementEventArgs e) { EndpointDiscoveryMetadata metadata = e.EndpointDiscoveryMetadata; FindCriteria criteria = new FindCriteria(typeof(ISimpleChatService)); if (criteria.IsMatch(metadata)) { this.RemoveUser(metadata.Address.Uri); } }
static void AddContractTypeScopes(EndpointDiscoveryMetadata endpointDiscoveryMetadata, ServiceDescription serviceDescription) { foreach (ServiceEndpoint endpoint in serviceDescription.Endpoints) { if (IsMetadataEndpoint(endpoint) || IsDiscoverySystemEndpoint(endpoint)) { continue; } endpointDiscoveryMetadata.Scopes.Add(FindCriteria.GetContractTypeNameScope( new XmlQualifiedName(endpoint.Contract.Name, endpoint.Contract.Namespace))); } }
public EndpointDiscoveryMetadata MatchEndpoint(FindCriteria criteria) { EndpointDiscoveryMetadata endpoint = null; var endpoints = OnMatchEndpoints(criteria); var metadatas = new List<EndpointDiscoveryMetadata>(); foreach (var ep in endpoints) { var metadata = ep.ToEndpointDiscoveryMetadata(); metadatas.Add(metadata); } endpoint = _endpointSelector.Select(metadatas); return endpoint; }
public DiscoveryClientBindingElement(DiscoveryEndpointProvider discoveryEndpointProvider, FindCriteria findCriteria) { if (discoveryEndpointProvider == null) { throw new ArgumentNullException("discoveryEndpointProvider"); } if (findCriteria == null) { throw new ArgumentNullException("findCriteria"); } DiscoveryEndpointProvider = discoveryEndpointProvider; FindCriteria = findCriteria; }
static void FindCalculatorServiceAddress() { DiscoveryClient discoveryClient = new DiscoveryClient(new UdpDiscoveryEndpoint()); discoveryClient.FindCompleted += new EventHandler<FindCompletedEventArgs>(ClientFindCompleted); discoveryClient.FindProgressChanged += new EventHandler<FindProgressChangedEventArgs>(ClientFindProgressChanged); Console.WriteLine("Finding ICalculatorServices endpoints asynchronously...\n"); FindCriteria findCriteria = new FindCriteria(typeof(ICalculatorService)); findCriteria.Duration = TimeSpan.FromSeconds(5); // Find ICalculatorService endpoint asynchronously. The results are returned asynchronously via events discoveryClient.FindAsync(findCriteria); }
public Collection<EndpointDiscoveryMetadata> GetAvailableConnections() { FindCriteria criteria = new FindCriteria(ContractType); criteria.Duration = FindDuration; Collection<EndpointDiscoveryMetadata> endpoints = new Collection<EndpointDiscoveryMetadata>(); FindResponse response = ClientDiscovery.Find(criteria); if (response.Endpoints.Count > 0) for (Int32 index = 0; index < response.Endpoints.Count; index++) { String[] allowedClients = GetAllowedClients(response.Endpoints[index]); if (IsConnectionAllowed(allowedClients)) endpoints.Add(response.Endpoints[index]); } return endpoints; }
public DiscoveryClientBindingElement(DiscoveryEndpointProvider discoveryEndpointProvider, FindCriteria findCriteria) { if (discoveryEndpointProvider == null) { throw FxTrace.Exception.ArgumentNull("discoveryEndpointProvider"); } if (findCriteria == null) { throw FxTrace.Exception.ArgumentNull("findCriteria"); } this.findCriteria = findCriteria; this.discoveryEndpointProvider = discoveryEndpointProvider; }
public void FindAsync(FindCriteria criteria, object userState) { AsyncCallback cb = delegate(IAsyncResult result) { FindResponse ret = null; Exception error = null; try { ret = EndFind(result); } catch (Exception ex) { error = ex; } OnFindCompleted(new FindCompletedEventArgs(ret, error, cancelled, result.AsyncState)); }; cancelled = false; BeginFind(criteria, cb, userState); }
public static Uri WcfTestClient_DiscoverChannel() { var dc = new DiscoveryClient(new UdpDiscoveryEndpoint()); FindCriteria fc = new FindCriteria(typeof(IWcfPingTest)); fc.Duration = TimeSpan.FromSeconds(20); FindResponse fr = dc.Find(fc); foreach (EndpointDiscoveryMetadata edm in fr.Endpoints) { Console.WriteLine("uri found = " + edm.Address.Uri.ToString()); } // here is the really nasty part // i am just returning the first channel, but it may not work. // you have to do some logic to decide which uri to use from the discovered uris // for example, you may discover "127.0.0.1", but that one is obviously useless. // also, catch exceptions when no endpoints are found and try again. return fr.Endpoints[0].Address.Uri; }
private void OnOnlineAnnouncement(object sender, AnnouncementEventArgs e) { EndpointDiscoveryMetadata metadata = e.EndpointDiscoveryMetadata; // We are looking for services that // implement the ISimpleChatService contract FindCriteria criteria = new FindCriteria(typeof(ISimpleChatService)); if (criteria.IsMatch(metadata)) { if (this.GetUser(metadata.Address.Uri) == null) { this.PopulateUserList(metadata); } } }
static void Main(string[] args) { DiscoveryClient discoveryClient = new DiscoveryClient(new UdpDiscoveryEndpoint()); FindCriteria criteria = new FindCriteria(typeof(ICalculator)); criteria.Scopes.Add(new Uri("http://www.artech.com/")); FindResponse response = discoveryClient.Find(criteria); if (response.Endpoints.Count > 0) { EndpointAddress address = response.Endpoints[0].Address; using (ChannelFactory<ICalculator> channelFactory = new ChannelFactory<ICalculator>(new WS2007HttpBinding(), address)) { ICalculator calculator = channelFactory.CreateChannel(); Console.WriteLine("x + y = {2} when x = {0} and y = {1}", 1, 2, calculator.Add(1, 2)); } } Console.Read(); }
protected override void Execute(CodeActivityContext context) { DiscoveryClient discoveryClient = new DiscoveryClient(new UdpDiscoveryEndpoint()); FindCriteria findCriteria = new FindCriteria(); // Create a contract to add to the findCriteria. The search will be based on this contract. findCriteria.ContractTypeNames.Add(new XmlQualifiedName("IPrintService", "http://tempuri.org/")); findCriteria.MaxResults = 1; findCriteria.Duration = new TimeSpan(0, 0, 0, 3); FindResponse findResponse = discoveryClient.Find(findCriteria); discoveryClient.Close(); if (findResponse.Endpoints.Count == 0) { throw new EndpointNotFoundException("Client was unable to find any matching endpoints using Discovery."); } this.DiscoveredEndpointUri.Set(context, findResponse.Endpoints[0].Address.Uri); }
protected override IAsyncResult OnBeginOnlineAnnouncement(DiscoveryMessageSequence messageSequence, EndpointDiscoveryMetadata endpointDiscoveryMetadata, AsyncCallback callback, object state) { if (endpointDiscoveryMetadata == null) { throw new ArgumentNullException("endpointDiscoveryMetadata"); } // We care only about ISimpleChatService services FindCriteria criteria = new FindCriteria(typeof(ISimpleChatService)); if (criteria.IsMatch(endpointDiscoveryMetadata)) { endpointDiscoveryMetadata.WriteLine("Adding"); Cache.Add(endpointDiscoveryMetadata); } return new CompletedAsyncResult(callback, state); }
static void Main(string[] args) { var discovery = new DiscoveryClient( new UdpDiscoveryEndpoint()); var criteria = new FindCriteria(typeof(EchoService)) { Duration = TimeSpan.FromSeconds(2) }; var service = discovery.Find(criteria); foreach (var endpoint in service.Endpoints) { Console.WriteLine("{0}", endpoint.Address); } var channelFactory = new ChannelFactory<EchoService>( new BasicHttpBinding(), service.Endpoints.FirstOrDefault().Address); var response = channelFactory.CreateChannel().Echo("hello!"); Console.WriteLine(response); }
public static FindCriteria CreateMetadataExchangeEndpointCriteria(IEnumerable <XmlQualifiedName> contractTypeNames) { if (contractTypeNames == null) { throw FxTrace.Exception.ArgumentNull("contractTypeNames"); } FindCriteria criteria = CreateMetadataExchangeEndpointCriteria(); foreach (XmlQualifiedName item in contractTypeNames) { if (item == null) { throw FxTrace.Exception.ArgumentNull("item"); } criteria.Scopes.Add(GetContractTypeNameScope(item)); } return(criteria); }
public DiscoveryClientChannelBase( ChannelManagerBase channelManagerBase, IChannelFactory <TChannel> innerChannelFactory, FindCriteria findCriteria, DiscoveryEndpointProvider discoveryEndpointProvider) : base(channelManagerBase) { Fx.Assert(findCriteria != null, "The findCriteria must be non null."); Fx.Assert(discoveryEndpointProvider != null, "The discoveryEndpointProvider must be non null."); Fx.Assert(innerChannelFactory != null, "The innerChannelFactory must be non null."); this.innerChannelFactory = innerChannelFactory; this.findCriteria = findCriteria; this.discoveryEndpointProvider = discoveryEndpointProvider; this.discoveredEndpoints = new InputQueue <EndpointDiscoveryMetadata>(); this.totalExpectedEndpoints = int.MaxValue; this.totalDiscoveredEndpoints = 0; this.discoveryCompleted = false; this.thisLock = new object(); }
void Cleanup(TimeSpan timeout) { TimeoutHelper timeoutHelper = new TimeoutHelper(timeout); Exception exception = null; lock (this.thisLock) { this.discoveryCompleted = true; } try { this.discoveryClient.CancelAsync(this); ((ICommunicationObject)this.discoveryClient).Close(timeoutHelper.RemainingTime()); } catch (TimeoutException timeoutException) { exception = timeoutException; } catch (CommunicationException communicationException) { exception = communicationException; } finally { if (exception != null && TD.DiscoveryClientInClientChannelFailedToCloseIsEnabled()) { TD.DiscoveryClientInClientChannelFailedToClose(exception); } } this.discoveredEndpoints.Dispose(); this.discoveryClient = null; this.discoveredEndpoints = null; this.findCriteria = null; this.discoveryEndpointProvider = null; this.innerChannelFactory = null; }
public static void Main() { // Create DiscoveryClient DiscoveryClient discoveryClient = new DiscoveryClient(new UdpDiscoveryEndpoint()); Console.WriteLine("Finding ICalculatorService endpoints..."); Console.WriteLine(); FindCriteria findCriteria = new FindCriteria(typeof(ICalculatorService)); findCriteria.Duration = TimeSpan.FromSeconds(5); // Find ICalculatorService endpoints FindResponse findResponse = discoveryClient.Find(findCriteria); Console.WriteLine("Found {0} ICalculatorService endpoint(s).", findResponse.Endpoints.Count); Console.WriteLine(); // Check to see if endpoints were found if (findResponse.Endpoints.Count > 0) { EndpointDiscoveryMetadata discoveredEndpoint = findResponse.Endpoints[0]; // Check to see if the endpoint has a listenUri and if it differs from the Address URI if (discoveredEndpoint.ListenUris.Count > 0 && discoveredEndpoint.Address.Uri != discoveredEndpoint.ListenUris[0]) { // Since the service is using a unique ListenUri, it needs to be invoked at the correct ListenUri InvokeCalculatorService(discoveredEndpoint.Address, discoveredEndpoint.ListenUris[0]); } else { // Endpoint was found, however it doesn't have a unique ListenUri, hence invoke the service with only the Address URI InvokeCalculatorService(discoveredEndpoint.Address, null); } } Console.WriteLine("Press <ENTER> to exit."); Console.ReadLine(); }
public Collection<EndpointDiscoveryMetadata> GetAvailableConnections() { FindCriteria findCriteria = new FindCriteria(m_ContractType); findCriteria.Duration = m_FindDuration; Collection<EndpointDiscoveryMetadata> endpoints = new Collection<EndpointDiscoveryMetadata>(); FindResponse findResponse = m_DiscoveryClient.Find(findCriteria); if (findResponse.Endpoints.Count > 0) { for (Int32 index = 0; index < findResponse.Endpoints.Count; index++) { String[] AllowedClients = GetAllowedClients(findResponse.Endpoints[index]); if (IsConnectionAllowed(AllowedClients)) { endpoints.Add(findResponse.Endpoints[index]); } } } return endpoints; }
protected FindRequestContext(FindCriteria criteria) { Fx.Assert(criteria != null, "The criteria must be non null."); this.criteria = criteria; }
public void FindAsync(FindCriteria criteria) { FindAsync(criteria, null); }
IAsyncResult BeginFind(FindCriteria criteria, AsyncCallback callback, object state) { return(((IDiscoveryCommon)client).BeginFind(criteria, callback, state)); }
public DefaultFindRequestContext(FindCriteria criteria) : base(criteria) { }
private DiscoveryClientBindingElement(DiscoveryClientBindingElement elementToBeCloned) : base(elementToBeCloned) { this.discoveryEndpointProvider = elementToBeCloned.DiscoveryEndpointProvider; this.findCriteria = elementToBeCloned.FindCriteria.Clone();; }
protected virtual IAsyncResult BeginShouldRedirectFind(FindCriteria resolveCriteria, AsyncCallback callback, object state) { return(new CompletedAsyncResult <bool>(false, callback, state)); }
//----------------------------------------------------- // Redirect Adhoc to Managed Probe //----------------------------------------------------- #region ShouldRedirectFind // Summary: // Override this method to allow the discovery proxy to send out multicast suppression // messages when it receives a multicast find request. // // Parameters: // resolveCriteria: // The resolve criteria that describes the service to find. // // callback: // The callback delegate to call when the operation has completed. // // state: // The user-defined state data. // // Returns: // A reference to the pending asynchronous operation. protected override IAsyncResult BeginShouldRedirectFind(FindCriteria resolveCriteria, AsyncCallback callback, object state) { return(_findTaskFactory.Create(resolveCriteria).ToApm(callback, state)); }
protected virtual IAsyncResult BeginShouldRedirectFind(FindCriteria resolveCriteria, AsyncCallback callback, Object state) { throw new NotImplementedException(); }
public DuplexFindContext(FindCriteria criteria, ProbeDuplexAsyncResult <TProbeMessage, TResponseChannel> probeDuplexAsyncResult) : base(criteria) { this.matchingEndpoints = new InputQueue <EndpointDiscoveryMetadata>(); this.probeDuplexAsyncResult = probeDuplexAsyncResult; }
IAsyncResult IMulticastSuppressionImplementation.BeginShouldRedirectFind(FindCriteria findCriteria, AsyncCallback callback, object state) { return(this.BeginShouldRedirectFind(findCriteria, callback, state)); }
public DiscoveryClientBindingElement() { DiscoveryEndpointProvider = DiscoveryEndpointProvider.CreateDefault(); FindCriteria = new FindCriteria(); // empty }
internal static FindCriteria ReadXml(XmlReader reader, DiscoveryVersion version) { if (reader == null) { throw new ArgumentNullException("reader"); } var ret = new FindCriteria(); reader.MoveToContent(); if (!reader.IsStartElement("Probe", version.Namespace) || reader.IsEmptyElement) { throw new XmlException(String.Format("Non-empty ProbeType element is expected. Got '{0}' {1} node in namespace '{2}' instead.", reader.LocalName, reader.NodeType, reader.NamespaceURI)); } reader.ReadStartElement("Probe", version.Namespace); // standard members reader.MoveToContent(); if (reader.IsStartElement("Types", version.Namespace)) { ret.ContractTypeNames = new Collection <XmlQualifiedName> ((XmlQualifiedName [])reader.ReadElementContentAs(typeof(XmlQualifiedName []), null, "Types", version.Namespace)); } reader.MoveToContent(); if (reader.IsStartElement("Types", version.Namespace)) { if (reader.MoveToAttribute("MatchBy")) { ret.ScopeMatchBy = new Uri(reader.Value, UriKind.RelativeOrAbsolute); reader.MoveToElement(); } } if (reader.IsStartElement("Scopes", version.Namespace)) { ret.Scopes = new Collection <Uri> ((Uri [])reader.ReadElementContentAs(typeof(Uri []), null, "Scopes", version.Namespace)); } // non-standard members for (reader.MoveToContent(); !reader.EOF && reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent()) { if (reader.NamespaceURI == SerializationNS) { switch (reader.LocalName) { case "MaxResults": ret.MaxResults = reader.ReadElementContentAsInt(); break; case "Duration": ret.Duration = (TimeSpan)reader.ReadElementContentAs(typeof(TimeSpan), null); break; } } else { ret.Extensions.Add(XElement.Load(reader)); } } reader.ReadEndElement(); return(ret); }