Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

316 lines
13 KiB
C#

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.ServiceModel.Description
{
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Runtime;
using System.Runtime.Diagnostics;
using System.ServiceModel;
using System.ServiceModel.Diagnostics;
using System.Xml;
public static class MetadataResolver
{
public static ServiceEndpointCollection Resolve(Type contract, EndpointAddress address)
{
if (contract == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("contract");
}
return Resolve(CreateContractCollection(contract), address);
}
public static ServiceEndpointCollection Resolve(IEnumerable<ContractDescription> contracts, EndpointAddress address)
{
return Resolve(contracts, address, new MetadataExchangeClient(address));
}
public static ServiceEndpointCollection Resolve(IEnumerable<ContractDescription> contracts, EndpointAddress address, MetadataExchangeClient client)
{
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);
MetadataSet metadataSet = client.GetMetadata(address);
return ImportEndpoints(metadataSet, contracts, client);
}
public static ServiceEndpointCollection Resolve(Type contract, Uri address, MetadataExchangeClientMode mode)
{
if (contract == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("contract");
}
return Resolve(CreateContractCollection(contract), address, mode);
}
public static ServiceEndpointCollection Resolve(IEnumerable<ContractDescription> contracts, Uri address, MetadataExchangeClientMode mode)
{
return Resolve(contracts, address, mode, new MetadataExchangeClient(address, mode));
}
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);
}
public static IAsyncResult BeginResolve(Type contract, EndpointAddress address, AsyncCallback callback, object asyncState)
{
if (contract == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("contract");
}
return BeginResolve(CreateContractCollection(contract), address, callback, asyncState);
}
public static IAsyncResult BeginResolve(IEnumerable<ContractDescription> contracts, EndpointAddress address, AsyncCallback callback, object asyncState)
{
return BeginResolve(contracts, address, new MetadataExchangeClient(address), callback, asyncState);
}
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 static IAsyncResult BeginResolve(Type contract, Uri address, MetadataExchangeClientMode mode, AsyncCallback callback, object asyncState)
{
if (contract == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("contract");
}
return BeginResolve(CreateContractCollection(contract), address, mode, callback, asyncState);
}
public static IAsyncResult BeginResolve(IEnumerable<ContractDescription> contracts, Uri address, MetadataExchangeClientMode mode, AsyncCallback callback, object asyncState)
{
return BeginResolve(contracts, address, mode, new MetadataExchangeClient(address, mode), callback, asyncState);
}
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 EndResolve(IAsyncResult result)
{
return AsyncMetadataResolverHelper.EndAsyncCall(result);
}
class AsyncMetadataResolverHelper : AsyncResult
{
MetadataExchangeClient client;
EndpointAddress address;
ServiceEndpointCollection endpointCollection;
MetadataExchangeClientMode mode;
IEnumerable<ContractDescription> knownContracts;
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;
GetMetadataSetAsync();
}
internal void GetMetadataSetAsync()
{
IAsyncResult result;
if (this.mode == MetadataExchangeClientMode.HttpGet)
{
result = this.client.BeginGetMetadata(this.address.Uri, MetadataExchangeClientMode.HttpGet, Fx.ThunkCallback(new AsyncCallback(this.EndGetMetadataSet)), null);
}
else
{
result = this.client.BeginGetMetadata(this.address, Fx.ThunkCallback(new AsyncCallback(this.EndGetMetadataSet)), null);
}
if (result.CompletedSynchronously)
{
HandleResult(result);
this.Complete(true);
}
}
internal void EndGetMetadataSet(IAsyncResult result)
{
if (result.CompletedSynchronously)
return;
Exception exception = null;
try
{
HandleResult(result);
}
catch (Exception e)
{
if (Fx.IsFatal(e))
throw;
exception = e;
}
this.Complete(false, exception);
}
private void HandleResult(IAsyncResult result)
{
MetadataSet metadataSet = this.client.EndGetMetadata(result);
endpointCollection = ImportEndpoints(metadataSet, knownContracts, this.client);
}
internal static ServiceEndpointCollection EndAsyncCall(IAsyncResult result)
{
AsyncMetadataResolverHelper helper = AsyncResult.End<AsyncMetadataResolverHelper>(result);
return helper.endpointCollection;
}
}
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;
}
static void TraceWsdlImportErrors(WsdlImporter importer)
{
foreach (MetadataConversionError error in importer.Errors)
{
if (DiagnosticUtility.ShouldTraceWarning)
{
Hashtable h = new Hashtable(2)
{
{ "IsWarning", error.IsWarning },
{ "Message", error.Message }
};
TraceUtility.TraceEvent(TraceEventType.Warning, TraceCode.WsmexNonCriticalWsdlExportError,
SR.GetString(SR.TraceCodeWsmexNonCriticalWsdlExportError), new DictionaryTraceRecord(h), null, null);
}
}
}
private static void ValidateContracts(IEnumerable<ContractDescription> contracts)
{
bool isEmpty = true;
Collection<XmlQualifiedName> qnames = new Collection<XmlQualifiedName>();
foreach (ContractDescription cd in contracts)
{
isEmpty = false;
if (cd == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SR.GetString(SR.SFxMetadataResolverKnownContractsCannotContainNull));
}
XmlQualifiedName qname = WsdlExporter.WsdlNamingHelper.GetPortTypeQName(cd);
if (qnames.Contains(qname))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SR.GetString(SR.SFxMetadataResolverKnownContractsUniqueQNames, qname.Name, qname.Namespace));
}
qnames.Add(qname);
}
if (isEmpty)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SR.GetString(SR.SFxMetadataResolverKnownContractsArgumentCannotBeEmpty));
}
}
private static Collection<ContractDescription> CreateContractCollection(Type contract)
{
Collection<ContractDescription> contracts = new Collection<ContractDescription>();
contracts.Add(ContractDescription.GetContract(contract));
return contracts;
}
}
}