private void EnsureNoOneWayTransactions(ServiceEndpoint endpoint)
{
CustomBinding binding = new CustomBinding(endpoint.Binding);
if (binding.Elements.Find <TransactionFlowBindingElement>() != null)
{
for (int i = 0; i < endpoint.Contract.Operations.Count; i++)
{
OperationDescription description = endpoint.Contract.Operations[i];
if (description.IsOneWay)
{
TransactionFlowOption transactions;
TransactionFlowAttribute attribute = description.Behaviors.Find <TransactionFlowAttribute>();
if (attribute != null)
{
transactions = attribute.Transactions;
}
else
{
transactions = TransactionFlowOption.NotAllowed;
}
if (TransactionFlowOptionHelper.AllowedOrRequired(transactions))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("SFxOneWayAndTransactionsIncompatible", new object[] { endpoint.Contract.Name, description.Name })));
}
}
}
}
}
void EnsureNoOneWayTransactions(ServiceEndpoint endpoint)
{
CustomBinding binding = new CustomBinding(endpoint.Binding);
TransactionFlowBindingElement txFlowBindingElement = binding.Elements.Find <TransactionFlowBindingElement>();
if (txFlowBindingElement != null)
{
for (int i = 0; i < endpoint.Contract.Operations.Count; i++)
{
OperationDescription operation = endpoint.Contract.Operations[i];
if (operation.IsOneWay)
{
TransactionFlowAttribute tfbp = operation.Behaviors.Find <TransactionFlowAttribute>();
TransactionFlowOption transactions;
if (tfbp != null)
{
transactions = tfbp.Transactions;
}
else
{
transactions = TransactionFlowOption.NotAllowed;
}
if (TransactionFlowOptionHelper.AllowedOrRequired(transactions))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
SR.GetString(SR.SFxOneWayAndTransactionsIncompatible, endpoint.Contract.Name, operation.Name)));
}
}
}
}
}
internal bool IsFlowEnabled(ContractDescription contract)
{
if (this.issuedTokens != TransactionFlowOption.NotAllowed)
{
return(true);
}
if (!this.transactions)
{
return(false);
}
foreach (OperationDescription operation in contract.Operations)
{
TransactionFlowAttribute parameter = operation.Behaviors.Find <TransactionFlowAttribute>();
if (parameter != null)
{
if (parameter.Transactions != TransactionFlowOption.NotAllowed)
{
return(true);
}
}
}
return(false);
}
void ValidateTransactionFlowRequired(string resource, string name, ServiceEndpoint endpoint)
{
bool anOperationRequiresTxFlow = false;
for (int i = 0; i < endpoint.Contract.Operations.Count; i++)
{
OperationDescription operationDescription = endpoint.Contract.Operations[i];
TransactionFlowAttribute transactionFlow = operationDescription.Behaviors.Find <TransactionFlowAttribute>();
if (transactionFlow != null && transactionFlow.Transactions == TransactionFlowOption.Mandatory)
{
anOperationRequiresTxFlow = true;
break;
}
}
if (anOperationRequiresTxFlow)
{
CustomBinding binding = new CustomBinding(endpoint.Binding);
TransactionFlowBindingElement transactionFlowBindingElement =
binding.Elements.Find <TransactionFlowBindingElement>();
if (transactionFlowBindingElement == null || !transactionFlowBindingElement.Transactions)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
String.Format(Globalization.CultureInfo.CurrentCulture, SR.GetString(resource), name, binding.Name)));
}
}
}
private static void EnableTransactionBehavior(OperationDescription operationDescription)
{
OperationBehaviorAttribute attribute = operationDescription.Behaviors.Find <OperationBehaviorAttribute>();
if (attribute != null)
{
attribute.TransactionScopeRequired = true;
attribute.TransactionAutoComplete = false;
}
else
{
OperationBehaviorAttribute item = new OperationBehaviorAttribute {
TransactionAutoComplete = false,
TransactionScopeRequired = true
};
operationDescription.Behaviors.Add(item);
}
TransactionFlowAttribute attribute4 = operationDescription.Behaviors.Find <TransactionFlowAttribute>();
if (attribute4 != null)
{
if (attribute4.Transactions != TransactionFlowOption.Allowed)
{
throw System.ServiceModel.Activities.FxTrace.Exception.AsError(new InvalidOperationException(System.ServiceModel.Activities.SR.ContractInferenceValidationForTransactionFlowBehavior));
}
}
else if (!operationDescription.IsOneWay)
{
operationDescription.Behaviors.Add(new TransactionFlowAttribute(TransactionFlowOption.Allowed));
}
}
static void ValidateTransactionFlow(ServiceEndpoint endpoint)
{
Exception exception = new InvalidOperationException("BindingRequirementAttribute requires transaction flow enabled, but binding for the endpoint with contract " + endpoint.Contract.ContractType + " has it disabled");
foreach (OperationDescription operation in endpoint.Contract.Operations)
{
TransactionFlowAttribute attribute = operation.Behaviors.Find <TransactionFlowAttribute>();
if (attribute != null)
{
if (attribute.Transactions == TransactionFlowOption.Allowed)
{
try
{
dynamic binding = endpoint.Binding;
if (binding.TransactionFlow == false)
{
throw exception;
}
continue;
}
catch (RuntimeBinderException)
{
throw new InvalidOperationException("BindingRequirementAttribute requires transaction flow enabled, but binding for the endpoint with contract " + endpoint.Contract.ContractType + " does not support transaction flow");
}
}
}
}
}
static void FillBehaviorInfo(IOperationBehavior behavior, IWmiInstance existingInstance, out IWmiInstance instance)
{
Fx.Assert(null != existingInstance, "");
Fx.Assert(null != behavior, "");
instance = null;
if (behavior is DataContractSerializerOperationBehavior)
{
instance = existingInstance.NewInstance("DataContractSerializerOperationBehavior");
DataContractSerializerOperationBehavior specificBehavior = (DataContractSerializerOperationBehavior)behavior;
instance.SetProperty(AdministrationStrings.IgnoreExtensionDataObject, specificBehavior.IgnoreExtensionDataObject);
instance.SetProperty(AdministrationStrings.MaxItemsInObjectGraph, specificBehavior.MaxItemsInObjectGraph);
if (null != specificBehavior.DataContractFormatAttribute)
{
instance.SetProperty(AdministrationStrings.Style, specificBehavior.DataContractFormatAttribute.Style.ToString());
}
}
else if (behavior is OperationBehaviorAttribute)
{
instance = existingInstance.NewInstance("OperationBehaviorAttribute");
OperationBehaviorAttribute specificBehavior = (OperationBehaviorAttribute)behavior;
instance.SetProperty(AdministrationStrings.AutoDisposeParameters, specificBehavior.AutoDisposeParameters);
instance.SetProperty(AdministrationStrings.Impersonation, specificBehavior.Impersonation.ToString());
instance.SetProperty(AdministrationStrings.ReleaseInstanceMode, specificBehavior.ReleaseInstanceMode.ToString());
instance.SetProperty(AdministrationStrings.TransactionAutoComplete, specificBehavior.TransactionAutoComplete);
instance.SetProperty(AdministrationStrings.TransactionScopeRequired, specificBehavior.TransactionScopeRequired);
}
else if (behavior is TransactionFlowAttribute)
{
instance = existingInstance.NewInstance("TransactionFlowAttribute");
TransactionFlowAttribute specificBehavior = (TransactionFlowAttribute)behavior;
instance.SetProperty(AdministrationStrings.TransactionFlowOption, specificBehavior.Transactions.ToString());
}
else if (behavior is XmlSerializerOperationBehavior)
{
instance = existingInstance.NewInstance("XmlSerializerOperationBehavior");
XmlSerializerOperationBehavior specificBehavior = (XmlSerializerOperationBehavior)behavior;
if (null != specificBehavior.XmlSerializerFormatAttribute)
{
instance.SetProperty(AdministrationStrings.Style, specificBehavior.XmlSerializerFormatAttribute.Style.ToString());
instance.SetProperty(AdministrationStrings.Use, specificBehavior.XmlSerializerFormatAttribute.Use.ToString());
instance.SetProperty(AdministrationStrings.SupportFaults, specificBehavior.XmlSerializerFormatAttribute.SupportFaults.ToString());
}
}
else if (behavior is IWmiInstanceProvider)
{
IWmiInstanceProvider instanceProvider = (IWmiInstanceProvider)behavior;
instance = existingInstance.NewInstance(instanceProvider.GetInstanceType());
instanceProvider.FillInstance(instance);
}
else
{
instance = existingInstance.NewInstance("Behavior");
}
if (null != instance)
{
instance.SetProperty(AdministrationStrings.Type, behavior.GetType().FullName);
}
}
private static void FillBehaviorInfo(IOperationBehavior behavior, IWmiInstance existingInstance, out IWmiInstance instance)
{
instance = null;
if (behavior is DataContractSerializerOperationBehavior)
{
instance = existingInstance.NewInstance("DataContractSerializerOperationBehavior");
DataContractSerializerOperationBehavior behavior2 = (DataContractSerializerOperationBehavior)behavior;
instance.SetProperty("IgnoreExtensionDataObject", behavior2.IgnoreExtensionDataObject);
instance.SetProperty("MaxItemsInObjectGraph", behavior2.MaxItemsInObjectGraph);
if (behavior2.DataContractFormatAttribute != null)
{
instance.SetProperty("Style", behavior2.DataContractFormatAttribute.Style.ToString());
}
}
else if (behavior is OperationBehaviorAttribute)
{
instance = existingInstance.NewInstance("OperationBehaviorAttribute");
OperationBehaviorAttribute attribute = (OperationBehaviorAttribute)behavior;
instance.SetProperty("AutoDisposeParameters", attribute.AutoDisposeParameters);
instance.SetProperty("Impersonation", attribute.Impersonation.ToString());
instance.SetProperty("ReleaseInstanceMode", attribute.ReleaseInstanceMode.ToString());
instance.SetProperty("TransactionAutoComplete", attribute.TransactionAutoComplete);
instance.SetProperty("TransactionScopeRequired", attribute.TransactionScopeRequired);
}
else if (behavior is TransactionFlowAttribute)
{
instance = existingInstance.NewInstance("TransactionFlowAttribute");
TransactionFlowAttribute attribute2 = (TransactionFlowAttribute)behavior;
instance.SetProperty("TransactionFlowOption", attribute2.Transactions.ToString());
}
else if (behavior is XmlSerializerOperationBehavior)
{
instance = existingInstance.NewInstance("XmlSerializerOperationBehavior");
XmlSerializerOperationBehavior behavior3 = (XmlSerializerOperationBehavior)behavior;
if (behavior3.XmlSerializerFormatAttribute != null)
{
instance.SetProperty("Style", behavior3.XmlSerializerFormatAttribute.Style.ToString());
instance.SetProperty("Use", behavior3.XmlSerializerFormatAttribute.Use.ToString());
instance.SetProperty("SupportFaults", behavior3.XmlSerializerFormatAttribute.SupportFaults.ToString());
}
}
else if (behavior is IWmiInstanceProvider)
{
IWmiInstanceProvider provider = (IWmiInstanceProvider)behavior;
instance = existingInstance.NewInstance(provider.GetInstanceType());
provider.FillInstance(instance);
}
else
{
instance = existingInstance.NewInstance("Behavior");
}
if (instance != null)
{
instance.SetProperty("Type", behavior.GetType().FullName);
}
}
void IOperationContractGenerationExtension.GenerateOperation(OperationContractGenerationContext context)
{
TransactionFlowAttribute attr = context.Operation.Behaviors.Find <TransactionFlowAttribute>();
if ((attr != null) && (attr.Transactions != TransactionFlowOption.NotAllowed))
{
CodeMemberMethod method = context.SyncMethod ?? context.BeginMethod;
method.CustomAttributes.Add(CreateAttrDecl(context, attr));
}
}
static void ValidateTransactionFlow(ServiceEndpoint endpoint)
{
Exception exception = new InvalidOperationException("BindingRequirementAttribute requires transaction flow enabled, but binding for the endpoint with contract " + endpoint.Contract.ContractType + " has it disabled");
foreach (OperationDescription operation in endpoint.Contract.Operations)
{
foreach (IOperationBehavior behavior in operation.Behaviors)
{
if (behavior is TransactionFlowAttribute)
{
TransactionFlowAttribute attribute = behavior as TransactionFlowAttribute;
if (attribute.Transactions == TransactionFlowOption.Allowed)
{
if (endpoint.Binding is NetTcpBinding)
{
NetTcpBinding tcpBinding = endpoint.Binding as NetTcpBinding;
if (tcpBinding.TransactionFlow == false)
{
throw exception;
}
break;
}
if (endpoint.Binding is NetNamedPipeBinding)
{
NetNamedPipeBinding ipcBinding = endpoint.Binding as NetNamedPipeBinding;
if (ipcBinding.TransactionFlow == false)
{
throw exception;
}
break;
}
if (endpoint.Binding is WSHttpBindingBase)
{
WSHttpBindingBase wsBinding = endpoint.Binding as WSHttpBindingBase;
if (wsBinding.TransactionFlow == false)
{
throw exception;
}
break;
}
if (endpoint.Binding is WSDualHttpBinding)
{
WSDualHttpBinding wsDualBinding = endpoint.Binding as WSDualHttpBinding;
if (wsDualBinding.TransactionFlow == false)
{
throw exception;
}
break;
}
throw new InvalidOperationException("BindingRequirementAttribute requires transaction flow enabled, but binding for the endpoint with contract " + endpoint.Contract.ContractType + " does not support transaction flow");
}
}
}
}
}
static bool ContractAllowsTransactionFlow(ContractDescription contract)
{
foreach (OperationDescription operation in contract.Operations)
{
TransactionFlowAttribute flowAttr = operation.Behaviors.Find <TransactionFlowAttribute>();
if (flowAttr != null && flowAttr.Transactions != TransactionFlowOption.NotAllowed)
{
return(true);
}
}
return(false);
}
void IPolicyExportExtension.ExportPolicy(MetadataExporter exporter, PolicyConversionContext context)
{
if (exporter == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("exporter");
}
if (context == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
}
TransactionFlowBindingElement bindingElement = context.BindingElements.Find <TransactionFlowBindingElement>();
if (bindingElement == null || !bindingElement.Transactions)
{
return;
}
XmlDocument doc = new XmlDocument();
XmlElement assertion = null;
foreach (OperationDescription operation in context.Contract.Operations)
{
TransactionFlowAttribute contextParam = operation.Behaviors.Find <TransactionFlowAttribute>();
TransactionFlowOption txFlowOption = contextParam == null ? TransactionFlowOption.NotAllowed : contextParam.Transactions;
// Transactions
if (bindingElement.TransactionProtocol == TransactionProtocol.OleTransactions)
{
assertion = GetAssertion(doc, txFlowOption,
TransactionPolicyStrings.OleTxTransactionsPrefix, TransactionPolicyStrings.OleTxTransactionsLocal,
TransactionPolicyStrings.OleTxTransactionsNamespace, exporter.PolicyVersion.Namespace);
}
else if (bindingElement.TransactionProtocol == TransactionProtocol.WSAtomicTransactionOctober2004)
{
assertion = GetAssertion(doc, txFlowOption,
TransactionPolicyStrings.WsatTransactionsPrefix, TransactionPolicyStrings.WsatTransactionsLocal,
TransactionPolicyStrings.WsatTransactionsNamespace10, exporter.PolicyVersion.Namespace);
}
else if (bindingElement.TransactionProtocol == TransactionProtocol.WSAtomicTransaction11)
{
assertion = GetAssertion(doc, txFlowOption,
TransactionPolicyStrings.WsatTransactionsPrefix, TransactionPolicyStrings.WsatTransactionsLocal,
TransactionPolicyStrings.WsatTransactionsNamespace11, exporter.PolicyVersion.Namespace);
}
if (assertion != null)
{
context.GetOperationBindingAssertions(operation).Add(assertion);
}
}
}
protected WorkflowHostingEndpoint(System.Type contractType, Binding binding, EndpointAddress address) : base(ContractDescription.GetContract(contractType), binding, address)
{
base.IsSystemEndpoint = true;
base.Contract.Behaviors.Add(new ServiceMetadataContractBehavior(false));
base.Contract.Behaviors.Add(new WorkflowHostingContractBehavior());
this.correlationQueries = new Collection <CorrelationQuery>();
base.Behaviors.Add(new CorrelationQueryBehavior(this.correlationQueries));
foreach (OperationDescription description in base.Contract.Operations)
{
TransactionFlowAttribute attribute = description.Behaviors.Find <TransactionFlowAttribute>();
if ((attribute != null) && (attribute.Transactions != TransactionFlowOption.NotAllowed))
{
description.Behaviors.Find <OperationBehaviorAttribute>().TransactionScopeRequired = true;
}
}
}
void SetTransactionFlow(OperationDescription operation)
{
TransactionFlowOption option = TransactionFlowOption.NotAllowed;
foreach (IOperationBehavior behavior in operation.Behaviors)
{
if (behavior is TransactionFlowAttribute)
{
TransactionFlowAttribute attribute = behavior as TransactionFlowAttribute;
option = attribute.Transactions;
break;
}
}
m_AllowedRadioButton.Checked = option == TransactionFlowOption.Allowed;
m_NotAllowedRadioButton.Checked = option == TransactionFlowOption.NotAllowed;
m_MandatoryRadioButton.Checked = option == TransactionFlowOption.Mandatory;
}
internal bool IsFlowEnabled(ContractDescription contract)
{
if (this.issuedTokens != TransactionFlowOption.NotAllowed)
{
return(true);
}
if (this.transactions)
{
foreach (OperationDescription description in contract.Operations)
{
TransactionFlowAttribute attribute = description.Behaviors.Find <TransactionFlowAttribute>();
if ((attribute != null) && (attribute.Transactions != TransactionFlowOption.NotAllowed))
{
return(true);
}
}
}
return(false);
}
void IPolicyExportExtension.ExportPolicy(MetadataExporter exporter, PolicyConversionContext context)
{
if (exporter == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("exporter");
}
if (context == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
}
TransactionFlowBindingElement element = context.BindingElements.Find <TransactionFlowBindingElement>();
if ((element != null) && element.Transactions)
{
XmlDocument doc = new XmlDocument();
XmlElement item = null;
foreach (OperationDescription description in context.Contract.Operations)
{
TransactionFlowAttribute attribute = description.Behaviors.Find <TransactionFlowAttribute>();
TransactionFlowOption option = (attribute == null) ? TransactionFlowOption.NotAllowed : attribute.Transactions;
if (element.TransactionProtocol == System.ServiceModel.TransactionProtocol.OleTransactions)
{
item = this.GetAssertion(doc, option, "oletx", "OleTxAssertion", "http://schemas.microsoft.com/ws/2006/02/tx/oletx", exporter.PolicyVersion.Namespace);
}
else if (element.TransactionProtocol == System.ServiceModel.TransactionProtocol.WSAtomicTransactionOctober2004)
{
item = this.GetAssertion(doc, option, "wsat", "ATAssertion", "http://schemas.xmlsoap.org/ws/2004/10/wsat", exporter.PolicyVersion.Namespace);
}
else if (element.TransactionProtocol == System.ServiceModel.TransactionProtocol.WSAtomicTransaction11)
{
item = this.GetAssertion(doc, option, "wsat", "ATAssertion", "http://docs.oasis-open.org/ws-tx/wsat/2006/06", exporter.PolicyVersion.Namespace);
}
if (item != null)
{
context.GetOperationBindingAssertions(description).Add(item);
}
}
}
}
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));
}
}
}
protected WorkflowHostingEndpoint(Type contractType, Binding binding, EndpointAddress address)
: base(ContractDescription.GetContract(contractType), binding, address)
{
this.IsSystemEndpoint = true;
this.Contract.Behaviors.Add(new ServiceMetadataContractBehavior(false));
this.Contract.Behaviors.Add(new WorkflowHostingContractBehavior());
Fx.Assert(!this.Behaviors.Contains(typeof(CorrelationQueryBehavior)), "Must not contain correlation query!");
this.correlationQueries = new Collection <CorrelationQuery>();
this.Behaviors.Add(new CorrelationQueryBehavior(this.correlationQueries));
// If TransactionFlowOption.Allowed or TransactionFlowOption.Mandatory is defined on an operation, we will set
// TransactionScopeRequired = true for that operation. The operation will become transacted (use transaction flow,
// or create one locally). For usability reason, we assume this is the majority usage. User could opt out by
// setting TransactionScopeRequired to false or remove the TransactionFlowAttribute from the operation.
foreach (OperationDescription operationDescription in this.Contract.Operations)
{
TransactionFlowAttribute transactionFlow = operationDescription.Behaviors.Find <TransactionFlowAttribute>();
if (transactionFlow != null && transactionFlow.Transactions != TransactionFlowOption.NotAllowed)
{
OperationBehaviorAttribute operationAttribute = operationDescription.Behaviors.Find <OperationBehaviorAttribute>();
operationAttribute.TransactionScopeRequired = true;
}
}
}
private void ValidateTransactionFlowRequired(string resource, string name, ServiceEndpoint endpoint)
{
bool flag = false;
for (int i = 0; i < endpoint.Contract.Operations.Count; i++)
{
OperationDescription description = endpoint.Contract.Operations[i];
TransactionFlowAttribute attribute = description.Behaviors.Find <TransactionFlowAttribute>();
if ((attribute != null) && (attribute.Transactions == TransactionFlowOption.Mandatory))
{
flag = true;
break;
}
}
if (flag)
{
CustomBinding binding = new CustomBinding(endpoint.Binding);
TransactionFlowBindingElement element = binding.Elements.Find <TransactionFlowBindingElement>();
if ((element == null) || !element.Transactions)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, System.ServiceModel.SR.GetString(resource), new object[] { name, binding.Name })));
}
}
}
private static CodeAttributeDeclaration CreateAttrDecl(OperationContractGenerationContext context, TransactionFlowAttribute attr)
{
CodeAttributeDeclaration declaration = new CodeAttributeDeclaration(context.Contract.ServiceContractGenerator.GetCodeTypeReference(typeof(TransactionFlowAttribute)));
declaration.Arguments.Add(new CodeAttributeArgument(ServiceContractGenerator.GetEnumReferenceTransactionFlowOption(attr.Transactions)));
return declaration;
}
public void Validate(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase)
{
if (serviceDescription == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("serviceDescription");
}
ContextBindingElement.ValidateContextBindingElementOnAllEndpointsWithSessionfulContract(serviceDescription, this);
if (serviceDescription.Behaviors != null)
{
ServiceBehaviorAttribute serviceBehavior = serviceDescription.Behaviors.Find <ServiceBehaviorAttribute>();
if (serviceBehavior != null)
{
if (serviceBehavior.InstanceContextMode != InstanceContextMode.PerSession)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new InvalidOperationException(
SR2.GetString(SR2.InstanceContextModeMustBePerSession, serviceBehavior.InstanceContextMode)));
}
if (serviceBehavior.ConcurrencyMode == ConcurrencyMode.Multiple)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new InvalidOperationException(
SR2.GetString(SR2.ConcurrencyMultipleNotSupported)));
}
if (serviceBehavior.ConcurrencyMode == ConcurrencyMode.Reentrant &&
this.UnknownExceptionAction == UnknownExceptionAction.AbortInstance)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new InvalidOperationException(
SR2.GetString(SR2.ConcurrencyReentrantAndAbortNotSupported)));
}
}
}
bool foundSessionfulContract = false;
foreach (ServiceEndpoint serviceEndpoint in serviceDescription.Endpoints)
{
if (serviceEndpoint != null && !serviceEndpoint.InternalIsSystemEndpoint(serviceDescription))
{
if (serviceEndpoint.Contract.SessionMode != SessionMode.NotAllowed)
{
foundSessionfulContract = true;
}
foreach (OperationDescription operation in serviceEndpoint.Contract.Operations)
{
DurableOperationAttribute durableBehavior =
operation.Behaviors.Find <DurableOperationAttribute>();
if (durableBehavior == null)
{
durableBehavior = defaultDurableOperationBehavior;
}
if (serviceEndpoint.Contract.SessionMode == SessionMode.NotAllowed)
{
if (!durableBehavior.CanCreateInstanceForOperation(operation.IsOneWay))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new InvalidOperationException(
SR2.GetString(
SR2.CanCreateInstanceMustBeTrue,
serviceEndpoint.Contract.Name,
operation.Name)));
}
}
else
{
if (operation.IsOneWay &&
durableBehavior.CanCreateInstanceForOperation(operation.IsOneWay))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new InvalidOperationException(
SR2.GetString(
SR2.CanCreateInstanceMustBeTwoWay,
serviceEndpoint.Contract.Name,
serviceEndpoint.Contract.SessionMode,
operation.Name)));
}
}
if (this.saveStateInOperationTransaction)
{
bool hasTransaction = false;
OperationBehaviorAttribute operationBehavior = operation.Behaviors.Find <OperationBehaviorAttribute>();
if (operationBehavior != null)
{
if (operationBehavior.TransactionScopeRequired)
{
hasTransaction = true;
}
}
TransactionFlowAttribute transactionBehavior = operation.Behaviors.Find <TransactionFlowAttribute>();
if (transactionBehavior != null)
{
if (transactionBehavior.Transactions == TransactionFlowOption.Mandatory)
{
hasTransaction = true;
}
}
if (!hasTransaction)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new InvalidOperationException(
SR2.GetString(
SR2.SaveStateInTransactionValidationFailed,
operation.Name,
serviceEndpoint.ListenUri)));
}
}
}
}
}
if (!foundSessionfulContract)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new InvalidOperationException(
SR2.GetString(SR2.SessionfulContractNotFound)));
}
}
static CodeAttributeDeclaration CreateAttrDecl(OperationContractGenerationContext context, TransactionFlowAttribute attr)
{
CodeAttributeDeclaration attrDecl = new CodeAttributeDeclaration(context.Contract.ServiceContractGenerator.GetCodeTypeReference(typeof(TransactionFlowAttribute)));
attrDecl.Arguments.Add(new CodeAttributeArgument(ServiceContractGenerator.GetEnumReference <TransactionFlowOption>(attr.Transactions)));
return(attrDecl);
}
internal static void DemandTransactionPermissions(ServiceEndpoint endpoint, string operationName)
{
bool transactionFlow = false;
bool flowOptionAllowed = false;
if (endpoint.Binding is NetMsmqBinding)
{
NetMsmqBinding msmqBinding = endpoint.Binding as NetMsmqBinding;
if (msmqBinding.Durable)
{
transactionFlow = true;
if (Transaction.Current != null)
{
flowOptionAllowed = true;
}
}
}
if (endpoint.Binding is NetTcpBinding)
{
NetTcpBinding tcpBinding = endpoint.Binding as NetTcpBinding;
transactionFlow = tcpBinding.TransactionFlow;
}
if (endpoint.Binding is NetNamedPipeBinding)
{
NetNamedPipeBinding ipcBinding = endpoint.Binding as NetNamedPipeBinding;
transactionFlow = ipcBinding.TransactionFlow;
}
if (endpoint.Binding is WSHttpBinding)
{
WSHttpBinding wsBinding = endpoint.Binding as WSHttpBinding;
transactionFlow = wsBinding.TransactionFlow;
}
if (endpoint.Binding is WSDualHttpBinding)
{
WSDualHttpBinding wsDualBinding = endpoint.Binding as WSDualHttpBinding;
transactionFlow = wsDualBinding.TransactionFlow;
}
if (transactionFlow)
{
if (Transaction.Current != null)
{
//If operationName is null, then at least one operation needs to allow flow
foreach (OperationDescription operation in endpoint.Contract.Operations)
{
string name = operationName ?? operation.Name;
if (name != operation.Name)
{
continue;
}
foreach (IOperationBehavior behavior in operation.Behaviors)
{
if (behavior is TransactionFlowAttribute)
{
TransactionFlowAttribute attribute = behavior as TransactionFlowAttribute;
if (attribute.Transactions != TransactionFlowOption.NotAllowed)
{
flowOptionAllowed = true;
break;
}
}
}
if (flowOptionAllowed)
{
break;
}
}
if (flowOptionAllowed)
{
IPermission distributedTransactionPermission = new DistributedTransactionPermission(PermissionState.Unrestricted);
distributedTransactionPermission.Demand();
}
}
}
}
public GenericTransactionFlowAttribute(TransactionFlowOption flowOption)
{
this.transactionFlowAttribute = new TransactionFlowAttribute(flowOption);
}
