mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
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
316 lines
13 KiB
C#
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;
|
|
}
|
|
}
|
|
}
|
|
|