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
734 lines
31 KiB
C#
734 lines
31 KiB
C#
//-----------------------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
namespace System.ServiceModel.Activities
|
|
{
|
|
using System.Activities;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.Net.Security;
|
|
using System.Runtime;
|
|
using System.ServiceModel.Activities.Description;
|
|
using System.ServiceModel.Channels;
|
|
using System.ServiceModel.Description;
|
|
using System.Xml;
|
|
using System.Xml.Linq;
|
|
|
|
static class ContractInferenceHelper
|
|
{
|
|
static DataContractFormatAttribute dataContractFormatAttribute;
|
|
static XmlSerializerFormatAttribute xmlSerializerFormatAttribute;
|
|
static Type exceptionType;
|
|
static Type faultExceptionType;
|
|
|
|
public static DataContractFormatAttribute DataContractFormatAttribute
|
|
{
|
|
get
|
|
{
|
|
if (dataContractFormatAttribute == null)
|
|
{
|
|
dataContractFormatAttribute = new DataContractFormatAttribute();
|
|
}
|
|
return dataContractFormatAttribute;
|
|
}
|
|
}
|
|
|
|
public static XmlSerializerFormatAttribute XmlSerializerFormatAttribute
|
|
{
|
|
get
|
|
{
|
|
if (xmlSerializerFormatAttribute == null)
|
|
{
|
|
xmlSerializerFormatAttribute = new XmlSerializerFormatAttribute
|
|
{
|
|
SupportFaults = true
|
|
};
|
|
}
|
|
return xmlSerializerFormatAttribute;
|
|
}
|
|
}
|
|
|
|
public static Type ExceptionType
|
|
{
|
|
get
|
|
{
|
|
if (exceptionType == null)
|
|
{
|
|
exceptionType = typeof(Exception);
|
|
}
|
|
return exceptionType;
|
|
}
|
|
}
|
|
|
|
public static Type FaultExceptionType
|
|
{
|
|
get
|
|
{
|
|
if (faultExceptionType == null)
|
|
{
|
|
faultExceptionType = typeof(FaultException<>);
|
|
}
|
|
return faultExceptionType;
|
|
}
|
|
}
|
|
|
|
public static void ProvideDefaultNamespace(ref XName serviceContractName)
|
|
{
|
|
Fx.Assert(serviceContractName != null, "Argument cannot be null!");
|
|
|
|
if (string.IsNullOrEmpty(serviceContractName.NamespaceName))
|
|
{
|
|
// If no namespace is given by the user, we provide default namespace. This is consistent with WCF.
|
|
serviceContractName = XName.Get(serviceContractName.LocalName, NamingHelper.DefaultNamespace);
|
|
}
|
|
}
|
|
|
|
public static ContractDescription CreateContractFromOperation(XName serviceContractName, OperationDescription operation)
|
|
{
|
|
Fx.Assert(serviceContractName != null, "serviceContractName cannot be null");
|
|
ProvideDefaultNamespace(ref serviceContractName);
|
|
|
|
ContractDescription contract = new ContractDescription(serviceContractName.LocalName, serviceContractName.NamespaceName)
|
|
{
|
|
// For inferred client side contracts, we do not set ContractType
|
|
|
|
ConfigurationName = serviceContractName.LocalName,
|
|
SessionMode = SessionMode.Allowed
|
|
};
|
|
contract.Operations.Add(operation);
|
|
return contract;
|
|
}
|
|
|
|
public static ContractDescription CreateOutputChannelContractDescription(XName serviceContractName, ProtectionLevel? protectionLevel)
|
|
{
|
|
Fx.Assert(serviceContractName != null, "cannot be null");
|
|
Type channelType = typeof(IOutputChannel);
|
|
|
|
ProvideDefaultNamespace(ref serviceContractName);
|
|
|
|
ContractDescription contract = new ContractDescription(serviceContractName.LocalName, serviceContractName.NamespaceName)
|
|
{
|
|
ContractType = channelType,
|
|
ConfigurationName = serviceContractName.LocalName,
|
|
SessionMode = SessionMode.Allowed
|
|
};
|
|
OperationDescription operation = new OperationDescription("Send", contract);
|
|
MessageDescription message = new MessageDescription(MessageHeaders.WildcardAction, MessageDirection.Input);
|
|
operation.Messages.Add(message);
|
|
|
|
if (protectionLevel.HasValue)
|
|
{
|
|
operation.ProtectionLevel = protectionLevel.Value;
|
|
}
|
|
|
|
contract.Operations.Add(operation);
|
|
return contract;
|
|
}
|
|
|
|
public static ContractDescription CreateRequestChannelContractDescription(XName serviceContractName, ProtectionLevel? protectionLevel)
|
|
{
|
|
Fx.Assert(serviceContractName != null, "cannot be null");
|
|
Type channelType = typeof(IRequestChannel);
|
|
|
|
ProvideDefaultNamespace(ref serviceContractName);
|
|
|
|
ContractDescription contract = new ContractDescription(serviceContractName.LocalName, serviceContractName.NamespaceName)
|
|
{
|
|
ContractType = channelType,
|
|
ConfigurationName = serviceContractName.LocalName,
|
|
SessionMode = SessionMode.Allowed
|
|
};
|
|
OperationDescription operation = new OperationDescription("Request", contract);
|
|
MessageDescription request = new MessageDescription(MessageHeaders.WildcardAction, MessageDirection.Input);
|
|
MessageDescription reply = new MessageDescription(MessageHeaders.WildcardAction, MessageDirection.Output);
|
|
operation.Messages.Add(request);
|
|
operation.Messages.Add(reply);
|
|
|
|
if (protectionLevel.HasValue)
|
|
{
|
|
operation.ProtectionLevel = protectionLevel.Value;
|
|
}
|
|
|
|
contract.Operations.Add(operation);
|
|
return contract;
|
|
}
|
|
|
|
public static void EnsureTransactionFlowOnContract(
|
|
ref ServiceEndpoint serviceEndpoint,
|
|
XName serviceContractName,
|
|
string operationName,
|
|
string action,
|
|
ProtectionLevel? protectionLevel)
|
|
{
|
|
Fx.Assert(serviceEndpoint != null, "ServiceEndpoint cannot be null!");
|
|
|
|
// Client side fully inferred contract always has null ContractType
|
|
if (serviceEndpoint.Contract.ContractType == null)
|
|
{
|
|
// If we are using the real contract, we only need to add TrancactionFlowAttribute to the operation
|
|
Fx.Assert(serviceEndpoint.Contract.Operations.Count == 1, "Client side contract should have exactly one operation!");
|
|
|
|
serviceEndpoint.Contract.Operations[0].Behaviors.Add(new TransactionFlowAttribute(TransactionFlowOption.Allowed));
|
|
}
|
|
else
|
|
{
|
|
// Replace the original fake contract with a fake contract tailored for transaction
|
|
|
|
ContractDescription contract = null;
|
|
OperationDescription operation = null;
|
|
MessageDescription request = null;
|
|
MessageDescription reply = null;
|
|
|
|
Type channelType = typeof(IRequestChannel);
|
|
|
|
// We need to create a contract description with the real service contract name
|
|
// and operation name and actions and with the TransactionFlow operation behavior
|
|
// because the TransactionChannelFactory has a dictionary of "Directional Action" to
|
|
// transaction flow value that it uses to decide whether or not to include the
|
|
// transaction header in the message.
|
|
Fx.Assert(serviceContractName != null, "Argument serviceContractName cannot be null!");
|
|
Fx.Assert(operationName != null, "Argument operationName cannot be null!");
|
|
|
|
ProvideDefaultNamespace(ref serviceContractName);
|
|
|
|
contract = new ContractDescription(serviceContractName.LocalName, serviceContractName.NamespaceName)
|
|
{
|
|
ContractType = channelType,
|
|
SessionMode = SessionMode.Allowed
|
|
};
|
|
operation = new OperationDescription(operationName, contract);
|
|
operation.Behaviors.Add(new TransactionFlowAttribute(TransactionFlowOption.Allowed));
|
|
|
|
string requestAction = null;
|
|
string replyAction = null;
|
|
if (String.IsNullOrEmpty(action))
|
|
{
|
|
// Construct the action.
|
|
requestAction = NamingHelper.GetMessageAction(operation, false);
|
|
replyAction = NamingHelper.GetMessageAction(operation, true);
|
|
}
|
|
else
|
|
{
|
|
requestAction = action;
|
|
replyAction = action + TypeLoader.ResponseSuffix;
|
|
}
|
|
|
|
request = new MessageDescription(requestAction, MessageDirection.Input);
|
|
reply = new MessageDescription(replyAction, MessageDirection.Output);
|
|
|
|
operation.Messages.Add(request);
|
|
operation.Messages.Add(reply);
|
|
|
|
if (protectionLevel.HasValue)
|
|
{
|
|
operation.ProtectionLevel = protectionLevel.Value;
|
|
}
|
|
|
|
contract.Operations.Add(operation);
|
|
|
|
// We need to replace the ServiceEndpoint because ServiceEndpoint.Contract does not have a public setter
|
|
Uri listenUri = serviceEndpoint.ListenUri;
|
|
serviceEndpoint = new ServiceEndpoint(contract)
|
|
{
|
|
Binding = serviceEndpoint.Binding,
|
|
Address = serviceEndpoint.Address,
|
|
Name = serviceEndpoint.Name,
|
|
};
|
|
if (listenUri != null)
|
|
{
|
|
serviceEndpoint.ListenUri = listenUri;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static OperationDescription CreateOneWayOperationDescription(Send send)
|
|
{
|
|
Fx.Assert(send != null, "Argument cannot be null!");
|
|
return CreateOperationDescriptionCore(send, null);
|
|
}
|
|
|
|
public static OperationDescription CreateTwoWayOperationDescription(Send send, ReceiveReply receiveReply)
|
|
{
|
|
Fx.Assert(send != null && receiveReply != null, "Arguments cannot be null!");
|
|
return CreateOperationDescriptionCore(send, receiveReply);
|
|
}
|
|
|
|
static OperationDescription CreateOperationDescriptionCore(Send send, ReceiveReply receiveReply)
|
|
{
|
|
XName contractXName = send.ServiceContractName;
|
|
ProvideDefaultNamespace(ref contractXName);
|
|
|
|
// Infer Name, Namespace, ConfigurationName
|
|
ContractDescription contract = new ContractDescription(contractXName.LocalName, contractXName.NamespaceName);
|
|
contract.ConfigurationName = send.EndpointConfigurationName;
|
|
|
|
OperationDescription operation = new OperationDescription(NamingHelper.XmlName(send.OperationName), contract);
|
|
if (send.ProtectionLevel.HasValue)
|
|
{
|
|
operation.ProtectionLevel = send.ProtectionLevel.Value;
|
|
}
|
|
|
|
AddKnownTypesToOperation(operation, send.KnownTypes);
|
|
|
|
// Infer In-Message
|
|
send.InternalContent.InferMessageDescription(operation, send, MessageDirection.Input);
|
|
|
|
// Infer Out-Message
|
|
if (receiveReply != null)
|
|
{
|
|
receiveReply.InternalContent.InferMessageDescription(operation, receiveReply, MessageDirection.Output);
|
|
}
|
|
|
|
PostProcessOperation(operation);
|
|
AddSerializerProvider(operation, send.SerializerOption);
|
|
|
|
contract.Operations.Add(operation);
|
|
|
|
return operation;
|
|
}
|
|
|
|
// Create server side OperationDescription.
|
|
// Note this method assumes that CacheMetadata has been called on the Receive activity (as part of
|
|
// the activity tree walk that is done in WorkflowService.GetContractDescriptions) because it relies on
|
|
// InternalReceiveMessage property of the Receive actitivy to be non-null.
|
|
public static OperationDescription CreateOperationDescription(Receive receive, ContractDescription contract)
|
|
{
|
|
Fx.Assert(receive.InternalReceive != null, "This method can only be called if CacheMetadata has been called on the receive activity");
|
|
|
|
OperationDescription operation = new OperationDescription(NamingHelper.XmlName(receive.OperationName), contract);
|
|
|
|
if (receive.ProtectionLevel.HasValue)
|
|
{
|
|
operation.ProtectionLevel = receive.ProtectionLevel.Value;
|
|
}
|
|
|
|
// Infer In-Message
|
|
receive.InternalContent.InferMessageDescription(operation, receive, MessageDirection.Input);
|
|
|
|
// Infer Out-Message
|
|
if (receive.HasReply)
|
|
{
|
|
// At this point, we already know all the following SendReplies are equivalent
|
|
SendReply sendReply = receive.FollowingReplies[0];
|
|
sendReply.InternalContent.InferMessageDescription(operation, sendReply, MessageDirection.Output);
|
|
}
|
|
else if (receive.HasFault)
|
|
{
|
|
// We infer Receive-SendFault pair as a two-way operation with void return value
|
|
CheckForDisposableParameters(operation, Constants.EmptyTypeArray);
|
|
AddOutputMessage(operation, null, Constants.EmptyStringArray, Constants.EmptyTypeArray);
|
|
}
|
|
|
|
PostProcessOperation(operation);
|
|
|
|
// Behaviors
|
|
AddSerializerProvider(operation, receive.SerializerOption);
|
|
AddWorkflowOperationBehaviors(operation, receive.InternalReceive.OperationBookmarkName, receive.CanCreateInstance);
|
|
|
|
if (receive.InternalReceive.AdditionalData.IsInsideTransactedReceiveScope)
|
|
{
|
|
operation.IsInsideTransactedReceiveScope = true;
|
|
EnableTransactionBehavior(operation);
|
|
if (receive.InternalReceive.AdditionalData.IsFirstReceiveOfTransactedReceiveScopeTree)
|
|
{
|
|
operation.IsFirstReceiveOfTransactedReceiveScopeTree = true;
|
|
}
|
|
}
|
|
|
|
return operation;
|
|
}
|
|
|
|
public static void AddInputMessage(OperationDescription operation, string overridingAction, Type type, SerializerOption serializerOption)
|
|
{
|
|
Fx.Assert(operation.Messages.Count == 0, "Operation already has input message");
|
|
|
|
bool isResponse = false;
|
|
MessageDescription message = MessageBuilder.CreateMessageDescription(
|
|
operation, isResponse, MessageDirection.Input, overridingAction, type, serializerOption);
|
|
|
|
operation.Messages.Add(message);
|
|
}
|
|
|
|
public static void AddInputMessage(OperationDescription operation, string overridingAction,
|
|
string[] argumentNames, Type[] argumentTypes)
|
|
{
|
|
Fx.Assert(operation.Messages.Count == 0, "Operation already has input message");
|
|
|
|
bool isResponse = false;
|
|
MessageDescription message = MessageBuilder.CreateMessageDescription(
|
|
operation, isResponse, MessageDirection.Input, overridingAction, argumentNames, argumentTypes);
|
|
|
|
operation.Messages.Add(message);
|
|
}
|
|
|
|
public static void AddOutputMessage(OperationDescription operation, string overridingAction, Type type, SerializerOption serializerOption)
|
|
{
|
|
Fx.Assert(operation.Messages.Count > 0, "Operation does not have input message");
|
|
Fx.Assert(operation.Messages.Count < 2, "Operation already has output message");
|
|
|
|
bool isResponse = true;
|
|
MessageDescription message = MessageBuilder.CreateMessageDescription(
|
|
operation, isResponse, MessageDirection.Output, overridingAction, type, serializerOption);
|
|
|
|
operation.Messages.Add(message);
|
|
}
|
|
|
|
public static void AddOutputMessage(OperationDescription operation, string overridingAction,
|
|
string[] argumentNames, Type[] argumentTypes)
|
|
{
|
|
Fx.Assert(operation.Messages.Count > 0, "Operation does not have input message");
|
|
Fx.Assert(operation.Messages.Count < 2, "Operation already has output message");
|
|
|
|
bool isResponse = true;
|
|
MessageDescription message = MessageBuilder.CreateMessageDescription(
|
|
operation, isResponse, MessageDirection.Output, overridingAction, argumentNames, argumentTypes);
|
|
|
|
operation.Messages.Add(message);
|
|
}
|
|
|
|
static void AddKnownTypesToOperation(OperationDescription operation, Collection<Type> knownTypes)
|
|
{
|
|
if (knownTypes != null)
|
|
{
|
|
foreach (Type knownType in knownTypes)
|
|
{
|
|
operation.KnownTypes.Add(knownType);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void CheckForDisposableParameters(OperationDescription operation, Type type)
|
|
{
|
|
if (type == null)
|
|
{
|
|
operation.HasNoDisposableParameters = true;
|
|
}
|
|
else
|
|
{
|
|
operation.HasNoDisposableParameters = !ServiceReflector.IsParameterDisposable(type);
|
|
}
|
|
}
|
|
|
|
public static void CheckForDisposableParameters(OperationDescription operation, Type[] types)
|
|
{
|
|
Fx.Assert(types != null, "Argument cannot be null!");
|
|
|
|
operation.HasNoDisposableParameters = true;
|
|
foreach (Type type in types)
|
|
{
|
|
if (ServiceReflector.IsParameterDisposable(type))
|
|
{
|
|
operation.HasNoDisposableParameters = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void EnableTransactionBehavior(OperationDescription operationDescription)
|
|
{
|
|
Fx.Assert(operationDescription != null, "OperationDescription is null");
|
|
|
|
OperationBehaviorAttribute attribute = operationDescription.Behaviors.Find<OperationBehaviorAttribute>();
|
|
if (attribute != null)
|
|
{
|
|
attribute.TransactionScopeRequired = true;
|
|
attribute.TransactionAutoComplete = false;
|
|
}
|
|
else
|
|
{
|
|
OperationBehaviorAttribute attr = new OperationBehaviorAttribute
|
|
{
|
|
TransactionAutoComplete = false,
|
|
TransactionScopeRequired = true
|
|
};
|
|
operationDescription.Behaviors.Add(attr);
|
|
}
|
|
TransactionFlowAttribute transactionFlowAttribute = operationDescription.Behaviors.Find<TransactionFlowAttribute>();
|
|
if (transactionFlowAttribute != null)
|
|
{
|
|
if (transactionFlowAttribute.Transactions != TransactionFlowOption.Allowed)
|
|
{
|
|
throw FxTrace.Exception.AsError(new InvalidOperationException(SR.ContractInferenceValidationForTransactionFlowBehavior));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!operationDescription.IsOneWay)
|
|
{
|
|
operationDescription.Behaviors.Add(new TransactionFlowAttribute(TransactionFlowOption.Allowed));
|
|
}
|
|
}
|
|
}
|
|
|
|
static void PostProcessOperation(OperationDescription operation)
|
|
{
|
|
MessageBuilder.ClearWrapperNames(operation);
|
|
}
|
|
|
|
static void AddSerializerProvider(OperationDescription operation, SerializerOption serializerOption)
|
|
{
|
|
switch (serializerOption)
|
|
{
|
|
case SerializerOption.DataContractSerializer:
|
|
AddDataContractSerializerFormat(operation);
|
|
break;
|
|
case SerializerOption.XmlSerializer:
|
|
AddXmlSerializerFormat(operation);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void AddDataContractSerializerFormat(OperationDescription operation)
|
|
{
|
|
if (operation.Behaviors.Find<DataContractSerializerOperationBehavior>() != null)
|
|
{
|
|
throw FxTrace.Exception.AsError(new InvalidOperationException(SR.OperationHasSerializerBehavior(
|
|
operation.Name, operation.DeclaringContract.Name, typeof(DataContractSerializerOperationBehavior))));
|
|
}
|
|
operation.Behaviors.Add(new DataContractSerializerOperationBehavior(operation, DataContractFormatAttribute));
|
|
if (!operation.Behaviors.Contains(typeof(DataContractSerializerOperationGenerator)))
|
|
{
|
|
operation.Behaviors.Add(new DataContractSerializerOperationGenerator());
|
|
}
|
|
}
|
|
|
|
static void AddXmlSerializerFormat(OperationDescription operation)
|
|
{
|
|
if (operation.Behaviors.Find<XmlSerializerOperationBehavior>() != null)
|
|
{
|
|
throw FxTrace.Exception.AsError(new InvalidOperationException(
|
|
SR.OperationHasSerializerBehavior(operation.Name, operation.DeclaringContract.Name, typeof(XmlSerializerOperationBehavior))));
|
|
}
|
|
operation.Behaviors.Add(new XmlSerializerOperationBehavior(operation, XmlSerializerFormatAttribute));
|
|
if (!operation.Behaviors.Contains(typeof(XmlSerializerOperationGenerator)))
|
|
{
|
|
operation.Behaviors.Add(new XmlSerializerOperationGenerator(new XmlSerializerImportOptions()));
|
|
}
|
|
}
|
|
|
|
static void AddWorkflowOperationBehaviors(OperationDescription operation, string bookmarkName, bool canCreateInstance)
|
|
{
|
|
KeyedByTypeCollection<IOperationBehavior> behaviors = operation.Behaviors;
|
|
WorkflowOperationBehavior workflowOperationBehavior = behaviors.Find<WorkflowOperationBehavior>();
|
|
if (workflowOperationBehavior == null)
|
|
{
|
|
behaviors.Add(new WorkflowOperationBehavior(new Bookmark(bookmarkName), canCreateInstance));
|
|
}
|
|
else
|
|
{
|
|
workflowOperationBehavior.CanCreateInstance = workflowOperationBehavior.CanCreateInstance || canCreateInstance;
|
|
}
|
|
}
|
|
|
|
public static void CorrectOutMessageForOperation(Receive receive, OperationDescription operation)
|
|
{
|
|
// Remove the original outMessage
|
|
Fx.Assert(operation.Messages.Count == 2, "OperationDescription must be two-way for CorrectOutMessageForOperation to be invoked!");
|
|
operation.Messages.RemoveAt(1);
|
|
|
|
SendReply sendReply = receive.FollowingReplies[0];
|
|
sendReply.InternalContent.InferMessageDescription(operation, sendReply, MessageDirection.Output);
|
|
|
|
ContractInferenceHelper.PostProcessOperation(operation);
|
|
}
|
|
|
|
public static void UpdateIsOneWayFlag(Receive receive, OperationDescription operation)
|
|
{
|
|
// Set InternalReceiveMessage.IsOneWay to false for two-way operations
|
|
if (!operation.IsOneWay)
|
|
{
|
|
receive.SetIsOneWay(false);
|
|
}
|
|
}
|
|
|
|
public static void AddFaultDescription(Receive activity, OperationDescription operation)
|
|
{
|
|
if (activity.HasFault)
|
|
{
|
|
foreach (SendReply sendFault in activity.FollowingFaults)
|
|
{
|
|
string action = null;
|
|
Type type = null;
|
|
|
|
action = sendFault.Action;
|
|
|
|
SendMessageContent sendReply = sendFault.InternalContent as SendMessageContent;
|
|
if (sendReply != null)
|
|
{
|
|
type = sendReply.InternalDeclaredMessageType;
|
|
}
|
|
else
|
|
{
|
|
SendParametersContent sendReplyParameters = sendFault.InternalContent as SendParametersContent;
|
|
if (sendReplyParameters != null)
|
|
{
|
|
type = sendReplyParameters.ArgumentTypes[0]; // Exception should be the only parameter in SendFault
|
|
}
|
|
}
|
|
|
|
Fx.Assert(type != null, "Exception type cannot be null!");
|
|
if (type.IsGenericType && type.GetGenericTypeDefinition() == FaultExceptionType)
|
|
{
|
|
Type faultType = type.GetGenericArguments()[0];
|
|
bool exists = false;
|
|
|
|
// We expect the number of fault types to be small, so we use iterative comparison
|
|
foreach (FaultDescription faultDescription in operation.Faults)
|
|
{
|
|
if (faultDescription.DetailType == faultType)
|
|
{
|
|
if (faultDescription.Action != action)
|
|
{
|
|
throw FxTrace.Exception.AsError(new ValidationException(SR.SendRepliesHaveSameFaultTypeDifferentAction));
|
|
}
|
|
else
|
|
{
|
|
exists = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!exists)
|
|
{
|
|
FaultDescription faultDescription = MessageBuilder.CreateFaultDescription(operation, faultType, action);
|
|
operation.Faults.Add(faultDescription);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void AddKnownTypesToOperation(Receive receive, OperationDescription operation)
|
|
{
|
|
Collection<Type> knownTypes = receive.InternalKnownTypes;
|
|
|
|
if (knownTypes != null)
|
|
{
|
|
foreach (Type knownType in knownTypes)
|
|
{
|
|
// We expect the number of known types to be small, so we use iterative comparison
|
|
if (!operation.KnownTypes.Contains(knownType))
|
|
{
|
|
operation.KnownTypes.Add(knownType);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void AddReceiveToFormatterBehavior(Receive receive, OperationDescription operation)
|
|
{
|
|
Fx.Assert(receive != null && operation != null, "Argument cannot be null!");
|
|
|
|
KeyedByTypeCollection<IOperationBehavior> behaviors = operation.Behaviors;
|
|
WorkflowFormatterBehavior formatterBehavior = behaviors.Find<WorkflowFormatterBehavior>();
|
|
if (formatterBehavior == null)
|
|
{
|
|
formatterBehavior = new WorkflowFormatterBehavior();
|
|
behaviors.Add(formatterBehavior);
|
|
}
|
|
|
|
formatterBehavior.Receives.Add(receive);
|
|
}
|
|
|
|
public static void RemoveReceiveFromFormatterBehavior(Receive receive, OperationDescription operation)
|
|
{
|
|
Fx.Assert(receive != null && operation != null, "Arguments cannot be null!");
|
|
|
|
KeyedByTypeCollection<IOperationBehavior> behaviors = operation.Behaviors;
|
|
WorkflowFormatterBehavior formatterBehavior = behaviors.Find<WorkflowFormatterBehavior>();
|
|
if (formatterBehavior != null)
|
|
{
|
|
formatterBehavior.Receives.Remove(receive);
|
|
}
|
|
}
|
|
|
|
public static CorrelationQuery CreateServerCorrelationQuery(MessageQuerySet select, Collection<CorrelationInitializer> correlationInitializers,
|
|
OperationDescription operation, bool isResponse)
|
|
{
|
|
Fx.Assert(operation != null, "Argument cannot be null!");
|
|
|
|
CorrelationQuery correlationQuery = CreateCorrelationQueryCore(select, correlationInitializers);
|
|
|
|
if (correlationQuery != null)
|
|
{
|
|
string action = !isResponse ? operation.Messages[0].Action : operation.Messages[1].Action;
|
|
correlationQuery.Where = new CorrelationActionMessageFilter { Action = action };
|
|
}
|
|
|
|
return correlationQuery;
|
|
}
|
|
|
|
// this method generates the correlationQuery for client side send and receiveReply
|
|
public static Collection<CorrelationQuery> CreateClientCorrelationQueries(MessageQuerySet select, Collection<CorrelationInitializer> correlationInitializers,
|
|
string overridingAction, XName serviceContractName, string operationName, bool isResponse)
|
|
{
|
|
Fx.Assert(serviceContractName != null && operationName != null, "Argument cannot be null!");
|
|
|
|
Collection<CorrelationQuery> queryCollection = new Collection<CorrelationQuery>();
|
|
CorrelationQuery correlationQuery = CreateCorrelationQueryCore(select, correlationInitializers);
|
|
|
|
if (correlationQuery != null)
|
|
{
|
|
if (overridingAction != null)
|
|
{
|
|
correlationQuery.Where = new CorrelationActionMessageFilter { Action = overridingAction };
|
|
}
|
|
else
|
|
{
|
|
ProvideDefaultNamespace(ref serviceContractName);
|
|
string defaultAction = NamingHelper.GetMessageAction(new XmlQualifiedName(serviceContractName.LocalName, serviceContractName.NamespaceName),
|
|
operationName, null, isResponse);
|
|
|
|
correlationQuery.Where = new CorrelationActionMessageFilter { Action = defaultAction };
|
|
}
|
|
|
|
queryCollection.Add(correlationQuery);
|
|
|
|
if (isResponse)
|
|
{
|
|
// we need an additional query with empty action to support soap1.1 reply cases
|
|
CorrelationQuery noActionQuery = correlationQuery.Clone();
|
|
noActionQuery.Where = new CorrelationActionMessageFilter { Action = String.Empty };
|
|
queryCollection.Add(noActionQuery);
|
|
}
|
|
}
|
|
|
|
return queryCollection;
|
|
}
|
|
|
|
static CorrelationQuery CreateCorrelationQueryCore(MessageQuerySet select, Collection<CorrelationInitializer> correlationInitializers)
|
|
{
|
|
CorrelationQuery correlationQuery = null;
|
|
|
|
if (select != null)
|
|
{
|
|
Fx.Assert(select.Count != 0, "Empty MessageQuerySet is not allowed!");
|
|
|
|
correlationQuery = new CorrelationQuery
|
|
{
|
|
Select = select
|
|
};
|
|
}
|
|
|
|
if (correlationInitializers != null && correlationInitializers.Count > 0)
|
|
{
|
|
foreach (CorrelationInitializer correlation in correlationInitializers)
|
|
{
|
|
QueryCorrelationInitializer queryCorrelation = correlation as QueryCorrelationInitializer;
|
|
if (queryCorrelation != null)
|
|
{
|
|
Fx.Assert(queryCorrelation.MessageQuerySet.Count != 0, "Empty MessageQuerySet is not allowed!");
|
|
|
|
correlationQuery = correlationQuery ?? new CorrelationQuery();
|
|
correlationQuery.SelectAdditional.Add(queryCorrelation.MessageQuerySet);
|
|
}
|
|
}
|
|
}
|
|
|
|
return correlationQuery;
|
|
}
|
|
}
|
|
}
|