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
290 lines
11 KiB
C#
290 lines
11 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.Globalization;
|
|
using System.Runtime;
|
|
using System.ServiceModel.Channels;
|
|
using System.ServiceModel.Dispatcher;
|
|
using SR2 = System.ServiceModel.Activities.SR;
|
|
using System.Runtime.DurableInstancing;
|
|
using System.Xml.Linq;
|
|
|
|
class ToReply : NativeActivity
|
|
{
|
|
IDispatchMessageFormatter formatter;
|
|
IDispatchFaultFormatter faultFormatter;
|
|
|
|
Collection<InArgument> parameters;
|
|
|
|
public IDispatchMessageFormatter Formatter
|
|
{
|
|
get
|
|
{
|
|
return this.formatter;
|
|
}
|
|
set
|
|
{
|
|
this.formatter = value;
|
|
ValidateFormatters();
|
|
}
|
|
}
|
|
|
|
public IDispatchFaultFormatter FaultFormatter
|
|
{
|
|
get
|
|
{
|
|
return this.faultFormatter;
|
|
}
|
|
set
|
|
{
|
|
this.faultFormatter = value;
|
|
ValidateFormatters();
|
|
}
|
|
}
|
|
|
|
public bool IncludeExceptionDetailInFaults
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public InArgument Result
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public Collection<InArgument> Parameters
|
|
{
|
|
get
|
|
{
|
|
if (this.parameters == null)
|
|
{
|
|
this.parameters = new Collection<InArgument>();
|
|
}
|
|
return this.parameters;
|
|
}
|
|
}
|
|
|
|
//CorrelationHandle is required to get the message version from the InternalReceivedMessage
|
|
public InArgument<CorrelationHandle> CorrelatesWith
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public OutArgument<Message> Message
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
protected override void CacheMetadata(NativeActivityMetadata metadata)
|
|
{
|
|
if (this.Result != null)
|
|
{
|
|
RuntimeArgument resultArgument = new RuntimeArgument(Constants.Result, this.Result.ArgumentType, ArgumentDirection.In);
|
|
metadata.Bind(this.Result, resultArgument);
|
|
metadata.AddArgument(resultArgument);
|
|
}
|
|
|
|
if (this.parameters != null)
|
|
{
|
|
int count = 0;
|
|
foreach (InArgument parameter in this.parameters)
|
|
{
|
|
RuntimeArgument parameterArgument = new RuntimeArgument(Constants.Parameter + count++, parameter.ArgumentType, ArgumentDirection.In);
|
|
metadata.Bind(parameter, parameterArgument);
|
|
metadata.AddArgument(parameterArgument);
|
|
}
|
|
}
|
|
|
|
RuntimeArgument messageArgument = new RuntimeArgument(Constants.Message, Constants.MessageType, ArgumentDirection.Out, true);
|
|
if (this.Message == null)
|
|
{
|
|
this.Message = new OutArgument<Message>();
|
|
}
|
|
metadata.Bind(this.Message, messageArgument);
|
|
metadata.AddArgument(messageArgument);
|
|
|
|
RuntimeArgument correlatesWithArgument = new RuntimeArgument(Constants.CorrelatesWith, Constants.CorrelationHandleType, ArgumentDirection.In);
|
|
if (this.CorrelatesWith == null)
|
|
{
|
|
this.CorrelatesWith = new InArgument<CorrelationHandle>();
|
|
}
|
|
metadata.Bind(this.CorrelatesWith, correlatesWithArgument);
|
|
metadata.AddArgument(correlatesWithArgument);
|
|
|
|
}
|
|
|
|
protected override void Execute(NativeActivityContext context)
|
|
{
|
|
MessageVersion version;
|
|
|
|
SendReceiveExtension sendReceiveExtension = context.GetExtension<SendReceiveExtension>();
|
|
if (sendReceiveExtension != null)
|
|
{
|
|
HostSettings hostSettings = sendReceiveExtension.HostSettings;
|
|
this.IncludeExceptionDetailInFaults = hostSettings.IncludeExceptionDetailInFaults;
|
|
}
|
|
|
|
CorrelationHandle correlatesWith = (this.CorrelatesWith == null) ? null : this.CorrelatesWith.Get(context);
|
|
if (correlatesWith == null)
|
|
{
|
|
correlatesWith = context.Properties.Find(CorrelationHandle.StaticExecutionPropertyName) as CorrelationHandle;
|
|
}
|
|
|
|
CorrelationResponseContext responseContext;
|
|
if (correlatesWith != null)
|
|
{
|
|
if (sendReceiveExtension != null)
|
|
{
|
|
if (!this.TryGetMessageVersion(correlatesWith.InstanceKey, out version))
|
|
{
|
|
throw FxTrace.Exception.AsError(new InvalidOperationException(SR2.MessageVersionInformationNotFound));
|
|
}
|
|
}
|
|
else if (correlatesWith.TryAcquireResponseContext(context, out responseContext))
|
|
{
|
|
//Register the ResponseContext so that InternalSendMessage can access it.
|
|
if (!correlatesWith.TryRegisterResponseContext(context, responseContext))
|
|
{
|
|
throw FxTrace.Exception.AsError(new InvalidOperationException(SR2.ResponseContextIsNotNull));
|
|
}
|
|
|
|
//Use the same MessageVersion as the incoming message that is retrieved using CorrelatonHandle
|
|
version = responseContext.MessageVersion;
|
|
}
|
|
else
|
|
{
|
|
throw FxTrace.Exception.AsError(new InvalidOperationException(SR2.CorrelationResponseContextShouldNotBeNull));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
throw FxTrace.Exception.AsError(new InvalidOperationException(SR2.CorrelationResponseContextShouldNotBeNull));
|
|
}
|
|
|
|
Fx.Assert((this.Formatter == null && this.FaultFormatter != null) ||
|
|
(this.Formatter != null && this.FaultFormatter == null),
|
|
"OperationFormatter and FaultFormatter cannot be both null or both set!");
|
|
|
|
if (this.FaultFormatter != null)
|
|
{
|
|
Fx.Assert(this.parameters.Count == 1, "Exception should be the only parameter!");
|
|
Exception exception = this.parameters[0].Get(context) as Exception;
|
|
Fx.Assert(exception != null, "InArgument must be an Exception!");
|
|
|
|
MessageFault messageFault;
|
|
string action;
|
|
|
|
FaultException faultException = exception as FaultException;
|
|
if (faultException != null)
|
|
{
|
|
// This is an expected fault
|
|
// Reproduce logic from ErrorBehavior.InitializeFault
|
|
|
|
messageFault = this.FaultFormatter.Serialize(faultException, out action);
|
|
if (action == null)
|
|
{
|
|
action = version.Addressing.DefaultFaultAction;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// This is an unexpected fault
|
|
// Reproduce logic from ErrorBehavior.ProvideFaultOfLastResort
|
|
|
|
FaultCode code = new FaultCode(FaultCodeConstants.Codes.InternalServiceFault, FaultCodeConstants.Namespaces.NetDispatch);
|
|
code = FaultCode.CreateReceiverFaultCode(code);
|
|
|
|
action = FaultCodeConstants.Actions.NetDispatcher;
|
|
|
|
if (this.IncludeExceptionDetailInFaults)
|
|
{
|
|
messageFault = MessageFault.CreateFault(code,
|
|
new FaultReason(new FaultReasonText(exception.Message, CultureInfo.CurrentCulture)),
|
|
new ExceptionDetail(exception));
|
|
}
|
|
else
|
|
{
|
|
messageFault = MessageFault.CreateFault(code,
|
|
new FaultReason(new FaultReasonText(SR2.InternalServerError, CultureInfo.CurrentCulture)));
|
|
}
|
|
}
|
|
|
|
if (messageFault == null)
|
|
{
|
|
throw FxTrace.Exception.AsError(new InvalidOperationException(SR2.CannotCreateMessageFault));
|
|
}
|
|
else
|
|
{
|
|
Message outMessage = System.ServiceModel.Channels.Message.CreateMessage(version, messageFault, action);
|
|
this.Message.Set(context, outMessage);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
object[] inObjects;
|
|
if (this.parameters != null)
|
|
{
|
|
inObjects = new object[this.parameters.Count];
|
|
for (int i = 0; i < this.parameters.Count; i++)
|
|
{
|
|
Fx.Assert(this.Parameters[i] != null, "Parameter cannot be null");
|
|
inObjects[i] = this.parameters[i].Get(context);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
inObjects = Constants.EmptyArray;
|
|
}
|
|
|
|
object returnValue = null;
|
|
if (this.Result != null)
|
|
{
|
|
returnValue = this.Result.Get(context);
|
|
}
|
|
|
|
Message outMessage = this.Formatter.SerializeReply(version, inObjects, returnValue);
|
|
this.Message.Set(context, outMessage);
|
|
}
|
|
}
|
|
|
|
bool TryGetMessageVersion(InstanceKey instanceKey, out MessageVersion version)
|
|
{
|
|
Fx.Assert(instanceKey != null, "Expect a valid instanceKey here");
|
|
version = MessageVersion.None;
|
|
if (instanceKey != null)
|
|
{
|
|
InstanceValue messageVersionValue;
|
|
if (instanceKey.Metadata.TryGetValue(WorkflowServiceNamespace.MessageVersionForReplies, out messageVersionValue))
|
|
{
|
|
version = (MessageVersion)messageVersionValue.Value;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void ValidateFormatters()
|
|
{
|
|
if (this.Formatter == null && this.FaultFormatter == null)
|
|
{
|
|
throw FxTrace.Exception.AsError(new ValidationException(SR2.OperationFormatterAndFaultFormatterNotSet));
|
|
}
|
|
if (this.Formatter != null && this.FaultFormatter != null)
|
|
{
|
|
throw FxTrace.Exception.AsError(new ValidationException(SR2.OperationFormatterAndFaultFormatterIncorrectlySet));
|
|
}
|
|
}
|
|
}
|
|
}
|