Files
mono/mcs/class/referencesource/System.ServiceModel/System/ServiceModel/ServiceConfiguration.cs
T
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

349 lines
14 KiB
C#

// <copyright>
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
namespace System.ServiceModel
{
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IdentityModel.Configuration;
using System.Linq;
using System.ServiceModel.Channels;
using System.ServiceModel.Description;
/// <summary>
/// Facade over ServiceHost to use in programmatic configuration.
/// </summary>
public class ServiceConfiguration
{
private ServiceHost host;
// ServiceConfiguration is a facade over a ServiceHost
internal ServiceConfiguration(ServiceHost host)
{
CheckArgument(host, "host");
this.host = host;
}
/// <summary>
/// Gets a complete, in-memory description of the service being configured, including all the endpoints for the service and specifications for their respective addresses, bindings, contracts and behaviors.
/// </summary>
public ServiceDescription Description
{
get
{
return this.host.Description;
}
}
/// <summary>
/// Gets the ServiceAuthenticationBehavior currently enabled on the service's Description.
/// </summary>
public ServiceAuthenticationBehavior Authentication
{
get
{
return this.host.Authentication;
}
}
/// <summary>
/// Gets the ServiceAuthorizationBehavior currently enabled on the service's Description.
/// </summary>
public ServiceAuthorizationBehavior Authorization
{
get
{
return this.host.Authorization;
}
}
/// <summary>
/// Gets the ServiceCredentials currently enabled on the service's Description.
/// </summary>
public ServiceCredentials Credentials
{
get
{
return this.host.Credentials;
}
}
/// <summary>
/// Gets the base addresses for the service as specified by the underlying ServiceHost.
/// </summary>
public ReadOnlyCollection<Uri> BaseAddresses
{
get
{
return this.host.BaseAddresses;
}
}
/// <summary>
/// Gets or sets OpenTimeout for the underlying ServiceHost
/// </summary>
public TimeSpan OpenTimeout
{
get
{
return this.host.OpenTimeout;
}
set
{
this.host.OpenTimeout = value;
}
}
/// <summary>
/// Gets or sets CloseTimeout for the underlying ServiceHost
/// </summary>
public TimeSpan CloseTimeout
{
get
{
return this.host.CloseTimeout;
}
set
{
this.host.CloseTimeout = value;
}
}
/// <summary>
/// Gets or sets a value indicating whether to use token handlers
/// </summary>
public bool UseIdentityConfiguration
{
get
{
return this.Credentials.UseIdentityConfiguration;
}
set
{
this.Credentials.UseIdentityConfiguration = value;
}
}
/// <summary>
/// Gets or sets IdentityConfiguration for the underlying ServiceHost
/// </summary>
public IdentityConfiguration IdentityConfiguration
{
get
{
return this.Credentials.IdentityConfiguration;
}
set
{
this.Credentials.IdentityConfiguration = value;
}
}
/// <summary>
/// Validate a service endpoint and add it to Description
/// </summary>
/// <param name="endpoint">endpoint to add</param>
public void AddServiceEndpoint(ServiceEndpoint endpoint)
{
CheckArgument(endpoint, "endpoint");
// Do some other checks to match ServiceHostBase.AddServiceEndpoint
if ((this.host.State != CommunicationState.Created) && (this.host.State != CommunicationState.Opening))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString("SFxServiceHostBaseCannotAddEndpointAfterOpen")));
}
if (this.Description == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString("SFxServiceHostBaseCannotAddEndpointWithoutDescription")));
}
if (endpoint.Address == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SR.GetString("SFxEndpointAddressNotSpecified"));
}
if (endpoint.Contract == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SR.GetString("SFxEndpointContractNotSpecified"));
}
if (endpoint.Binding == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SR.GetString("SFxEndpointBindingNotSpecified"));
}
if (!endpoint.IsSystemEndpoint || (endpoint.Contract.ContractType == typeof(IMetadataExchange)))
{
// Throw if contract is not valid for this service
// i.e. if contract is not implemented by service, unless endpoint is a standard endpoint
// note: (metadata endpoints require metadata behavior to implement IMetadataExchange even though it's a standard endpoint)
IContractResolver resolver = this.host.GetContractResolver(this.host.ImplementedContracts);
ConfigLoader configLoader = new ConfigLoader(resolver);
configLoader.LookupContract(endpoint.Contract.ConfigurationName, this.Description.Name); // throws on failure
}
this.Description.Endpoints.Add(endpoint);
}
/// <summary>
/// Create a new service endpoint and add it to Description
/// </summary>
/// <param name="contractType">interface annotated with [ServiceContract]</param>
/// <param name="binding">protocol to use for communication</param>
/// <param name="address">absolute address for service, or address relative to base address for supplied binding</param>
/// <returns>The endpoint which was created</returns>
public ServiceEndpoint AddServiceEndpoint(Type contractType, Binding binding, string address)
{
CheckArgument(address, "address");
return this.AddServiceEndpoint(contractType, binding, new Uri(address, UriKind.RelativeOrAbsolute));
}
/// <summary>
/// Create a new service endpoint and add it to Description
/// </summary>
/// <param name="contractType">interface annotated with [ServiceContract]</param>
/// <param name="binding">protocol to use for communication</param>
/// <param name="address">absolute address for service, or address relative to base address for supplied binding</param>
/// <returns>The endpoint which was created</returns>
public ServiceEndpoint AddServiceEndpoint(Type contractType, Binding binding, Uri address)
{
CheckArgument(contractType, "contractType");
CheckArgument(binding, "binding");
CheckArgument(address, "address");
ContractDescription contract = this.host.ImplementedContracts == null
? null
: this.host.ImplementedContracts.Values.FirstOrDefault(implementedContract => implementedContract.ContractType == contractType);
if (contract == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("contractType", SR.GetString(SR.SFxMethodNotSupportedByType2, this.host.Description.ServiceType, contractType));
}
ServiceEndpoint endpoint = new ServiceEndpoint(contract, binding, new EndpointAddress(ServiceHost.MakeAbsoluteUri(address, binding, this.host.InternalBaseAddresses)));
this.AddServiceEndpoint(endpoint);
return endpoint;
}
/// <summary>
/// Create a new service endpoint and add it to Description
/// </summary>
/// <param name="contractType">interface annotated with [ServiceContract]</param>
/// <param name="binding">protocol to use for communication</param>
/// <param name="address">absolute logical address for service, or address relative to base address for supplied binding</param>
/// <param name="listenUri">absolute physical address for service, or address relative to base address for supplied binding</param>
/// <returns>The endpoint which was created</returns>
public ServiceEndpoint AddServiceEndpoint(Type contractType, Binding binding, string address, Uri listenUri)
{
CheckArgument(listenUri, "listenUri");
ServiceEndpoint endpoint = this.AddServiceEndpoint(contractType, binding, address);
this.SetListenUri(endpoint, binding, listenUri);
return endpoint;
}
/// <summary>
/// Create a new service endpoint and add it to Description
/// </summary>
/// <param name="contractType">interface annotated with [ServiceContract]</param>
/// <param name="binding">protocol to use for communication</param>
/// <param name="address">absolute logical address for service, or address relative to base address for supplied binding</param>
/// <param name="listenUri">absolute physical address for service, or address relative to base address for supplied binding</param>
/// <returns>The endpoint which was created</returns>
public ServiceEndpoint AddServiceEndpoint(Type contractType, Binding binding, Uri address, Uri listenUri)
{
CheckArgument(listenUri, "listenUri");
ServiceEndpoint endpoint = this.AddServiceEndpoint(contractType, binding, address);
this.SetListenUri(endpoint, binding, listenUri);
return endpoint;
}
/// <summary>
/// Convenience method to compute and set endpoint's address
/// </summary>
/// <param name="endpoint">endpoint to set</param>
/// <param name="relativeAddress">address relative to the ServiceHost's base address, if any, for endpoint's current binding</param>
public void SetEndpointAddress(ServiceEndpoint endpoint, string relativeAddress)
{
CheckArgument(endpoint, "endpoint");
CheckArgument(relativeAddress, "relativeAddress");
this.host.SetEndpointAddress(endpoint, relativeAddress);
}
/// <summary>
/// Automatically add endpoints for all of a service's enabled contracts, for all of its enabled base addresses that match the specified binding.
/// </summary>
/// <param name="protocol">Binding to add endpoints for</param>
/// <returns>Endpoints created</returns>
public Collection<ServiceEndpoint> EnableProtocol(Binding protocol)
{
CheckArgument(protocol, "protocol");
Collection<ServiceEndpoint> generatedEndpoints = new Collection<ServiceEndpoint>();
if (this.host.ImplementedContracts != null)
{
// don't generate endpoints for contracts that serve as the base type for other reflected contracts
IEnumerable<ContractDescription> contracts = this.host.ImplementedContracts.Values;
IEnumerable<ContractDescription> mostSpecificContracts = contracts.Where(contract
=> contracts.All(otherContract
=> object.ReferenceEquals(contract, otherContract)
|| !contract.ContractType.IsAssignableFrom(otherContract.ContractType)));
foreach (var uri in this.host.BaseAddresses)
{
if (uri.Scheme.Equals(protocol.Scheme))
{
foreach (ContractDescription contract in mostSpecificContracts)
{
ServiceEndpoint endpoint = new ServiceEndpoint(contract, protocol, new EndpointAddress(uri));
this.AddServiceEndpoint(endpoint);
generatedEndpoints.Add(endpoint);
}
}
}
}
return generatedEndpoints;
}
/// <summary>
/// Load endpoints and behaviors into service Description from current AppDomain's configuration
/// </summary>
public void LoadFromConfiguration()
{
this.host.LoadFromConfiguration();
}
/// <summary>
/// Load endpoints and behaviors into service Description from supplied configuration
/// </summary>
/// <param name="configuration">configuration to load from</param>
public void LoadFromConfiguration(System.Configuration.Configuration configuration)
{
CheckArgument(configuration, "configuration");
this.host.LoadFromConfiguration(configuration);
}
private static void CheckArgument<T>(T argument, string argumentName)
{
if (argument == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(argumentName);
}
}
private void SetListenUri(ServiceEndpoint endpoint, Binding binding, Uri listenUri)
{
endpoint.UnresolvedListenUri = listenUri;
endpoint.ListenUri = ServiceHost.MakeAbsoluteUri(listenUri, binding, this.host.InternalBaseAddresses);
}
}
}