public FactoryServiceHelper(Uri url)
{
adresse = url;
Uri mexAddress = new Uri(adresse.ToString() + "?wsdl");
//for MEX endpoints use a MEX address and a mexMode of .MetadataExchange
MetadataExchangeClientMode mexMode = MetadataExchangeClientMode.HttpGet;
MetadataExchangeClient mexClient = new MetadataExchangeClient(mexAddress, mexMode);
mexClient.ResolveMetadataReferences = true;
serviceMetadata = mexClient.GetMetadata();
WsdlImporter importer = new WsdlImporter(serviceMetadata);
System.Collections.ObjectModel.Collection <ContractDescription> contracts = importer.ImportAllContracts();
BasicHttpBinding Binding = new BasicHttpBinding();
EndpointAddress address = new EndpointAddress(adresse.ToString());
ChannelFactory <IRequestChannel> factory =
new ChannelFactory <IRequestChannel>(Binding, address);
serviceChannel = factory.CreateChannel();
serviceInfo = contracts[0];
targetNamespace = serviceInfo.Namespace;
serviceName = serviceInfo.Name;
}
static ServiceEndpointCollection QueryMexEndpoint(string mexAddress, Binding binding, string issuer, string secret)
{
Binding extendedBinding = null;
if (binding is NetTcpRelayBinding)
{
NetTcpRelayBinding actualBinding = binding as NetTcpRelayBinding;
actualBinding.MaxReceivedMessageSize *= MessageSizeMultiplier;
extendedBinding = actualBinding;
}
if (binding is WS2007HttpRelayBinding)
{
WS2007HttpRelayBinding actualBinding = binding as WS2007HttpRelayBinding;
actualBinding.MaxReceivedMessageSize *= MessageSizeMultiplier;
extendedBinding = actualBinding;
}
MetadataExchangeClient mexClient = new MetadataExchangeClient(extendedBinding);
mexClient.SetServiceBusCredentials(issuer, secret);
MetadataSet metadata = mexClient.GetMetadata(new EndpointAddress(mexAddress));
MetadataImporter importer = new WsdlImporter(metadata);
return(importer.ImportAllEndpoints());
}
protected bool RetrieveMetadata(ProxyWrapper proxywrapper)
{
var success = true;
MetadataSet metadataset = null;
bool isInbadlist = null != _badProxyAddressList.FirstOrDefault <ProxyWrapper>(w => w.EndPoint.address == proxywrapper.EndPoint.address);
if (proxywrapper.Proxy != null)
{
try
{
var address = string.Format(@"{0}?wsdl", proxywrapper.EndPoint.address);
var mexClient = new MetadataExchangeClient(new Uri(address), MetadataExchangeClientMode.HttpGet);
metadataset = mexClient.GetMetadata();
}
catch (Exception e)
{
#if LOG // TODO : Remove when .NET 4.0 log manager is used
_logger.Warning(e.Message);
#endif
success = false;
}
}
if (null != metadataset)
{
var sb = new StringBuilder();
foreach (var section in metadataset.MetadataSections)
{
sb.AppendLine(string.Format(@"{0}{1}", section.Identifier.ToString(), Environment.NewLine));
}
VerifyProxyResults = sb.ToString();
}
return(success);
}
// </Snippet0>
static void CallFromMain(string[] args)
{
//<snippet10>
// make endpoint address
EndpointAddress mexAddress = new EndpointAddress("http://localhost:8080/ServiceMetadata/mex");
// Download all metadata. The policy importer runs automatically.p
ServiceEndpointCollection endpoints
= MetadataResolver.Resolve(
typeof(IStatefulService),
new EndpointAddress("http://localhost:8080/StatefulService/mex")
);
//</snippet10>
MetadataExchangeClient mexClient =
new MetadataExchangeClient(mexAddress);
mexClient.ResolveMetadataReferences = true;
MetadataSet metaDocs = mexClient.GetMetadata();
WsdlImporter importer = new WsdlImporter(metaDocs);
// This is not neccesary for this snippet.
// PolicyConversionContext myPolicyConversionContext = new PolicyConversionContext ();
//ImportPolicy(importer, myPolicyConversionContext);
}
/// <summary>
/// Find the wsdl importer
/// </summary>
/// <param name="wsdlUri">The wsdl uri</param>
/// <returns>A wsdl importer</returns>
private WsdlImporter GetWsdlImporter(Uri wsdlUri)
{
_logger.WriteDebug($"GetWsdlImporter wsdlUri[{wsdlUri}]");
WSHttpBinding mexBinding = null;
if (wsdlUri.Scheme == Uri.UriSchemeHttp)
{
mexBinding = (WSHttpBinding)MetadataExchangeBindings.CreateMexHttpBinding();
}
else
{
mexBinding = (WSHttpBinding)MetadataExchangeBindings.CreateMexHttpsBinding();
}
mexBinding.MaxReceivedMessageSize = Int32.MaxValue;
mexBinding.MaxBufferPoolSize = Int32.MaxValue;
mexBinding.ReaderQuotas.MaxStringContentLength = Int32.MaxValue;
mexBinding.ReaderQuotas.MaxNameTableCharCount = Int32.MaxValue;
mexBinding.ReaderQuotas.MaxArrayLength = Int32.MaxValue;
mexBinding.ReaderQuotas.MaxBytesPerRead = Int32.MaxValue;
mexBinding.ReaderQuotas.MaxDepth = 64;
var mexClient = new MetadataExchangeClient(mexBinding);
mexClient.MaximumResolvedReferences = int.MaxValue;
var metadataSet = mexClient.GetMetadata(wsdlUri, MetadataExchangeClientMode.HttpGet);
return(new WsdlImporter(metadataSet));
}
/// <summary>
/// Try to create MetadataExchangeClient for GttpGet exchange mode
/// </summary>
/// <param name="client"></param>
/// <returns></returns>
private bool TryCreateMetadataExchangeClientForHttpGet(out MetadataExchangeClient client)
{
var address = new Uri(mAddress);
var GetAddress = CreateHttpGetAddress(mAddress);
BindingElement bindingElement = null;
if (address.Scheme == Uri.UriSchemeHttp)
{
var httpTransport = new HttpTransportBindingElement();
httpTransport.MaxReceivedMessageSize *= ReceivedMessageSizMultiplier;
bindingElement = httpTransport;
}
if (address.Scheme == Uri.UriSchemeHttps)
{
var httpsTransport = new HttpsTransportBindingElement();
httpsTransport.MaxReceivedMessageSize *= ReceivedMessageSizMultiplier;
bindingElement = httpsTransport;
}
try
{
var binding = new CustomBinding(bindingElement);
client = new MetadataExchangeClient(binding);
return(true);
}
catch
{
client = null;
return(false);
}
}
private MetadataSet GetServiceMetadata(string wsdlUrl, MetadataExchangeClientMode clientMode, System.Net.NetworkCredential mexNetworkCredentials)
{
MetadataSet metadata = null;
Binding mexBinding;
if (clientMode == MetadataExchangeClientMode.HttpGet)
{
mexBinding = new BasicHttpBinding {
MaxReceivedMessageSize = 50000000L
};
}
else
{
mexBinding = new WSHttpBinding(SecurityMode.None)
{
MaxReceivedMessageSize = 50000000L
};
}
var mexClient = new MetadataExchangeClient(mexBinding)
{
ResolveMetadataReferences = true,
MaximumResolvedReferences = 200,
HttpCredentials = mexNetworkCredentials
};
try
{
metadata = mexClient.GetMetadata(new Uri(wsdlUrl), clientMode);
} catch (Exception ex) {
Console.WriteLine(String.Format("Error: {0}", ex.Message));
}
return(metadata);
}
MetadataSet ResolveWithWSMex(string url)
{
MetadataSet metadata = null;
try
{
MetadataExchangeClient client = new MetadataExchangeClient(new EndpointAddress(url));
Console.WriteLine("\nAttempting to download metadata from {0} using WS-MetadataExchange..", url);
metadata = client.GetMetadata();
}
catch (InvalidOperationException e)
{
//MetadataExchangeClient wraps exceptions, thrown while
//fetching the metadata, in an InvalidOperationException
string msg;
if (e.InnerException == null)
{
msg = e.Message;
}
else
{
msg = e.InnerException.ToString();
}
Console.WriteLine("WS-MetadataExchange query failed for the url '{0}' with exception :\n {1}",
url, msg);
}
return(metadata);
}
public void CanPubishMEXEndpointsUsingCustomAddress()
{
using (new WindsorContainer()
.AddFacility <WcfFacility>(f => f.CloseTimeout = TimeSpan.Zero)
.Register(Component.For <Operations>()
.DependsOn(new { number = 42 })
.AsWcfService(new DefaultServiceModel()
.AddBaseAddresses(
"net.tcp://localhost/Operations",
"http://localhost:27198/UsingWindsor.svc")
.AddEndpoints(
WcfEndpoint.ForContract <IOperations>()
.BoundTo(new NetTcpBinding {
PortSharingEnabled = true
})
)
.PublishMetadata(mex => mex.EnableHttpGet().AtAddress("tellMeAboutYourSelf"))
)
))
{
var tcpMextClient = new MetadataExchangeClient(new EndpointAddress("net.tcp://localhost/Operations/tellMeAboutYourSelf"));
var tcpMetadata = tcpMextClient.GetMetadata();
Assert.IsNotNull(tcpMetadata);
var httpMextClient = new MetadataExchangeClient(new EndpointAddress("http://localhost:27198/UsingWindsor.svc?wsdl"));
var httpMetadata = httpMextClient.GetMetadata();
Assert.IsNotNull(httpMetadata);
}
}
static void ImportAllContracts()
{
EndpointAddress mexAddress = new EndpointAddress(uri + "/mex");
MetadataExchangeClient mexClient = new MetadataExchangeClient(mexAddress);
// Retrieve the metadata for all endpoints using metadata exchange protocol (mex).
MetadataSet metadataSet = mexClient.GetMetadata();
//Convert the metadata into endpoints
WsdlImporter importer = new WsdlImporter(metadataSet);
CodeCompileUnit codeCompileUnit = new CodeCompileUnit();
var contracts = importer.ImportAllContracts();
ServiceContractGenerator generator = new ServiceContractGenerator(codeCompileUnit);
foreach (var item in contracts)
{
generator.GenerateServiceContractType(item);
}
if (generator.Errors.Count != 0)
{
throw new Exception("error");
}
CompilerCSharpCode(generator);
var assembly = CompilerAssembly(codeCompileUnit);
CompilerNewServiceContract(assembly, importer);
}
static void ImportAllEndpoints()
{
EndpointAddress mexAddress = new EndpointAddress(uri + "/mex");
MetadataExchangeClient mexClient = new MetadataExchangeClient(mexAddress);
// Retrieve the metadata for all endpoints using metadata exchange protocol (mex).
MetadataSet metadataSet = mexClient.GetMetadata();
//Convert the metadata into endpoints
WsdlImporter importer = new WsdlImporter(metadataSet);
#region endpoints
ServiceEndpointCollection endpoints = importer.ImportAllEndpoints();
ContractDescription contract = ContractDescription.GetContract(typeof(ICalculator));
// Communicate with each endpoint that supports the ICalculator contract.
foreach (ServiceEndpoint ep in endpoints)
{
if (ep.Contract.Namespace.Equals(contract.Namespace) && ep.Contract.Name.Equals(contract.Name))
{
// Create a client using the endpoint address and binding.
var client = new ChannelFactory <CalculatorClientChannel>(ep.Binding, new EndpointAddress(ep.Address.Uri)).CreateChannel();
// call operations
Console.WriteLine(client.Add(2, 3));
//Closing the client gracefully closes the connection and cleans up resources
client.Close();
}
}
#endregion
}
static void GenerateVBCodeForService(Uri metadataAddress, string outputFile)
{
MetadataExchangeClient mexClient = new MetadataExchangeClient(metadataAddress, MetadataExchangeClientMode.HttpGet);
mexClient.ResolveMetadataReferences = true;
MetadataSet metaDocs = mexClient.GetMetadata();
WsdlImporter importer = new WsdlImporter(metaDocs);
ServiceContractGenerator generator = new ServiceContractGenerator();
System.Collections.ObjectModel.Collection <ContractDescription> contracts = importer.ImportAllContracts();
foreach (ContractDescription contract in contracts)
{
generator.GenerateServiceContractType(contract);
}
if (generator.Errors.Count != 0)
{
throw new ApplicationException("There were errors during code compilation.");
}
// Write the code dom.
System.CodeDom.Compiler.CodeGeneratorOptions options = new System.CodeDom.Compiler.CodeGeneratorOptions();
options.BracingStyle = "C";
System.CodeDom.Compiler.CodeDomProvider codeDomProvider = System.CodeDom.Compiler.CodeDomProvider.CreateProvider("VB");
System.CodeDom.Compiler.IndentedTextWriter textWriter = new System.CodeDom.Compiler.IndentedTextWriter(new System.IO.StreamWriter(outputFile));
codeDomProvider.GenerateCodeFromCompileUnit(generator.TargetCompileUnit, textWriter, options);
textWriter.Close();
}
private void IsServiceAlive()
{
while (true)
{
if (_token.IsCancellationRequested)
{
Environment.Exit(1);
}
try
{
MetadataExchangeClient mexClient = new MetadataExchangeClient(new Uri("http://localhost/ComponentsReturn"), MetadataExchangeClientMode.HttpGet);
MetadataSet metadata = mexClient.GetMetadata();
this.Set(() => this.Icon = BitmapFrame.Create(iconUriStart));
BtOpen.Set(() => BtOpen.IsEnabled = true);
BtSave.Set(() => BtSave.IsEnabled = true);
}
catch (Exception ex)
{
BtOpen.Set(() => BtOpen.IsEnabled = false);
BtSave.Set(() => BtSave.IsEnabled = false);
this.Set(() => this.Icon = BitmapFrame.Create(iconUriStop));
}
}
}
private void WSDLImport(string metadataAddress)
{
//<snippet9>
MetadataExchangeClient mexClient = new MetadataExchangeClient(metadataAddress);
mexClient.ResolveMetadataReferences = true;
MetadataSet metaDocs = mexClient.GetMetadata();
WsdlImporter importer = new WsdlImporter(metaDocs);
object dataContractImporter;
XsdDataContractImporter xsdInventoryImporter;
if (!importer.State.TryGetValue(typeof(XsdDataContractImporter),
out dataContractImporter))
{
xsdInventoryImporter = new XsdDataContractImporter();
}
xsdInventoryImporter = (XsdDataContractImporter)dataContractImporter;
xsdInventoryImporter.Options ??= new ImportOptions();
xsdInventoryImporter.Options.DataContractSurrogate = new InventorySurrogated();
importer.State.Add(typeof(XsdDataContractImporter), xsdInventoryImporter);
Collection <ContractDescription> contracts = importer.ImportAllContracts();
//</snippet9>
}
void DiscoverMexMetadata(object sender, DoWorkEventArgs e)
{
Uri url = (Uri)e.Argument;
var client = new MetadataExchangeClient(url, MetadataExchangeClientMode.MetadataExchange);
MetadataSet metadata = client.GetMetadata();
e.Result = new ServiceReferenceDiscoveryEventArgs(metadata);
}
public static void SetServiceBusCredentials(this MetadataExchangeClient mexClient, string issuer, string secret)
{
Type type = mexClient.GetType();
FieldInfo info = type.GetField("factory", BindingFlags.Instance | BindingFlags.NonPublic);
ChannelFactory <IMetadataExchange> factory = info.GetValue(mexClient) as ChannelFactory <IMetadataExchange>;
factory.SetServiceBusCredentials(issuer, secret);
}
/// <summary>
/// Queries the mex contracts.
/// </summary>
/// <param name="mexAddress">The mex address.</param>
/// <param name="bindingElement">The binding element.</param>
/// <returns>IEnumerable{ContractDescription}.</returns>
static IEnumerable <ContractDescription> QueryMexContracts(string mexAddress, BindingElement bindingElement)
{
var binding = new CustomBinding(bindingElement);
var mexClient = new MetadataExchangeClient(binding);
var metadata = mexClient.GetMetadata(new EndpointAddress(mexAddress));
MetadataImporter importer = new WsdlImporter(metadata);
return(importer.ImportAllContracts());
}
private WsdlImporter ImportWSDL(Uri wsdlLoc)
{
MetadataExchangeClient mexC = new MetadataExchangeClient(wsdlLoc, MetadataExchangeClientMode.HttpGet);
mexC.ResolveMetadataReferences = true;
MetadataSet metaSet = mexC.GetMetadata();
return(new WsdlImporter(metaSet));
}
/// <summary>
/// Queries the mex endpoint.
/// </summary>
/// <param name="mexAddress">The mex address.</param>
/// <param name="bindingElement">The binding element.</param>
/// <returns>ServiceEndpointCollection.</returns>
static ServiceEndpointCollection QueryMexEndpoint(string mexAddress, BindingElement bindingElement)
{
var binding = new CustomBinding(bindingElement);
var mexClient = new MetadataExchangeClient(binding);
var metadata = mexClient.GetMetadata(new EndpointAddress(mexAddress));
MetadataImporter importer = new WsdlImporter(metadata);
return(importer.ImportAllEndpoints());
}
ServiceEndpointCollection GetEndpoints(BindingElement bindingElement)
{
CustomBinding binding = new CustomBinding(bindingElement);
MetadataExchangeClient MEXClient = new MetadataExchangeClient(binding);
MetadataSet metadata = MEXClient.GetMetadata(new EndpointAddress(m_MexAddressTextBox.Text));
MetadataImporter importer = new WsdlImporter(metadata);
return(importer.ImportAllEndpoints());
}
public void CheckWsdl()
{
var metaTransfer =
new MetadataExchangeClient(new Uri(Settings.Default.InforoomOnline_Tests_localhost_InforoomOnlineService + "?wsdl"),
MetadataExchangeClientMode.HttpGet);
metaTransfer.ResolveMetadataReferences = true;
var otherDocs = metaTransfer.GetMetadata();
Assert.That(otherDocs.MetadataSections.Count, Is.GreaterThan(0));
}
static void Main()
{
// Specify the Metadata Exchange binding and its security mode
WSHttpBinding mexBinding = new WSHttpBinding(SecurityMode.Message);
mexBinding.Security.Message.ClientCredentialType = MessageCredentialType.Certificate;
// Create a MetadataExchangeClient for retrieving metadata, and set the certificate details
MetadataExchangeClient mexClient = new MetadataExchangeClient(mexBinding);
mexClient.SoapCredentials.ClientCertificate.SetCertificate(
StoreLocation.CurrentUser, StoreName.My,
X509FindType.FindBySubjectName, "client.com");
mexClient.SoapCredentials.ServiceCertificate.Authentication.CertificateValidationMode = X509CertificateValidationMode.PeerOrChainTrust;
mexClient.SoapCredentials.ServiceCertificate.SetDefaultCertificate(
StoreLocation.CurrentUser, StoreName.TrustedPeople,
X509FindType.FindBySubjectName, "localhost");
// The contract we want to fetch metadata for
Collection <ContractDescription> contracts = new Collection <ContractDescription>();
ContractDescription contract = ContractDescription.GetContract(typeof(ICalculator));
contracts.Add(contract);
// Find endpoints for that contract
EndpointAddress mexAddress = new EndpointAddress(ConfigurationManager.AppSettings["mexAddress"]);
ServiceEndpointCollection endpoints = MetadataResolver.Resolve(contracts,
mexAddress, mexClient);
// Communicate with each endpoint that supports the ICalculator contract.
foreach (ServiceEndpoint endpoint in endpoints)
{
if (endpoint.Contract.Namespace.Equals(contract.Namespace) && endpoint.Contract.Name.Equals(contract.Name))
{
// Create a channel and set the certificate details to communicate with the Application endpoint
ChannelFactory <ICalculator> cf = new ChannelFactory <ICalculator>(endpoint.Binding, endpoint.Address);
cf.Credentials.ClientCertificate.SetCertificate(StoreLocation.CurrentUser, StoreName.My,
X509FindType.FindBySubjectName, "client.com");
cf.Credentials.ServiceCertificate.Authentication.CertificateValidationMode = X509CertificateValidationMode.PeerOrChainTrust;
ICalculator channel = cf.CreateChannel();
// call operations
DoCalculations(channel);
((IChannel)channel).Close();
cf.Close();
}
}
Console.WriteLine();
Console.WriteLine("Press <ENTER> to terminate client.");
Console.ReadLine();
}
private MetadataSet GetMetadata()
{
Debug.Assert(string.IsNullOrWhiteSpace(m_mexAddress) == false);
var mexUri = new Uri(m_mexAddress);
var mexClient = new MetadataExchangeClient(mexUri, MetadataExchangeClientMode.MetadataExchange)
{
ResolveMetadataReferences = true
};
return(mexClient.GetMetadata());
}
static void Main()
{
string outputFile = "c:\\temp\\test";
//<Snippet0>
EndpointAddress mexAddress = new EndpointAddress("http://localhost:8000/ServiceModelSamples/service/mex");
//</Snippet0>
//<Snippet1>
MetadataExchangeClient mexClient = new MetadataExchangeClient(mexAddress);
mexClient.ResolveMetadataReferences = true;
MetadataSet metaSet = mexClient.GetMetadata();
//</Snippet1>
//<Snippet2>
WsdlImporter importer = new WsdlImporter(metaSet);
System.Collections.ObjectModel.Collection <ContractDescription> contracts = importer.ImportAllContracts();
//</Snippet2>
//<Snippet3>
ServiceContractGenerator generator = new ServiceContractGenerator();
foreach (ContractDescription contract in contracts)
{
generator.GenerateServiceContractType(contract);
}
if (generator.Errors.Count != 0)
{
throw new Exception("There were errors during code compilation.");
}
//</Snippet3>
// Write the code dom
//<Snippet4>
System.CodeDom.Compiler.CodeGeneratorOptions options = new System.CodeDom.Compiler.CodeGeneratorOptions();
options.BracingStyle = "C";
System.CodeDom.Compiler.CodeDomProvider codeDomProvider = System.CodeDom.Compiler.CodeDomProvider.CreateProvider("C#");
System.CodeDom.Compiler.IndentedTextWriter textWriter = new System.CodeDom.Compiler.IndentedTextWriter(new System.IO.StreamWriter(outputFile));
codeDomProvider.GenerateCodeFromCompileUnit(generator.TargetCompileUnit, textWriter, options);
textWriter.Close();
//</Snippet4>
Console.WriteLine();
Console.WriteLine("Press <ENTER> to terminate client.");
Console.ReadLine();
}
private IEnumerable <ContractDescription> GetContractsDescriptions()
{
var mexClient = new MetadataExchangeClient(_uri, MetadataExchangeClientMode.HttpGet)
{
ResolveMetadataReferences = true
};
var metaDataSet = mexClient.GetMetadata();
var wdslImporter = new WsdlImporter(metaDataSet);
return(wdslImporter.ImportAllContracts());
}
private MetadataSet DiscoverMetadata(Uri address)
{
if (UriSchemeSupportsDisco(address) &&
!IsMexUri(address))
{
return(GetMetadataWithDiscovery(address));
}
else
{
MetadataExchangeClient metadataTransferClient =
new MetadataExchangeClient(address, MetadataExchangeClientMode.MetadataExchange);
return(metadataTransferClient.GetMetadata());
}
}
static ServiceEndpointCollection QueryMexEndpoint(string mexAddress, BindingElement bindingElement)
{
dynamic element = bindingElement;
element.MaxReceivedMessageSize *= MessageSizeMultiplier;
CustomBinding binding = new CustomBinding(element);
MetadataExchangeClient mexClient = new MetadataExchangeClient(binding);
MetadataSet metadata = mexClient.GetMetadata(new EndpointAddress(mexAddress));
MetadataImporter importer = new WsdlImporter(metadata);
return(importer.ImportAllEndpoints());
}
static void Main(string[] args)
{
Uri address = new Uri("http://127.0.0.1:9999/calculatorservice/metadata");
MetadataExchangeClient metadataExchangeClient = new MetadataExchangeClient(address, MetadataExchangeClientMode.HttpGet);
metadataExchangeClient.ResolveMetadataReferences = false;
MetadataSet metadata = metadataExchangeClient.GetMetadata();
using (XmlWriter writer = new XmlTextWriter("metadata.xml", Encoding.UTF8))
{
metadata.WriteTo(writer);
}
Process.Start("metadata.xml");
}
static void Main(string[] args)
{
Uri uri = new Uri("http://10.157.13.69:3336/mex");
MetadataExchangeClient client = new MetadataExchangeClient(uri, MetadataExchangeClientMode.MetadataExchange);
MetadataSet metadata = client.GetMetadata();
WsdlImporter importer = new WsdlImporter(metadata);
ServiceEndpointCollection endpoints = importer.ImportAllEndpoints();
//ServiceEndpointCollection endpoints = MetadataResolver.Resolve(typeof(IService), uri, MetadataExchangeClientMode.MetadataExchange);
foreach (var item in endpoints)
{
Console.WriteLine(item.Address.Uri);
}
}
static ServiceEndpointCollection QueryMexEndpoint(string mexAddress, Binding binding, string issuer, string secret)
{
dynamic extendedBinding = binding;
extendedBinding.MaxReceivedMessageSize *= MessageSizeMultiplier;
MetadataExchangeClient mexClient = new MetadataExchangeClient(extendedBinding);
mexClient.SetServiceBusCredentials(issuer, secret);
MetadataSet metadata = mexClient.GetMetadata(new EndpointAddress(mexAddress));
MetadataImporter importer = new WsdlImporter(metadata);
return(importer.ImportAllEndpoints());
}
