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);
}
static CorrelationQuery CreateDefaultCorrelationQuery(CorrelationQuery query, string action, CorrelationDataDescription data, ref bool shouldPreserveMessage)
{
MessageQuery messageQuery = new XPathMessageQuery
{
Expression = string.Format(CultureInfo.InvariantCulture, defaultQueryFormat, data.Name),
Namespaces = new XPathMessageContext()
};
if (data.IsOptional)
{
messageQuery = new OptionalMessageQuery
{
Query = messageQuery
};
}
if (query == null)
{
MessageFilter filter;
// verify if the data name is added by the context channel
bool isContextQuery = (data.Name == contextCorrelationName);
// if there is a query that is not a context query set it to true since we might read from
// the message body
if (!shouldPreserveMessage && !isContextQuery)
{
shouldPreserveMessage = true;
}
// this is a server side query, we use an action filter
if (action == MessageHeaders.WildcardAction)
{
filter = new MatchAllMessageFilter();
}
else
{
filter = new ActionMessageFilter(action);
}
return(new CorrelationQuery
{
Where = filter,
IsDefaultContextQuery = isContextQuery,
Select = new MessageQuerySet
{
{ data.Name, messageQuery }
}
});
}
else
{
query.Select[data.Name] = messageQuery;
return(query);
}
}
private void CollectCorrelationQueryFromReply(ref Collection <CorrelationQuery> correlationQueries, XName serviceContractName, Activity reply, OperationDescription operation)
{
SendReply reply2 = reply as SendReply;
if (reply2 != null)
{
CorrelationQuery correlationQuery = ContractInferenceHelper.CreateServerCorrelationQuery(null, reply2.CorrelationInitializers, operation, true);
this.CollectCorrelationQuery(ref correlationQueries, serviceContractName, correlationQuery);
}
}
private void CollectCorrelationQuery(ref Collection<CorrelationQuery> queries, XName serviceContractName, CorrelationQuery correlationQuery)
{
if (correlationQuery != null)
{
if ((queries == null) && !this.correlationQueryByContract.TryGetValue(serviceContractName, out queries))
{
queries = new Collection<CorrelationQuery>();
this.correlationQueryByContract.Add(serviceContractName, queries);
}
queries.Add(correlationQuery);
}
}
public static CorrelationQuery CreateServerCorrelationQuery(MessageQuerySet select, Collection <CorrelationInitializer> correlationInitializers, OperationDescription operation, bool isResponse)
{
CorrelationQuery query = CreateCorrelationQueryCore(select, correlationInitializers);
if (query != null)
{
string str = !isResponse ? operation.Messages[0].Action : operation.Messages[1].Action;
CorrelationActionMessageFilter filter = new CorrelationActionMessageFilter {
Action = str
};
query.Where = filter;
}
return(query);
}
internal void SetReplyCorrelationQuery(CorrelationQuery replyQuery)
{
if ((this.internalSend != null) && !this.internalSend.ReplyCorrelationQueries.Contains(replyQuery))
{
this.internalSend.ReplyCorrelationQueries.Add(replyQuery);
}
else
{
if (this.lazyCorrelationQueries == null)
{
this.lazyCorrelationQueries = new List <CorrelationQuery>();
}
this.lazyCorrelationQueries.Add(replyQuery);
}
}
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);
}
internal void SetReplyCorrelationQuery(CorrelationQuery replyQuery)
{
Fx.Assert(replyQuery != null, "replyQuery cannot be null!");
if (this.internalSend != null && !this.internalSend.ReplyCorrelationQueries.Contains(replyQuery))
{
this.internalSend.ReplyCorrelationQueries.Add(replyQuery);
}
else
{
// we save the CorrelationQuery and add it to InternalSendMessage later
if (this.lazyCorrelationQueries == null)
{
this.lazyCorrelationQueries = new List <CorrelationQuery>();
}
this.lazyCorrelationQueries.Add(replyQuery);
}
}
private static CorrelationQuery CreateDefaultCorrelationQuery(CorrelationQuery query, string action, CorrelationDataDescription data, ref bool shouldPreserveMessage)
{
XPathMessageQuery query5 = new XPathMessageQuery {
Expression = string.Format(CultureInfo.InvariantCulture, "sm:correlation-data('{0}')", new object[] { data.Name }),
Namespaces = new XPathMessageContext()
};
MessageQuery query2 = query5;
if (data.IsOptional)
{
OptionalMessageQuery query3 = new OptionalMessageQuery {
Query = query2
};
query2 = query3;
}
if (query == null)
{
MessageFilter filter;
bool flag = data.Name == "wsc-instanceId";
if (!shouldPreserveMessage && !flag)
{
shouldPreserveMessage = true;
}
if (action == "*")
{
filter = new MatchAllMessageFilter();
}
else
{
filter = new ActionMessageFilter(new string[] { action });
}
CorrelationQuery query4 = new CorrelationQuery {
Where = filter,
IsDefaultContextQuery = flag
};
MessageQuerySet set = new MessageQuerySet();
set.Add(data.Name, query2);
query4.Select = set;
return(query4);
}
query.Select[data.Name] = query2;
return(query);
}
// 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);
}
private static CorrelationQuery CreateCorrelationQueryCore(MessageQuerySet select, Collection <CorrelationInitializer> correlationInitializers)
{
CorrelationQuery query = null;
if (select != null)
{
query = new CorrelationQuery {
Select = select
};
}
if ((correlationInitializers != null) && (correlationInitializers.Count > 0))
{
foreach (CorrelationInitializer initializer in correlationInitializers)
{
QueryCorrelationInitializer initializer2 = initializer as QueryCorrelationInitializer;
if (initializer2 != null)
{
query = query ?? new CorrelationQuery();
query.SelectAdditional.Add(initializer2.MessageQuerySet);
}
}
}
return(query);
}
public static Collection <CorrelationQuery> CreateClientCorrelationQueries(MessageQuerySet select, Collection <CorrelationInitializer> correlationInitializers, string overridingAction, XName serviceContractName, string operationName, bool isResponse)
{
Collection <CorrelationQuery> collection = new Collection <CorrelationQuery>();
CorrelationQuery item = CreateCorrelationQueryCore(select, correlationInitializers);
if (item != null)
{
if (overridingAction != null)
{
CorrelationActionMessageFilter filter = new CorrelationActionMessageFilter {
Action = overridingAction
};
item.Where = filter;
}
else
{
ProvideDefaultNamespace(ref serviceContractName);
string str = NamingHelper.GetMessageAction(new XmlQualifiedName(serviceContractName.LocalName, serviceContractName.NamespaceName), operationName, null, isResponse);
CorrelationActionMessageFilter filter2 = new CorrelationActionMessageFilter {
Action = str
};
item.Where = filter2;
}
collection.Add(item);
if (isResponse)
{
CorrelationQuery query2 = item.Clone();
CorrelationActionMessageFilter filter3 = new CorrelationActionMessageFilter {
Action = string.Empty
};
query2.Where = filter3;
collection.Add(query2);
}
}
return(collection);
}
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;
}
void ConfigureBindingDefaultQueries(ServiceEndpoint endpoint, ICorrelationDataSource source, bool dispatch)
{
if (!CorrelationQuery.IsQueryCollectionSearchable(this.queries))
{
return;
}
// we should preserve the message if there are any existing queries added by the user
if (this.queries.Count <= 0)
{
this.shouldPreserveMessage = false;
}
foreach (OperationDescription operation in endpoint.Contract.Operations)
{
string inAction;
CorrelationQuery inQuery;
string outAction = null;
CorrelationQuery outQuery = null;
CorrelationQuery noActionReplyQuery = null;
inAction = operation.Messages[0].Action;
inQuery = CorrelationQuery.FindCorrelationQueryForAction(this.queries, inAction);
if (!operation.IsOneWay)
{
outAction = operation.Messages[1].Action;
outQuery = CorrelationQuery.FindCorrelationQueryForAction(this.queries, outAction);
if (!dispatch)
{
noActionReplyQuery = CorrelationQuery.FindCorrelationQueryForAction(this.queries, String.Empty);
}
}
// we will not add default query if a query already exists for the action
bool canDefaultIn = inQuery == null;
bool canDefaultOut = !operation.IsOneWay && outQuery == null;
// if there are no user added queries for receiveReply, we add a NoActionQuery
bool addNoActionQueryForReply = !operation.IsOneWay && !dispatch && noActionReplyQuery == null;
// On the client side we add special filters, SendFilter and ReceiveFilter
// But on dispatch side, we use ActionFilter and therefore need to verify that for wildcardaction, we
// only add a single defaultquery
if (canDefaultIn && canDefaultOut)
{
//verify if any of them is a wildcardaction, in that case let's just add a single query with a MatchAllFilter
if (inAction == MessageHeaders.WildcardAction)
{
canDefaultOut = false;
}
else if (outAction == MessageHeaders.WildcardAction)
{
canDefaultIn = false;
}
else if (inAction == outAction)
{
// in this case we will be adding the same query twice, let's just add once
// a possible scenario is when we add a contractDescription with wildcardaction for request & reply
canDefaultOut = false;
}
}
if (!canDefaultIn && !canDefaultOut)
{
continue;
}
foreach (CorrelationDataDescription data in source.DataSources)
{
if (!data.IsDefault)
{
continue;
}
if (canDefaultIn &&
(dispatch && data.ReceiveValue || data.SendValue))
{
inQuery = CreateDefaultCorrelationQuery(inQuery, inAction, data, ref shouldPreserveMessage);
}
if (canDefaultOut &&
(dispatch && data.SendValue || data.ReceiveValue))
{
outQuery = CreateDefaultCorrelationQuery(outQuery, outAction, data, ref shouldPreserveMessage);
}
if (addNoActionQueryForReply)
{
noActionReplyQuery = CreateDefaultCorrelationQuery(noActionReplyQuery, String.Empty, data, ref shouldPreserveMessage);
}
}
if (canDefaultIn && inQuery != null)
{
this.queries.Add(inQuery);
}
if (canDefaultOut && outQuery != null)
{
this.queries.Add(outQuery);
}
if (addNoActionQueryForReply && noActionReplyQuery != null)
{
this.queries.Add(noActionReplyQuery);
}
}
}
private void ConfigureBindingDefaultQueries(ServiceEndpoint endpoint, ICorrelationDataSource source, bool dispatch)
{
if (CorrelationQuery.IsQueryCollectionSearchable(this.queries))
{
if (this.queries.Count <= 0)
{
this.shouldPreserveMessage = false;
}
foreach (OperationDescription description in endpoint.Contract.Operations)
{
string action = null;
CorrelationQuery query2 = null;
CorrelationQuery query3 = null;
string str = description.Messages[0].Action;
CorrelationQuery query = CorrelationQuery.FindCorrelationQueryForAction(this.queries, str);
if (!description.IsOneWay)
{
action = description.Messages[1].Action;
query2 = CorrelationQuery.FindCorrelationQueryForAction(this.queries, action);
if (!dispatch)
{
query3 = CorrelationQuery.FindCorrelationQueryForAction(this.queries, string.Empty);
}
}
bool flag = query == null;
bool flag2 = !description.IsOneWay && (query2 == null);
bool flag3 = (!description.IsOneWay && !dispatch) && (query3 == null);
if (flag && flag2)
{
if (str == "*")
{
flag2 = false;
}
else if (action == "*")
{
flag = false;
}
else if (str == action)
{
flag2 = false;
}
}
if (flag || flag2)
{
foreach (CorrelationDataDescription description2 in source.DataSources)
{
if (description2.IsDefault)
{
if (flag && ((dispatch && description2.ReceiveValue) || description2.SendValue))
{
query = CreateDefaultCorrelationQuery(query, str, description2, ref this.shouldPreserveMessage);
}
if (flag2 && ((dispatch && description2.SendValue) || description2.ReceiveValue))
{
query2 = CreateDefaultCorrelationQuery(query2, action, description2, ref this.shouldPreserveMessage);
}
if (flag3)
{
query3 = CreateDefaultCorrelationQuery(query3, string.Empty, description2, ref this.shouldPreserveMessage);
}
}
}
if (flag && (query != null))
{
this.queries.Add(query);
}
if (flag2 && (query2 != null))
{
this.queries.Add(query2);
}
if (flag3 && (query3 != null))
{
this.queries.Add(query3);
}
}
}
}
}
internal void SetReplyCorrelationQuery(CorrelationQuery replyQuery)
{
if ((this.internalSend != null) && !this.internalSend.ReplyCorrelationQueries.Contains(replyQuery))
{
this.internalSend.ReplyCorrelationQueries.Add(replyQuery);
}
else
{
if (this.lazyCorrelationQueries == null)
{
this.lazyCorrelationQueries = new List<CorrelationQuery>();
}
this.lazyCorrelationQueries.Add(replyQuery);
}
}
internal void SetReplyCorrelationQuery(CorrelationQuery replyQuery)
{
Fx.Assert(replyQuery != null, "replyQuery cannot be null!");
if (this.internalSend != null && !this.internalSend.ReplyCorrelationQueries.Contains(replyQuery))
{
this.internalSend.ReplyCorrelationQueries.Add(replyQuery);
}
else
{
// we save the CorrelationQuery and add it to InternalSendMessage later
if (this.lazyCorrelationQueries == null)
{
this.lazyCorrelationQueries = new List<CorrelationQuery>();
}
this.lazyCorrelationQueries.Add(replyQuery);
}
}
internal IDictionary <XName, ContractDescription> GetContractDescriptions()
{
if (this.cachedInferredContracts == null)
{
this.WalkActivityTree();
this.correlationQueryByContract = new Dictionary <XName, Collection <CorrelationQuery> >();
IDictionary <XName, ContractDescription> dictionary = new Dictionary <XName, ContractDescription>();
IDictionary <ContractAndOperationNameTuple, OperationInfo> dictionary2 = new Dictionary <ContractAndOperationNameTuple, OperationInfo>();
foreach (Receive receive in this.knownServiceActivities)
{
OperationInfo info;
XName serviceContractXName = this.FixServiceContractName(receive.ServiceContractName);
ContractAndOperationNameTuple key = new ContractAndOperationNameTuple(serviceContractXName, receive.OperationName);
if (dictionary2.TryGetValue(key, out info))
{
ContractValidationHelper.ValidateReceiveWithReceive(receive, info.Receive);
}
else
{
ContractDescription description;
if (!dictionary.TryGetValue(serviceContractXName, out description))
{
description = new ContractDescription(serviceContractXName.LocalName, serviceContractXName.NamespaceName)
{
ConfigurationName = serviceContractXName.LocalName
};
dictionary.Add(serviceContractXName, description);
}
OperationDescription item = ContractInferenceHelper.CreateOperationDescription(receive, description);
description.Operations.Add(item);
info = new OperationInfo(receive, item);
dictionary2.Add(key, info);
}
this.CorrectOutMessageForOperationWithFault(receive, info);
ContractInferenceHelper.UpdateIsOneWayFlag(receive, info.OperationDescription);
ContractInferenceHelper.AddFaultDescription(receive, info.OperationDescription);
ContractInferenceHelper.AddKnownTypesToOperation(receive, info.OperationDescription);
ContractInferenceHelper.AddReceiveToFormatterBehavior(receive, info.OperationDescription);
Collection <CorrelationQuery> queries = null;
if (receive.HasCorrelatesOn || receive.HasCorrelationInitializers)
{
MessageQuerySet select = receive.HasCorrelatesOn ? receive.CorrelatesOn : null;
CorrelationQuery correlationQuery = ContractInferenceHelper.CreateServerCorrelationQuery(select, receive.CorrelationInitializers, info.OperationDescription, false);
this.CollectCorrelationQuery(ref queries, serviceContractXName, correlationQuery);
}
if (receive.HasReply)
{
foreach (SendReply reply in receive.FollowingReplies)
{
ReceiveAndReplyTuple tuple2 = new ReceiveAndReplyTuple(receive, reply);
this.receiveAndReplyPairs.Remove(tuple2);
this.CollectCorrelationQueryFromReply(ref queries, serviceContractXName, reply, info.OperationDescription);
reply.SetContractName(serviceContractXName);
}
}
if (receive.HasFault)
{
foreach (Activity activity in receive.FollowingFaults)
{
ReceiveAndReplyTuple tuple3 = new ReceiveAndReplyTuple(receive, activity);
this.receiveAndReplyPairs.Remove(tuple3);
this.CollectCorrelationQueryFromReply(ref queries, serviceContractXName, activity, info.OperationDescription);
}
}
}
if (this.receiveAndReplyPairs.Count != 0)
{
throw System.ServiceModel.Activities.FxTrace.Exception.AsError(new ValidationException(System.ServiceModel.Activities.SR.DanglingReceive));
}
if (System.ServiceModel.Activities.TD.InferredContractDescriptionIsEnabled())
{
foreach (ContractDescription description3 in dictionary.Values)
{
System.ServiceModel.Activities.TD.InferredContractDescription(description3.Name, description3.Namespace);
if (System.ServiceModel.Activities.TD.InferredOperationDescriptionIsEnabled())
{
foreach (OperationDescription description4 in description3.Operations)
{
System.ServiceModel.Activities.TD.InferredOperationDescription(description4.Name, description3.Name, description4.IsOneWay.ToString());
}
}
}
}
this.cachedInferredContracts = dictionary;
}
return(this.cachedInferredContracts);
}
private void CollectCorrelationQuery(ref Collection <CorrelationQuery> queries, XName serviceContractName, CorrelationQuery correlationQuery)
{
if (correlationQuery != null)
{
if ((queries == null) && !this.correlationQueryByContract.TryGetValue(serviceContractName, out queries))
{
queries = new Collection <CorrelationQuery>();
this.correlationQueryByContract.Add(serviceContractName, queries);
}
queries.Add(correlationQuery);
}
}
private static CorrelationQuery CreateCorrelationQueryCore(MessageQuerySet select, Collection<CorrelationInitializer> correlationInitializers)
{
CorrelationQuery query = null;
if (select != null)
{
query = new CorrelationQuery {
Select = select
};
}
if ((correlationInitializers != null) && (correlationInitializers.Count > 0))
{
foreach (CorrelationInitializer initializer in correlationInitializers)
{
QueryCorrelationInitializer initializer2 = initializer as QueryCorrelationInitializer;
if (initializer2 != null)
{
query = query ?? new CorrelationQuery();
query.SelectAdditional.Add(initializer2.MessageQuerySet);
}
}
}
return query;
}
