public static IAsyncResult BeginResolve(IEnumerable<ContractDescription> contracts, System.ServiceModel.EndpointAddress address, MetadataExchangeClient client, AsyncCallback callback, Object asyncState)
{
Contract.Requires(address != null);
Contract.Ensures(Contract.Result<System.IAsyncResult>() != null);
return default(IAsyncResult);
}
static void UseWcf()
{
/*
动态下载服务元数据
*/
MetadataExchangeClient metaExchangeClient =
new MetadataExchangeClient(
new Uri("http://localhost:8002/ManualService"),
MetadataExchangeClientMode.HttpGet
);
//下载元数据
MetadataSet metadataSet = metaExchangeClient.GetMetadata();
WsdlImporter importer = new WsdlImporter(metadataSet);
ServiceEndpointCollection endpointCollection = importer.ImportAllEndpoints();
IManulService manulProxy = null;
foreach (ServiceEndpoint endPointItem in endpointCollection)
{
manulProxy = new ChannelFactory<IManulService>(
endPointItem.Binding,
endPointItem.Address
).CreateChannel();
((IChannel)manulProxy).Open();
Console.WriteLine("WCF调用结果为：{0}",
manulProxy.GetData());
((IChannel)manulProxy).Close();
}
}
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();
}
/// <summary>
/// Find the wsdl importer
/// </summary>
/// <param name="wsdlUri">The wsdl uri</param>
/// <returns>A wsdl importer</returns>
private WsdlImporter GetWsdlImporter(Uri wsdlUri)
{
WSHttpBinding mexBinding = null;
var mode = System.ServiceModel.Description.MetadataExchangeClientMode.HttpGet;
if (wsdlUri.Scheme == Uri.UriSchemeHttp)
{
mexBinding = (WSHttpBinding)System.ServiceModel.Description.MetadataExchangeBindings.CreateMexHttpBinding();
}
else
{
mexBinding = (WSHttpBinding)System.ServiceModel.Description.MetadataExchangeBindings.CreateMexHttpsBinding();
}
mexBinding.MaxReceivedMessageSize = 2147483647;
mexBinding.MaxBufferPoolSize = int.MaxValue;
mexBinding.ReaderQuotas.MaxStringContentLength = int.MaxValue;
mexBinding.ReaderQuotas.MaxNameTableCharCount = int.MaxValue;
mexBinding.ReaderQuotas.MaxArrayLength = int.MaxValue;
mexBinding.ReaderQuotas.MaxBytesPerRead = int.MaxValue;
mexBinding.ReaderQuotas.MaxDepth = 64;
var mexClient = new System.ServiceModel.Description.MetadataExchangeClient(mexBinding);
mexClient.MaximumResolvedReferences = int.MaxValue;
var metadataSet = mexClient.GetMetadata(wsdlUri, mode);
return(new System.ServiceModel.Description.WsdlImporter(metadataSet));
}
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);
}
internal AsyncMetadataResolverHelper(EndpointAddress address, MetadataExchangeClientMode mode, MetadataExchangeClient client, IEnumerable <ContractDescription> knownContracts, AsyncCallback callback, object asyncState) : base(callback, asyncState)
{
this.address = address;
this.client = client;
this.mode = mode;
this.knownContracts = knownContracts;
this.GetMetadataSetAsync();
}
static ServiceEndpointCollection QueryMexEndpoint(string mexAddress, BindingElement bindingElement)
{
var binding = new CustomBinding(bindingElement);
var MEXClient = new MetadataExchangeClient(binding);
var metadata = MEXClient.GetMetadata(new EndpointAddress(mexAddress));
var importer = new WsdlImporter(metadata);
return importer.ImportAllEndpoints();
}
public static IAsyncResult BeginResolve(IEnumerable<ContractDescription> contracts, Uri address, MetadataExchangeClientMode mode, MetadataExchangeClient client, AsyncCallback callback, Object asyncState)
{
Contract.Requires(address != null);
Contract.Requires(address.IsAbsoluteUri);
Contract.Ensures(Contract.Result<System.IAsyncResult>() != null);
return default(IAsyncResult);
}
static void Main(string[] args)
{
MetadataExchangeClient metadataExchangeClient = new MetadataExchangeClient(new Uri("http://127.0.0.1:3721/calculatorservice/metadata"), 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)
{
Console.WriteLine("URI of the metadata documetns retreived");
//MetadataExchangeClient metaTransfer = new MetadataExchangeClient(new Uri("http://localhost:1169/Service1.svc/mex"), MetadataExchangeClientMode.MetadataExchange);
MetadataExchangeClient metaTransfer = new MetadataExchangeClient(new Uri("http://localhost:1169/Service1.svc"), MetadataExchangeClientMode.HttpGet);
metaTransfer.ResolveMetadataReferences = true;
MetadataSet metadata = metaTransfer.GetMetadata();
foreach (MetadataSection doc in metadata.MetadataSections)
Console.WriteLine(doc.Dialect + " : " + doc.Metadata);
Console.ReadLine();
}
static ServiceEndpointCollection QueryMexEndpoint(string mexAddress,Binding binding,TokenProvider tokenProvider)
{
dynamic extendedBinding = binding;
extendedBinding.MaxReceivedMessageSize *= MessageSizeMultiplier;
MetadataExchangeClient mexClient = new MetadataExchangeClient(extendedBinding);
mexClient.SetServiceBusCredentials(tokenProvider);
MetadataSet metadata = mexClient.GetMetadata(new EndpointAddress(mexAddress));
MetadataImporter importer = new WsdlImporter(metadata);
return importer.ImportAllEndpoints();
}
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();
}
// 5.
public static ServiceEndpointCollection Resolve(
IEnumerable <ContractDescription> contracts,
EndpointAddress address,
MetadataExchangeClient client)
{
if (client == null)
{
throw new ArgumentNullException("client");
}
return(ResolveContracts(contracts, () => client.GetMetadata(address)));
}
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 GetMetaDataDocs(EndpointAddress metadataAddress)
{
var binding = new WSHttpBinding(SecurityMode.Transport);
binding.MaxReceivedMessageSize = Int32.MaxValue;
binding.ReaderQuotas.MaxNameTableCharCount = Int32.MaxValue;
var mexClient = new MetadataExchangeClient(binding)
{
ResolveMetadataReferences = true,
MaximumResolvedReferences = 1000
};
var metaDocs = mexClient.GetMetadata(metadataAddress.Uri, MetadataExchangeClientMode.HttpGet);
return metaDocs;
}
private WsdlImporter CreateImporter(EndPointSetting wsdl)
{
var endpoint = new EndpointAddress(wsdl.Uri);
var binding = new WSHttpBinding(SecurityMode.None)
{
MaxReceivedMessageSize = Int32.MaxValue,
};
var mex = new MetadataExchangeClient(binding);
mex.ResolveMetadataReferences = true;
var metaDocs = mex.GetMetadata(new Uri(wsdl.Uri), MetadataExchangeClientMode.HttpGet);
return new WsdlImporter(metaDocs);
}
public static IAsyncResult BeginResolve(IEnumerable<ContractDescription> contracts, EndpointAddress address, MetadataExchangeClient client, AsyncCallback callback, object asyncState)
{
if (address == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("address");
}
if (client == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("client");
}
if (contracts == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("contracts");
}
ValidateContracts(contracts);
return new AsyncMetadataResolverHelper(address, MetadataExchangeClientMode.MetadataExchange, client, contracts, callback, asyncState);
}
public WebService(string path)
{
var metadataAddress = new EndpointAddress(path);
var mexClient = new MetadataExchangeClient(metadataAddress.Uri, MetadataExchangeClientMode.HttpGet);
mexClient.ResolveMetadataReferences = true;
var metadata = mexClient.GetMetadata(metadataAddress.Uri, MetadataExchangeClientMode.HttpGet);
var metadataSet = new MetadataSet(metadata.MetadataSections);
var importer = new WsdlImporter(metadataSet);
AllWsdlDocuments = importer.WsdlDocuments;
AllContracts = importer.ImportAllContracts();
AllBindings = importer.ImportAllBindings();
AllEndpoints = importer.ImportAllEndpoints();
//AllContracts.First().Operations.First().
}
static void Main(string[] args)
{
Binding binding = MetadataExchangeBindings.CreateMexHttpBinding();
EndpointAddress address = new EndpointAddress("http://127.0.0.1:9999/calculatorservice/mex");
MetadataExchangeClient metadataExchangeClient = new MetadataExchangeClient(binding);
MetadataSet metadata = metadataExchangeClient.GetMetadata(address);
WsdlImporter wsdlImporter = new WsdlImporter(metadata);
//添加已知契约类型
ContractDescription contract = ContractDescription.GetContract(typeof(ICalculator));
wsdlImporter.KnownContracts.Add(new XmlQualifiedName(contract.Name, contract.Namespace), contract);
ServiceEndpointCollection endpoints = wsdlImporter.ImportAllEndpoints();
using (ChannelFactory<ICalculator> channelFactory = new ChannelFactory<ICalculator>(endpoints[0]))
{
ICalculator calculator = channelFactory.CreateChannel();
Console.WriteLine("x + y = {2} when x = {0} and y = {1}", 1, 2, calculator.Add(1, 2));
}
Console.Read();
}
public static ServiceEndpointCollection Resolve(IEnumerable<ContractDescription> contracts, Uri address, MetadataExchangeClientMode mode, MetadataExchangeClient client)
{
if (address == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("address");
}
MetadataExchangeClientModeHelper.Validate(mode);
if (client == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("client");
}
if (contracts == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("contracts");
}
ValidateContracts(contracts);
MetadataSet metadataSet = client.GetMetadata(address, mode);
return ImportEndpoints(metadataSet, contracts, client);
}
private WsdlImporter CreateImporter(EndPointSetting wsdl)
{
var endpoint = new EndpointAddress(wsdl.Uri);
var binding = new WSHttpBinding(SecurityMode.None)
{
MaxReceivedMessageSize = Int32.MaxValue,
};
var mex = new MetadataExchangeClient(binding);
mex.ResolveMetadataReferences = true;
var sections = new SingleEnumerable<EndpointAddress>(endpoint)
.Select(ma => mex.GetMetadata(ma.Uri, MetadataExchangeClientMode.HttpGet))
.SelectMany(mds => mds.MetadataSections);
var metaDocs = new MetadataSet(sections);
return new WsdlImporter(metaDocs);
}
static MetadataSet ResolveWithWSMex (string url)
{
MetadataSet metadata = null;
try {
var 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;
msg = e.InnerException == null ? e.Message : e.InnerException.ToString ();
Console.WriteLine ("WS-MetadataExchange query failed for the url '{0}' with exception :\n {1}",
url, msg);
}
return metadata;
}
static void GenerateVBCodeForService(EndpointAddress metadataAddress, string outputFile)
{
MetadataExchangeClient mexClient = new MetadataExchangeClient(metadataAddress);
mexClient.ResolveMetadataReferences = true;
MetadataSet metaDocs = mexClient.GetMetadata();
WsdlImporter importer = new WsdlImporter(metaDocs);
ServiceContractGenerator generator = new ServiceContractGenerator();
// Uncomment the following code if you are going to do your work programmatically rather than add
// the WsdlDocumentationImporters through a configuration file.
/*
// The following code inserts the custom WSDL programmatically adding the custom WsdlImporter without
// removing the other importers already in the collection.
System.Collections.Generic.IEnumerable<IWsdlImportExtension> exts = importer.WsdlExtensions;
System.Collections.Generic.List<IWsdlImportExtension> newExts = new System.Collections.Generic.List<IWsdlImportExtension>();
foreach (IWsdlImportExtension ext in exts)
newExts.Add(ext);
newExts.Add(new WsdlDocumentationImporter());
importer = new WsdlImporter(newExts.ToArray(), metaDocs.MetadataSections);
*/
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();
}
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();
}
static void Main()
{
// Create a MetadataExchangeClient for retrieving metadata.
EndpointAddress mexAddress = new EndpointAddress(ConfigurationManager.AppSettings["mexAddress"]);
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);
ServiceEndpointCollection endpoints = importer.ImportAllEndpoints();
CalculatorClient client = null;
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.
client = new CalculatorClient(ep.Binding, new EndpointAddress(ep.Address.Uri));
Console.WriteLine("Communicate with endpoint: ");
Console.WriteLine(" AddressPath={0}", ep.Address.Uri.PathAndQuery);
Console.WriteLine(" Binding={0}", ep.Binding.Name);
// call operations
DoCalculations(client);
//Closing the client gracefully closes the connection and cleans up resources
client.Close();
}
}
Console.WriteLine();
Console.WriteLine("Press <ENTER> to terminate client.");
Console.ReadLine();
}
// 6
public static IAsyncResult BeginResolve(IEnumerable <ContractDescription> contracts, Uri address, MetadataExchangeClientMode mode, MetadataExchangeClient client, AsyncCallback callback, object asyncState)
{
return(resolver.BeginInvoke(contracts, () => client.GetMetadata(address, mode), callback, asyncState));
}
void DownloadWeb(model.IProxy proxy, out List<wsdlDescription.ServiceDescription> descriptions, out List<XmlSchema> schemas)
{
descriptions = new List<wsdlDescription.ServiceDescription>();
schemas = new List<XmlSchema>();
MetadataExchangeClient client;
MetadataExchangeClientMode exchangeMode;
if (_wsdlEndpoint.EndsWith("mex")) {
WSHttpBinding mexBinding = utils.BindingWrapper.GetMexBinding(proxy);
client = new MetadataExchangeClient(mexBinding);
exchangeMode = MetadataExchangeClientMode.MetadataExchange;
}
else {
BasicHttpBinding wsdlBinding = utils.BindingWrapper.GetWsdlBinding(proxy);
client = new MetadataExchangeClient(wsdlBinding);
exchangeMode = MetadataExchangeClientMode.HttpGet;
}
client.ResolveMetadataReferences = true;
client.OperationTimeout = new TimeSpan(0, 0, _timeoutInSeconds);
MetadataSet metadata = client.GetMetadata(new Uri(_wsdlEndpoint), exchangeMode);
foreach (var metaDataSection in metadata.MetadataSections) {
if (metaDataSection.Metadata is wsdlDescription.ServiceDescription) {
descriptions.Add((wsdlDescription.ServiceDescription)metaDataSection.Metadata);
}
else if (metaDataSection.Metadata is XmlSchema) {
schemas.Add((XmlSchema)metaDataSection.Metadata);
}
}
}
public void CanPubishMEXEndpointsWithoutBaseAddressesUsingCustomAddress()
{
using (new WindsorContainer()
.AddFacility<WcfFacility>(f =>
{
f.DefaultBinding = new NetTcpBinding { PortSharingEnabled = true };
f.CloseTimeout = TimeSpan.Zero;
}
)
.Register(Component.For<Operations>()
.DependsOn(new { number = 42 })
.AsWcfService(new DefaultServiceModel().AddEndpoints(
WcfEndpoint.ForContract<IOperations>()
.At("net.tcp://localhost/Operations"))
.PublishMetadata(mex => mex.AtAddress("tellMeAboutYourSelf"))
)))
{
var tcpMextClient = new MetadataExchangeClient(new EndpointAddress("net.tcp://localhost/Operations/tellMeAboutYourSelf"));
var tcpMetadata = tcpMextClient.GetMetadata();
Assert.IsNotNull(tcpMetadata);
}
}
public void CanPubishMEXEndpointsUsingDefaults()
{
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())
)
))
{
var tcpMextClient = new MetadataExchangeClient(new EndpointAddress("net.tcp://localhost/Operations/mex"));
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(httpMextClient);
}
}
public static IAsyncResult BeginResolve(IEnumerable <ContractDescription> contracts, System.ServiceModel.EndpointAddress address, MetadataExchangeClient client, AsyncCallback callback, Object asyncState)
{
Contract.Requires(address != null);
Contract.Ensures(Contract.Result <System.IAsyncResult>() != null);
return(default(IAsyncResult));
}
public static IAsyncResult BeginResolve(IEnumerable <ContractDescription> contracts, Uri address, MetadataExchangeClientMode mode, MetadataExchangeClient client, AsyncCallback callback, Object asyncState)
{
Contract.Requires(address != null);
Contract.Requires(address.IsAbsoluteUri);
Contract.Ensures(Contract.Result <System.IAsyncResult>() != null);
return(default(IAsyncResult));
}
public static ServiceEndpointCollection Resolve(IEnumerable <ContractDescription> contracts, Uri address, MetadataExchangeClientMode mode, MetadataExchangeClient client)
{
if (address == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("address");
}
MetadataExchangeClientModeHelper.Validate(mode);
if (client == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("client");
}
if (contracts == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("contracts");
}
ValidateContracts(contracts);
MetadataSet metadataSet = client.GetMetadata(address, mode);
return(ImportEndpoints(metadataSet, contracts, client));
}
private static ServiceEndpointCollection ImportEndpoints(MetadataSet metadataSet, IEnumerable <ContractDescription> contracts, MetadataExchangeClient client)
{
ServiceEndpointCollection endpoints = new ServiceEndpointCollection();
WsdlImporter importer = new WsdlImporter(metadataSet);
// remember the original proxy so user doesn't need to set it again
importer.State.Add(MetadataExchangeClient.MetadataExchangeClientKey, client);
foreach (ContractDescription cd in contracts)
{
importer.KnownContracts.Add(WsdlExporter.WsdlNamingHelper.GetPortTypeQName(cd), cd);
}
foreach (ContractDescription cd in contracts)
{
ServiceEndpointCollection contractEndpoints;
contractEndpoints = importer.ImportEndpoints(cd);
foreach (ServiceEndpoint se in contractEndpoints)
{
endpoints.Add(se);
}
}
//Trace all warnings and errors
if (importer.Errors.Count > 0)
{
TraceWsdlImportErrors(importer);
}
return(endpoints);
}
public static IAsyncResult BeginResolve(IEnumerable <ContractDescription> contracts, Uri address, MetadataExchangeClientMode mode, MetadataExchangeClient client,
AsyncCallback callback, object asyncState)
{
if (address == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("address");
}
MetadataExchangeClientModeHelper.Validate(mode);
if (client == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("client");
}
if (contracts == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("contracts");
}
ValidateContracts(contracts);
return(new AsyncMetadataResolverHelper(new EndpointAddress(address), mode, client, contracts, callback, asyncState));
}
public static ServiceEndpointCollection Resolve(IEnumerable <ContractDescription> contracts, System.ServiceModel.EndpointAddress address, MetadataExchangeClient client)
{
Contract.Requires(address != null);
Contract.Ensures(Contract.Result <System.ServiceModel.Description.ServiceEndpointCollection>() != null);
return(default(ServiceEndpointCollection));
}
private static ServiceEndpointCollection ImportEndpoints(MetadataSet metadataSet, IEnumerable <ContractDescription> contracts, MetadataExchangeClient client)
{
ServiceEndpointCollection endpoints = new ServiceEndpointCollection();
WsdlImporter importer = new WsdlImporter(metadataSet);
importer.State.Add("MetadataExchangeClientKey", client);
foreach (ContractDescription description in contracts)
{
importer.KnownContracts.Add(WsdlExporter.WsdlNamingHelper.GetPortTypeQName(description), description);
}
foreach (ContractDescription description2 in contracts)
{
foreach (ServiceEndpoint endpoint in importer.ImportEndpoints(description2))
{
endpoints.Add(endpoint);
}
}
if (importer.Errors.Count > 0)
{
TraceWsdlImportErrors(importer);
}
return(endpoints);
}
public void ResolveTokenIssuerPolicy(MetadataImporter importer, PolicyConversionContext policyContext, IssuedSecurityTokenParameters parameters)
{
if (policyContext == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("policyContext");
}
if (parameters == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("parameters");
}
EndpointAddress mexAddress = (parameters.IssuerMetadataAddress != null) ? parameters.IssuerMetadataAddress : parameters.IssuerAddress;
if (mexAddress == null || mexAddress.IsAnonymous || mexAddress.Uri.Equals(SelfIssuerUri))
{
return;
}
int maximumRedirections = (int)importer.State[SecurityBindingElementImporter.MaxPolicyRedirectionsKey];
if (maximumRedirections <= 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.MaximumPolicyRedirectionsExceeded)));
}
--maximumRedirections;
//
// Try to retrieve the proxy from the importer.State bag so that we can have secure mex
// and it fails, then we can create a default one
//
MetadataExchangeClient policyFetcher = null;
if ((importer.State != null) && (importer.State.ContainsKey(MetadataExchangeClient.MetadataExchangeClientKey)))
{
policyFetcher = importer.State[MetadataExchangeClient.MetadataExchangeClientKey] as MetadataExchangeClient;
}
if (policyFetcher == null)
policyFetcher = new MetadataExchangeClient(mexAddress);
ServiceEndpointCollection federationEndpoints = null;
MetadataSet metadataSet = null;
Exception mexException = null;
try
{
metadataSet = policyFetcher.GetMetadata(mexAddress);
}
catch (Exception e)
{
if (Fx.IsFatal(e))
throw;
if (e is NullReferenceException)
throw;
mexException = e;
}
//
// DCR 6729: Try the http get option here if mex failed.
//
if (metadataSet == null )
{
try
{
metadataSet = policyFetcher.GetMetadata(mexAddress.Uri, MetadataExchangeClientMode.HttpGet);
}
catch (Exception e)
{
if (Fx.IsFatal(e))
throw;
if (e is NullReferenceException)
throw;
if (mexException == null)
mexException = e;
}
}
if (metadataSet == null)
{
//
// we could not retrieve the metadata from the issuer for some reason
//
if (mexException != null)
importer.Errors.Add(new MetadataConversionError(SR.GetString(SR.UnableToObtainIssuerMetadata, mexAddress, mexException), false));
return;
}
WsdlImporter wsdlImporter;
// NOTE: [....], Policy import/export is seperate from WSDL however, this policy importer
// invokes the WsdlImporter. In the event that the current MetadataImporter is a WsdlImporter,
// we should use it's collection of extensions for the import process. Other wise
WsdlImporter currentWsdlImporter = importer as WsdlImporter;
if (currentWsdlImporter != null)
{
wsdlImporter = new WsdlImporter(metadataSet, importer.PolicyImportExtensions, currentWsdlImporter.WsdlImportExtensions);
}
else
{
wsdlImporter = new WsdlImporter(metadataSet, importer.PolicyImportExtensions, null);
}
//
// Copy the State from the first importer to the second one so that the state can be passed to the second round wsdl retrieval
//
if ((importer.State != null) && (importer.State.ContainsKey(MetadataExchangeClient.MetadataExchangeClientKey)))
{
wsdlImporter.State.Add(MetadataExchangeClient.MetadataExchangeClientKey, importer.State[MetadataExchangeClient.MetadataExchangeClientKey]);
}
wsdlImporter.State.Add(SecurityBindingElementImporter.MaxPolicyRedirectionsKey, maximumRedirections);
federationEndpoints = wsdlImporter.ImportAllEndpoints();
// copy all the import errors into the current metadata importer
for (int i = 0; i < wsdlImporter.Errors.Count; ++i)
{
MetadataConversionError error = wsdlImporter.Errors[i];
importer.Errors.Add(new MetadataConversionError(SR.GetString(SR.ErrorImportingIssuerMetadata, mexAddress, InsertEllipsisIfTooLong(error.Message)), error.IsWarning));
}
if (federationEndpoints != null)
{
AddCompatibleFederationEndpoints(federationEndpoints, parameters);
if (parameters.AlternativeIssuerEndpoints != null && parameters.AlternativeIssuerEndpoints.Count > 0)
{
importer.Errors.Add(new MetadataConversionError(SR.GetString(SR.MultipleIssuerEndpointsFound, mexAddress)));
}
}
}
public static IAsyncResult BeginResolve(Type contract, EndpointAddress address, MetadataExchangeClient client, AsyncCallback callback, object asyncState)
{
return(resolver.BeginInvoke(ToContracts(contract), () => client.GetMetadata(address), callback, asyncState));
}
public static ServiceEndpoint[] GetEndpoints(string mexAddress)
{
if (String.IsNullOrEmpty(mexAddress))
{
Debug.Assert(false, "Empty address");
return null;
}
Uri address = new Uri(mexAddress);
ServiceEndpointCollection endpoints = null;
if (address.Scheme == "http")
{
HttpTransportBindingElement httpBindingElement = new HttpTransportBindingElement();
httpBindingElement.MaxReceivedMessageSize *= MessageSizeMultiplier;
//Try the HTTP MEX Endpoint
try
{
endpoints = QueryMexEndpoint(mexAddress, httpBindingElement);
}
catch
{ }
//Try over HTTP-GET
if (endpoints == null)
{
string httpGetAddress = mexAddress;
if (mexAddress.EndsWith("?wsdl") == false)
{
httpGetAddress += "?wsdl";
}
CustomBinding binding = new CustomBinding(httpBindingElement);
MetadataExchangeClient mexClient = new MetadataExchangeClient(binding);
MetadataSet metadata = mexClient.GetMetadata(new Uri(httpGetAddress), MetadataExchangeClientMode.HttpGet);
MetadataImporter importer = new WsdlImporter(metadata);
endpoints = importer.ImportAllEndpoints();
}
}
if (address.Scheme == "https")
{
HttpsTransportBindingElement httpsBindingElement = new HttpsTransportBindingElement();
httpsBindingElement.MaxReceivedMessageSize *= MessageSizeMultiplier;
//Try the HTTPS MEX Endpoint
try
{
endpoints = QueryMexEndpoint(mexAddress, httpsBindingElement);
}
catch
{ }
//Try over HTTPS-GET
if (endpoints == null)
{
string httpsGetAddress = mexAddress;
if (mexAddress.EndsWith("?wsdl") == false)
{
httpsGetAddress += "?wsdl";
}
CustomBinding binding = new CustomBinding(httpsBindingElement);
MetadataExchangeClient mexClient = new MetadataExchangeClient(binding);
MetadataSet metadata = mexClient.GetMetadata(new Uri(httpsGetAddress), MetadataExchangeClientMode.HttpGet);
MetadataImporter importer = new WsdlImporter(metadata);
endpoints = importer.ImportAllEndpoints();
}
}
if (address.Scheme == "net.tcp")
{
TcpTransportBindingElement tcpBindingElement = new TcpTransportBindingElement();
tcpBindingElement.MaxReceivedMessageSize *= MessageSizeMultiplier;
endpoints = QueryMexEndpoint(mexAddress, tcpBindingElement);
}
if (address.Scheme == "net.pipe")
{
NamedPipeTransportBindingElement ipcBindingElement = new NamedPipeTransportBindingElement();
ipcBindingElement.MaxReceivedMessageSize *= MessageSizeMultiplier;
endpoints = QueryMexEndpoint(mexAddress, ipcBindingElement);
}
return endpoints.ToArray();
}
private static MetadataExchangeClient CreateMetadataExchangeClient(Uri serviceUri)
{
string scheme = serviceUri.Scheme;
MetadataExchangeClient result = null;
if (string.Compare(scheme, Uri.UriSchemeHttp, StringComparison.OrdinalIgnoreCase) == 0)
{
WSHttpBinding wSHttpBinding = (WSHttpBinding)MetadataExchangeBindings.CreateMexHttpBinding();
wSHttpBinding.MaxReceivedMessageSize = 67108864L;
wSHttpBinding.ReaderQuotas.MaxNameTableCharCount = 1048576;
result = new MetadataExchangeClient(wSHttpBinding);
}
else
{
if (string.Compare(scheme, Uri.UriSchemeHttps, StringComparison.OrdinalIgnoreCase) == 0)
{
WSHttpBinding wSHttpBinding2 = (WSHttpBinding)MetadataExchangeBindings.CreateMexHttpsBinding();
wSHttpBinding2.MaxReceivedMessageSize = 67108864L;
wSHttpBinding2.ReaderQuotas.MaxNameTableCharCount = 1048576;
result = new MetadataExchangeClient(wSHttpBinding2);
}
else
{
if (string.Compare(scheme, Uri.UriSchemeNetTcp, StringComparison.OrdinalIgnoreCase) == 0)
{
CustomBinding tcpBinding = (CustomBinding)MetadataExchangeBindings.CreateMexTcpBinding();
tcpBinding.Elements.Find<TcpTransportBindingElement>().MaxReceivedMessageSize = 67108864L;
result = new MetadataExchangeClient(tcpBinding);
}
else if (string.Compare(scheme, Uri.UriSchemeNetPipe, StringComparison.OrdinalIgnoreCase) != 0)
{
CustomBinding namedPipeBinding = (CustomBinding)MetadataExchangeBindings.CreateMexNamedPipeBinding();
namedPipeBinding.Elements.Find<NamedPipeTransportBindingElement>().MaxReceivedMessageSize = 67108864L;
result = new MetadataExchangeClient(namedPipeBinding);
}
}
}
return result;
}
public static ServiceEndpoint[] GetEndpoints(string mexAddress)
{
if(string.IsNullOrWhiteSpace(mexAddress))
{
throw new ArgumentException("mexAddress");
}
Uri address = new Uri(mexAddress);
ServiceEndpointCollection endpoints = null;
BindingElement bindingElement = null;
//Try over HTTP-GET first
if(address.Scheme == Uri.UriSchemeHttp || address.Scheme == Uri.UriSchemeHttps)
{
string getAddress = mexAddress;
if(mexAddress.EndsWith("?wsdl") == false)
{
getAddress += "?wsdl";
}
if(address.Scheme == Uri.UriSchemeHttp)
{
HttpTransportBindingElement httpBindingElement = new HttpTransportBindingElement();
httpBindingElement.MaxReceivedMessageSize *= MessageSizeMultiplier;
bindingElement = httpBindingElement;
}
else
{
HttpsTransportBindingElement httpsBindingElement = new HttpsTransportBindingElement();
httpsBindingElement.MaxReceivedMessageSize *= MessageSizeMultiplier;
bindingElement = httpsBindingElement;
}
CustomBinding binding = new CustomBinding(bindingElement);
MetadataExchangeClient mexClient = new MetadataExchangeClient(binding);
MetadataSet metadata = mexClient.GetMetadata(new Uri(getAddress),MetadataExchangeClientMode.HttpGet);
MetadataImporter importer = new WsdlImporter(metadata);
endpoints = importer.ImportAllEndpoints();
return endpoints.ToArray();
}
//Try MEX endpoint:
if(address.Scheme == Uri.UriSchemeHttp)
{
bindingElement = new HttpTransportBindingElement();
}
if(address.Scheme == Uri.UriSchemeHttps)
{
bindingElement = new HttpsTransportBindingElement();
}
if(address.Scheme == Uri.UriSchemeNetTcp)
{
bindingElement = new TcpTransportBindingElement();
}
if(address.Scheme == Uri.UriSchemeNetPipe)
{
bindingElement = new NamedPipeTransportBindingElement();
}
endpoints = QueryMexEndpoint(mexAddress,bindingElement);
return endpoints.ToArray();
}
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;
}