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
283 lines
11 KiB
C#
283 lines
11 KiB
C#
//----------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//----------------------------------------------------------------
|
|
|
|
namespace System.ServiceModel.Routing
|
|
{
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.Runtime;
|
|
using System.ServiceModel;
|
|
using System.ServiceModel.Activation;
|
|
using System.ServiceModel.Channels;
|
|
using System.ServiceModel.Description;
|
|
using System.ServiceModel.Dispatcher;
|
|
|
|
[Fx.Tag.XamlVisible(false)]
|
|
public sealed class RoutingBehavior : IServiceBehavior
|
|
{
|
|
RoutingConfiguration configuration;
|
|
|
|
public RoutingBehavior(RoutingConfiguration routingConfiguration)
|
|
{
|
|
if (routingConfiguration == null)
|
|
{
|
|
throw FxTrace.Exception.ArgumentNull("routingConfiguration");
|
|
}
|
|
|
|
this.configuration = routingConfiguration;
|
|
}
|
|
|
|
void IServiceBehavior.AddBindingParameters(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase, Collection<ServiceEndpoint> endpoints, BindingParameterCollection bindingParameters)
|
|
{
|
|
}
|
|
|
|
void IServiceBehavior.ApplyDispatchBehavior(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase)
|
|
{
|
|
RoutingExtension routingExtension = new RoutingExtension(this.configuration);
|
|
serviceHostBase.Extensions.Add(routingExtension);
|
|
for (int i = 0; i < serviceHostBase.ChannelDispatchers.Count; i++)
|
|
{
|
|
ChannelDispatcher channelDispatcher = serviceHostBase.ChannelDispatchers[i] as ChannelDispatcher;
|
|
if (channelDispatcher != null)
|
|
{
|
|
foreach (EndpointDispatcher endpointDispatcher in channelDispatcher.Endpoints)
|
|
{
|
|
if (!endpointDispatcher.IsSystemEndpoint &&
|
|
RoutingUtilities.IsRoutingServiceNamespace(endpointDispatcher.ContractNamespace))
|
|
{
|
|
DispatchRuntime dispatchRuntime = endpointDispatcher.DispatchRuntime;
|
|
//Since we use PerSession instancing this concurrency only applies to messages
|
|
//in the same session, also needed to maintain order.
|
|
dispatchRuntime.ConcurrencyMode = ConcurrencyMode.Single;
|
|
dispatchRuntime.EnsureOrderedDispatch = this.configuration.EnsureOrderedDispatch;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void IServiceBehavior.Validate(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase)
|
|
{
|
|
HashSet<string> endpoints = new HashSet<string>();
|
|
foreach (ServiceEndpoint endpoint in serviceDescription.Endpoints)
|
|
{
|
|
if (!endpoint.IsSystemEndpoint &&
|
|
RoutingUtilities.IsRoutingServiceNamespace(endpoint.Contract.Namespace))
|
|
{
|
|
endpoint.Behaviors.Add(new RoutingEndpointBehavior(endpoint));
|
|
endpoints.Add(endpoint.Name);
|
|
}
|
|
}
|
|
EndpointNameMessageFilter.Validate(this.configuration.InternalFilterTable.Keys, endpoints);
|
|
}
|
|
|
|
public static Type GetContractForDescription(ContractDescription description)
|
|
{
|
|
if (description == null)
|
|
{
|
|
throw FxTrace.Exception.ArgumentNull("description");
|
|
}
|
|
|
|
if (description.CallbackContractType != null)
|
|
{
|
|
return typeof(IDuplexSessionRouter);
|
|
}
|
|
|
|
bool allOneWay = true;
|
|
foreach (OperationDescription operation in description.Operations)
|
|
{
|
|
if (!operation.IsOneWay)
|
|
{
|
|
allOneWay = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (allOneWay)
|
|
{
|
|
if (description.SessionMode == SessionMode.Required)
|
|
{
|
|
return typeof(ISimplexSessionRouter);
|
|
}
|
|
else
|
|
{
|
|
return typeof(ISimplexDatagramRouter);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return typeof(IRequestReplyRouter);
|
|
}
|
|
}
|
|
|
|
internal class RoutingEndpointBehavior : IEndpointBehavior, IChannelInitializer, IInputSessionShutdown
|
|
{
|
|
public RoutingEndpointBehavior(ServiceEndpoint endpoint)
|
|
{
|
|
this.Endpoint = endpoint;
|
|
this.EndpointName = endpoint.Name;
|
|
}
|
|
|
|
internal ChannelDispatcher ChannelDispatcher
|
|
{
|
|
get;
|
|
private set;
|
|
}
|
|
|
|
internal ServiceEndpoint Endpoint
|
|
{
|
|
get;
|
|
private set;
|
|
}
|
|
|
|
internal string EndpointName
|
|
{
|
|
get;
|
|
private set;
|
|
}
|
|
|
|
internal bool ImpersonationRequired
|
|
{
|
|
get;
|
|
private set;
|
|
}
|
|
|
|
internal bool ReceiveContextEnabled
|
|
{
|
|
get;
|
|
private set;
|
|
}
|
|
|
|
internal bool TransactedReceiveEnabled
|
|
{
|
|
get;
|
|
private set;
|
|
}
|
|
|
|
public void AddBindingParameters(ServiceEndpoint endpoint, BindingParameterCollection bindingParameters)
|
|
{
|
|
//Turn on ReceiveContext here if supported
|
|
IReceiveContextSettings receiveContextSettings = endpoint.Binding.GetProperty<IReceiveContextSettings>(bindingParameters);
|
|
if (receiveContextSettings != null)
|
|
{
|
|
receiveContextSettings.Enabled = true;
|
|
}
|
|
}
|
|
|
|
public void ApplyClientBehavior(ServiceEndpoint endpoint, ClientRuntime clientRuntime)
|
|
{
|
|
}
|
|
|
|
public void ApplyDispatchBehavior(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher)
|
|
{
|
|
this.ChannelDispatcher = endpointDispatcher.ChannelDispatcher;
|
|
this.ChannelDispatcher.ChannelInitializers.Add(this);
|
|
endpointDispatcher.DispatchRuntime.InputSessionShutdownHandlers.Add(this);
|
|
endpointDispatcher.DispatchRuntime.AutomaticInputSessionShutdown = false;
|
|
|
|
if (endpointDispatcher.DispatchRuntime.ImpersonateCallerForAllOperations)
|
|
{
|
|
this.ImpersonationRequired = true;
|
|
}
|
|
else if (AspNetEnvironment.Current.AspNetCompatibilityEnabled)
|
|
{
|
|
this.ImpersonationRequired = true;
|
|
}
|
|
|
|
BindingParameterCollection bindingParams = new BindingParameterCollection();
|
|
if (RoutingUtilities.IsTransactedReceive(endpoint.Binding, bindingParams))
|
|
{
|
|
foreach (OperationDescription operation in endpoint.Contract.Operations)
|
|
{
|
|
if (operation.Behaviors.Find<TransactedReceiveOperationBehavior>() == null)
|
|
{
|
|
operation.Behaviors.Add(new TransactedReceiveOperationBehavior());
|
|
}
|
|
}
|
|
this.ChannelDispatcher.IsTransactedReceive = true;
|
|
endpointDispatcher.DispatchRuntime.TransactionAutoCompleteOnSessionClose = true;
|
|
this.TransactedReceiveEnabled = true;
|
|
}
|
|
|
|
IReceiveContextSettings rcSettings = endpoint.Binding.GetProperty<IReceiveContextSettings>(bindingParams);
|
|
if (rcSettings != null && rcSettings.Enabled)
|
|
{
|
|
foreach (OperationDescription operation in endpoint.Contract.Operations)
|
|
{
|
|
ReceiveContextEnabledAttribute rcEnabled = new ReceiveContextEnabledAttribute();
|
|
rcEnabled.ManualControl = true;
|
|
operation.Behaviors.Add(rcEnabled);
|
|
}
|
|
this.ReceiveContextEnabled = true;
|
|
|
|
//Switch TransactedReceive off, because we don't want the Dispatcher creating any Transaction
|
|
endpointDispatcher.ChannelDispatcher.IsTransactedReceive = false;
|
|
endpointDispatcher.DispatchRuntime.TransactionAutoCompleteOnSessionClose = false;
|
|
}
|
|
}
|
|
|
|
public void Validate(ServiceEndpoint endpoint)
|
|
{
|
|
}
|
|
|
|
void IChannelInitializer.Initialize(IClientChannel channel)
|
|
{
|
|
RoutingChannelExtension channelState = RoutingChannelExtension.Create(this);
|
|
channel.Extensions.Add(channelState);
|
|
}
|
|
|
|
void IInputSessionShutdown.ChannelFaulted(IDuplexContextChannel channel)
|
|
{
|
|
RoutingChannelExtension channelExtension = channel.Extensions.Find<RoutingChannelExtension>();
|
|
if (channelExtension != null)
|
|
{
|
|
channelExtension.Fault(new CommunicationObjectFaultedException());
|
|
}
|
|
else
|
|
{
|
|
RoutingUtilities.Abort(channel, channel.LocalAddress);
|
|
}
|
|
}
|
|
|
|
void IInputSessionShutdown.DoneReceiving(IDuplexContextChannel channel)
|
|
{
|
|
RoutingChannelExtension channelExtension = channel.Extensions.Find<RoutingChannelExtension>();
|
|
channelExtension.DoneReceiving(this.Endpoint.Binding.CloseTimeout);
|
|
}
|
|
}
|
|
|
|
class TransactedReceiveOperationBehavior : IOperationBehavior
|
|
{
|
|
public void AddBindingParameters(OperationDescription operationDescription, BindingParameterCollection bindingParameters)
|
|
{
|
|
}
|
|
|
|
public void ApplyClientBehavior(OperationDescription operationDescription, ClientOperation clientOperation)
|
|
{
|
|
}
|
|
|
|
public void ApplyDispatchBehavior(OperationDescription operationDescription, DispatchOperation dispatchOperation)
|
|
{
|
|
if (operationDescription.Behaviors.Find<ReceiveContextEnabledAttribute>() == null)
|
|
{
|
|
dispatchOperation.TransactionRequired = true;
|
|
}
|
|
|
|
ContractDescription contract = operationDescription.DeclaringContract;
|
|
if (dispatchOperation.IsOneWay && contract.SessionMode == SessionMode.Required)
|
|
{
|
|
dispatchOperation.Parent.ConcurrencyMode = ConcurrencyMode.Single;
|
|
dispatchOperation.Parent.ReleaseServiceInstanceOnTransactionComplete = false;
|
|
dispatchOperation.TransactionAutoComplete = false;
|
|
}
|
|
}
|
|
|
|
public void Validate(OperationDescription operationDescription)
|
|
{
|
|
}
|
|
}
|
|
}
|
|
}
|