public Activity Create(DependencyObject target)
{
string correlationHandleName = ActivityDesignerHelper.GenerateUniqueVariableNameForContext(target, correlationHandleNamePrefix);
Variable<CorrelationHandle> requestReplyCorrelation = new Variable<CorrelationHandle> { Name = correlationHandleName };
Send send = new Send
{
OperationName = "Operation1",
ServiceContractName = XName.Get("IService", "http://tempuri.org/"),
CorrelationInitializers =
{
new RequestReplyCorrelationInitializer
{
CorrelationHandle = new VariableValue<CorrelationHandle> { Variable = requestReplyCorrelation }
}
}
};
Sequence sequence = new Sequence()
{
Variables = { requestReplyCorrelation },
Activities =
{
send,
new ReceiveReply
{
DisplayName = "ReceiveReplyForSend",
Request = send,
},
}
};
return sequence;
}
static void CreateClientWorkflow()
{
Variable<string> message = new Variable<string>("message", "Hello!");
Variable<string> result = new Variable<string> { Name = "result" };
Endpoint endpoint = new Endpoint
{
AddressUri = new Uri(Microsoft.Samples.WorkflowServicesSamples.Common.Constants.ServiceBaseAddress),
Binding = new BasicHttpBinding(),
};
Send requestEcho = new Send
{
ServiceContractName = XName.Get("Echo", "http://tempuri.org/"),
Endpoint = endpoint,
OperationName = "Echo",
//parameters for send
Content = new SendParametersContent
{
Parameters =
{
{ "message", new InArgument<string>(message) }
}
}
};
workflow = new CorrelationScope
{
Body = new Sequence
{
Variables = { message, result },
Activities =
{
new WriteLine {
Text = new InArgument<string>("Client is ready!")
},
requestEcho,
new WriteLine {
Text = new InArgument<string>("Message sent: Hello!")
},
new ReceiveReply
{
Request = requestEcho,
//parameters for the reply
Content = new ReceiveParametersContent
{
Parameters =
{
{ "echo", new OutArgument<string>(result) }
}
}
},
new WriteLine {
Text = new InArgument<string>(env => "Message received: "+result.Get(env))
}
}
}
};
}
static Activity BuildRequestReply()
{
Send send = new Send
{
OperationName = "DoRequestReply",
EndpointConfigurationName = "clientEndpoint",
ServiceContractName = XName.Get("ISuppressSample", "http://tempuri.org/"),
};
return new CorrelationScope
{
Body = new Sequence
{
Activities =
{
new WriteLine { Text = "Beginning RequestReply sequence" },
send,
new PrintTxID(),
new ReceiveReply
{
Request = send,
},
new WriteLine { Text = "End RequestReply sequence" },
},
},
};
}
static Activity GetClientWorkflow()
{
Variable<PurchaseOrder> po = new Variable<PurchaseOrder>();
Variable<OrderStatus> orderStatus = new Variable<OrderStatus>();
Endpoint clientEndpoint = new Endpoint
{
Binding = Constants.Binding,
AddressUri = new Uri(Constants.ServiceAddress)
};
Send submitPO = new Send
{
Endpoint = clientEndpoint,
ServiceContractName = Constants.POContractName,
OperationName = Constants.SubmitPOName,
Content = SendContent.Create(new InArgument<PurchaseOrder>(po))
};
return new Sequence
{
Variables = { po, orderStatus },
Activities =
{
new WriteLine { Text = "Sending order for 150 widgets." },
new Assign<PurchaseOrder> { To = po, Value = new InArgument<PurchaseOrder>( (e) => new PurchaseOrder() { PartName = "Widget", Quantity = 150 } ) },
new CorrelationScope
{
Body = new Sequence
{
Activities =
{
submitPO,
new ReceiveReply
{
Request = submitPO,
Content = ReceiveContent.Create(new OutArgument<int>( (e) => po.Get(e).Id ))
}
}
}
},
new WriteLine { Text = new InArgument<string>( (e) => string.Format("Got PoId: {0}", po.Get(e).Id) ) },
new Assign<OrderStatus> { To = orderStatus, Value = new InArgument<OrderStatus>( (e) => new OrderStatus() { Id = po.Get(e).Id, Confirmed = true }) },
new Send
{
Endpoint = clientEndpoint,
ServiceContractName = Constants.POContractName,
OperationName = Constants.ConfirmPurchaseOrder,
Content = SendContent.Create(new InArgument<OrderStatus>(orderStatus))
},
new WriteLine { Text = "The order was confirmed." },
new WriteLine { Text = "Client completed." }
}
};
}
static void CreateClientWorkflow()
{
Variable<string> message = new Variable<string>("message", "client");
Variable<string> result = new Variable<string> { Name = "result" };
Endpoint endpoint = new Endpoint
{
AddressUri = new Uri(Common.Constants.ServiceBaseAddress),
Binding = new BasicHttpBinding(),
};
Send requestEcho = new Send
{
ServiceContractName = XName.Get("Echo", "http://tempuri.org/"),
Endpoint = endpoint,
OperationName = "Echo",
Content = new SendParametersContent
{
Parameters =
{
{ "message", new InArgument<string>(message) }
}
}
};
workflow = new CorrelationScope
{
Body = new Sequence
{
Variables = { message, result },
Activities =
{
new WriteLine {
Text = new InArgument<string>("Hello")
},
requestEcho,
new ReceiveReply
{
Request = requestEcho,
Content = new ReceiveParametersContent
{
Parameters =
{
{ "echo", new OutArgument<string>(result) }
}
}
},
new WriteLine {
Text = new InArgument<string>(result)
}
}
}
};
}
private Activity InternalImplementation()
{
Variable<string> reply = new Variable<string> { Name = "replyString" };
Send send = new Send
{
OperationName = "StartSample",
Content = SendContent.Create(new InArgument<string>("Client side: Send request.")),
EndpointConfigurationName = "codeServiceEndpoint",
ServiceContractName = "ITransactedReceiveService",
};
return new CorrelationScope
{
Body = new Sequence
{
Variables = { reply },
Activities =
{
new WriteLine { Text = "Client workflow begins." },
new TransactionScope
{
Body = new Sequence
{
Activities =
{
// Transaction DistributedIdentifier will be emtpy until the send activity causes the transaction to promote to MSDTC
new PrintTransactionInfo(),
new WriteLine { Text = new InArgument<string>("Client side: Beginning send.") },
send,
new WriteLine { Text = new InArgument<string>("Client side: Send complete.") },
new ReceiveReply
{
Request = send,
Content = ReceiveContent.Create(new OutArgument<string>(reply))
},
new WriteLine { Text = new InArgument<string>(new VisualBasicValue<string>() { ExpressionText = "\"Client side: Reply received = '\" + replyString.toString() + \"'\"" }) },
new PrintTransactionInfo(),
new WriteLine { Text = new InArgument<string>("Client side: Receive complete.") },
},
},
},
new WriteLine { Text = "Client workflow ends." }
}
}
};
}
public static OperationDescription CreateOneWayOperationDescription(Send send)
{
Fx.Assert(send != null, "Argument cannot be null!");
return CreateOperationDescriptionCore(send, null);
}
static Sequence VendorApprovalRequest(Endpoint endpoint)
{
Variable<VendorRequest> vendor = new Variable<VendorRequest>
{
Name = "vendor",
};
Variable<VendorResponse> result = new Variable<VendorResponse>
{
Name = "result"
};
Send approvedVendor = new Send
{
ServiceContractName = XName.Get("FinanceService", "http://tempuri.org/"),
Endpoint = endpoint,
OperationName = "ApprovedVendor",
Content = SendContent.Create(new InArgument<VendorRequest>(vendor)),
};
Sequence workflow = new Sequence
{
Variables = { vendor, result },
Activities =
{
new Assign<VendorRequest>
{
Value = new InArgument<VendorRequest>( (e) => new VendorRequest { Name = "Vendor1", requestingDepartment = "HR" }),
To = new OutArgument<VendorRequest>(vendor)
},
new WriteLine
{
Text = new InArgument<string>("Hello")
},
approvedVendor,
new ReceiveReply
{
Request = approvedVendor,
Content = ReceiveContent.Create(new OutArgument<VendorResponse>(result))
},
new If
{
Condition = new InArgument<bool> (env => result.Get(env).isPreApproved),
Then =
new WriteLine
{
Text = new InArgument<string>("Vendor Approved")
},
Else =
new WriteLine
{
Text = new InArgument<string>("Vendor is not Approved")
},
},
}
};
return workflow;
}
static Activity GetClientWorkflow()
{
Variable<PurchaseOrder> po = new Variable<PurchaseOrder>();
Variable<Customer> customer = new Variable<Customer>();
Endpoint clientEndpoint = new Endpoint
{
Binding = Constants.Binding,
AddressUri = new Uri(Constants.ServiceAddress)
};
Send submitPO = new Send
{
Endpoint = clientEndpoint,
ServiceContractName = Constants.POContractName,
OperationName = Constants.SubmitPOName,
Content = SendContent.Create(new InArgument<PurchaseOrder>(po))
};
return new Sequence
{
Variables = { po, customer },
Activities =
{
new Assign<PurchaseOrder>
{
To = po,
Value = new InArgument<PurchaseOrder>( (e) => new PurchaseOrder() { PartName = "Widget", Quantity = 150 } )
},
new Assign<Customer>
{
To = customer,
Value = new InArgument<Customer>( (e) => new Customer() { Id = 12345678, Name = "John Smith" } )
},
new WriteLine { Text = new InArgument<string>( (e) => string.Format("Submitting new PurchaseOrder for {0} {1}s", po.Get(e).Quantity, po.Get(e).PartName) ) },
new CorrelationScope
{
Body = new Sequence
{
Activities =
{
submitPO,
new ReceiveReply
{
Request = submitPO,
Content = ReceiveContent.Create(new OutArgument<int>( (e) => po.Get(e).Id ))
}
}
}
},
new WriteLine { Text = new InArgument<string>( (e) => string.Format("Received ID for new PO: {0}", po.Get(e).Id) ) },
new Assign<int> { To = new OutArgument<int>( (e) => po.Get(e).Quantity ), Value = 250 },
new WriteLine { Text = "Updated PO with new quantity: 250. Resubmitting updated PurchaseOrder based on POId." },
new Send
{
Endpoint = clientEndpoint,
ServiceContractName = Constants.POContractName,
OperationName = Constants.UpdatePOName,
Content = SendContent.Create(new InArgument<PurchaseOrder>(po))
},
new Assign<int>
{
To = new OutArgument<int>( (e) => po.Get(e).CustomerId ),
Value = new InArgument<int>( (e) => customer.Get(e).Id )
},
new WriteLine { Text = "Updating customer data based on CustomerId." },
new Send
{
Endpoint = clientEndpoint,
ServiceContractName = Constants.POContractName,
OperationName = Constants.AddCustomerInfoName,
Content = SendContent.Create(new InArgument<PurchaseOrder>(po))
},
new Send
{
Endpoint = clientEndpoint,
ServiceContractName = Constants.POContractName,
OperationName = Constants.UpdateCustomerName,
Content = SendContent.Create(new InArgument<Customer>(customer))
},
new WriteLine { Text = "Client completed." }
}
};
}
private Activity InternalImplementation()
{
string correlationKey = Guid.NewGuid().ToString();
Send sendBootstrap = new Send
{
OperationName = "Bootstrap",
EndpointConfigurationName = endpointConfigurationName,
Content = SendMessageContent.Create(new InArgument<string>(correlationKey)),
ServiceContractName = Constants.ServiceContractName,
};
// In this sample there is no client side transaction, so transaction flow is not occuring.
// Instead the service workflow is creating and scoping the transaction.
return new CorrelationScope()
{
Body = new Sequence
{
Activities =
{
new WriteLine { Text = "Client: Workflow begins." },
new WriteLine { Text = "Client: Bootstrap service." },
// The service requires an initial Request represented by this "bootstrap" message.
sendBootstrap,
new ReceiveReply
{
Request = sendBootstrap
},
new WriteLine { Text = "Client: Beginning parallel sends." },
// The service workflow is now in a state where it's accepting multiple requests in parallel.
// All of these requests will execute under the same server side transaction.
new Parallel()
{
CompletionCondition = false,
Branches =
{
new Send
{
OperationName = "WorkBranch1",
ServiceContractName = Constants.ServiceContractName,
EndpointConfigurationName = endpointConfigurationName,
Content = SendMessageContent.Create(new InArgument<string>(correlationKey))
},
new Send
{
OperationName = "WorkBranch2",
ServiceContractName = Constants.ServiceContractName,
EndpointConfigurationName = endpointConfigurationName,
Content = SendMessageContent.Create(new InArgument<string>(correlationKey)),
},
new Send
{
OperationName = "WorkBranch3",
ServiceContractName = Constants.ServiceContractName,
EndpointConfigurationName = endpointConfigurationName,
Content = SendMessageContent.Create(new InArgument<string>(correlationKey)),
},
},
},
new WriteLine { Text = "Client: All sends complete." },
new WriteLine { Text = "Client: Workflow ends." }
}
}
};
}
static Sequence ExpenseRequest(Endpoint endpoint)
{
Variable<Expense> mealExpense = new Variable<Expense>
{
Name = "mealExpense",
};
Variable<bool> result = new Variable<bool>
{
Name = "result"
};
Send approveExpense = new Send
{
ServiceContractName = XName.Get("FinanceService", "http://tempuri.org/"),
Endpoint = endpoint,
OperationName = "ApproveExpense",
Content = SendContent.Create(new InArgument<Expense>(mealExpense))
};
approveExpense.KnownTypes.Add(typeof(Travel));
approveExpense.KnownTypes.Add(typeof(Meal));
Sequence workflow = new Sequence
{
Variables = { mealExpense, result },
Activities =
{
new Assign<Expense>
{
Value = new InArgument<Expense>( (e) => new Meal { Amount = 50, Location = "Redmond", Vendor = "KFC" }),
To = new OutArgument<Expense>(mealExpense)
},
new WriteLine
{
Text = new InArgument<string>("Hello")
},
approveExpense,
new ReceiveReply
{
Request = approveExpense,
Content = ReceiveContent.Create(new OutArgument<bool>(result))
},
new If
{
Condition = new InArgument<bool> (result),
Then =
new WriteLine
{
Text = new InArgument<string>("Expense Approved")
},
Else =
new WriteLine
{
Text = new InArgument<string>("Expense Cannot be Approved")
},
},
}
};
return workflow;
}
static Activity GetClientWorkflow()
{
Variable<PurchaseOrder> po = new Variable<PurchaseOrder>();
Variable<bool> invalidorder = new Variable<bool>() { Default = true };
Variable<string> replytext = new Variable<string>();
DelegateInArgument<FaultException<POFault>> poFault = new DelegateInArgument<FaultException<POFault>>();
DelegateInArgument<FaultException<ExceptionDetail>> unexpectedFault = new DelegateInArgument<FaultException<ExceptionDetail>>();
// submits a purchase order for the part and quantity stored in the po variable
Send submitPO = new Send
{
Endpoint = new Endpoint
{
Binding = Constants.Binding,
AddressUri = new Uri(Constants.ServiceAddress)
},
ServiceContractName = Constants.POContractName,
OperationName = Constants.SubmitPOName,
KnownTypes = { typeof(POFault) },
Content = SendContent.Create(new InArgument<PurchaseOrder>(po))
};
return new CorrelationScope
{
Body = new Sequence
{
Variables = { invalidorder, po },
Activities =
{
// defines the original desired parts and quantity: 155 pencils
new Assign<PurchaseOrder>
{
To = po,
Value = new InArgument<PurchaseOrder>( (e) => new PurchaseOrder() { PartName = "Pencil", Quantity = 155 } )
},
new While
{
// loop until a valid order is submitted
Condition = invalidorder,
Variables = { replytext },
Body = new Sequence
{
Activities =
{
// print out the order that will be submitted
new WriteLine { Text = new InArgument<string>((env) => string.Format("Submitting Order: {0} {1}s", po.Get(env).Quantity, po.Get(env).PartName)) },
// submit the order
submitPO,
new TryCatch
{
Try = new Sequence
{
Activities =
{
// receive the result of the order
// if ReceiveReply gets a Fault message, then we will handle those faults below
new ReceiveReply
{
Request = submitPO,
Content = ReceiveContent.Create(new OutArgument<string>(replytext))
},
new WriteLine { Text = replytext },
// this order must be valid, so set invalidorder to false
new Assign<bool>
{
To = invalidorder,
Value = false
}
}
},
Catches =
{
// catch a known Fault type: POFault
new Catch<FaultException<POFault>>
{
Action = new ActivityAction<FaultException<POFault>>
{
Argument = poFault,
Handler = new Sequence
{
Activities =
{
// print out the details of the POFault
new WriteLine { Text = new InArgument<string>((env) => string.Format("\tReceived POFault: {0}", poFault.Get(env).Reason.ToString())) },
new WriteLine { Text = new InArgument<string>((env) => string.Format("\tPOFault Problem: {0}", poFault.Get(env).Detail.Problem)) },
new WriteLine { Text = new InArgument<string>((env) => string.Format("\tPOFault Solution: {0}", poFault.Get(env).Detail.Solution)) },
// update the order to buy Widgets instead
new Assign<string>
{
To = new OutArgument<string>( (e) => po.Get(e).PartName ),
Value = "Widget"
}
}
}
}
},
// catch any unknown fault types
new Catch<FaultException<ExceptionDetail>>
{
Action = new ActivityAction<FaultException<ExceptionDetail>>
{
Argument = unexpectedFault,
Handler = new Sequence
{
Activities =
{
// print out the details of the fault
new WriteLine
{
Text = new InArgument<string>((e) => string.Format("\tReceived Fault: {0}",
unexpectedFault.Get(e).Message
))
},
// update the order to buy 10 less of the item
new Assign<int>
{
To = new OutArgument<int>( (e) => po.Get(e).Quantity ),
Value = new InArgument<int>( (e) => po.Get(e).Quantity - 10 )
}
}
}
}
},
}
}
}
}
},
new WriteLine { Text = "Order successfully processed." }
}
}
};
}
static Sequence PurchaseOrderRequest(Endpoint endpoint)
{
Variable<PurchaseOrder> po = new Variable<PurchaseOrder>
{
Name = "po"
};
Variable<bool> result = new Variable<bool>
{
Name = "result"
};
Send approveExpense = new Send
{
ServiceContractName = XName.Get("FinanceService", "http://tempuri.org/"),
Endpoint = endpoint,
OperationName = "ApprovePurchaseOrder",
Content = SendContent.Create(new InArgument<PurchaseOrder>(po)),
SerializerOption = SerializerOption.XmlSerializer
};
Sequence workflow = new Sequence
{
Variables = { po, result },
Activities =
{
new Assign<PurchaseOrder>
{
Value = new InArgument<PurchaseOrder>( (e) => new PurchaseOrder { RequestedAmount = 500, Description = "New PC" }),
To = new OutArgument<PurchaseOrder>(po)
},
new WriteLine
{
Text = new InArgument<string>("Hello")
},
approveExpense,
new ReceiveReply
{
Request = approveExpense,
Content = ReceiveContent.Create(new OutArgument<bool>(result))
},
new If
{
Condition = new InArgument<bool> (result),
Then =
new WriteLine
{
Text = new InArgument<string>("Purchase order Approved")
},
Else =
new WriteLine
{
Text = new InArgument<string>("Purchase order Cannot be Approved")
},
},
}
};
return workflow;
}
// Define workflow
static Activity ClientWorkflow()
{
string correlationKey = Guid.NewGuid().ToString();
Send requestOne = new Send
{
Endpoint = Constants.ServerEndpoint,
ServiceContractName = Constants.ServiceContractName,
OperationName = "ScenarioOne",
Content = new SendMessageContent { Message = new InArgument<string>(correlationKey) },
};
Send requestTwo = new Send
{
Endpoint = Constants.ServerEndpoint,
ServiceContractName = Constants.ServiceContractName,
OperationName = "ScenarioTwo",
Content = new SendMessageContent { Message = new InArgument<string>(correlationKey) },
};
return new CorrelationScope
{
Body = new Sequence
{
Activities =
{
new WriteLine { Text = "Begin Client Workflow" },
new TransactionScope
{
// Initiate Transaction for Scenario One
Body = new Sequence
{
Activities =
{
new WriteLine { Text = "Scenario One Started" },
// Transaction has not flowed yet, so it remains local
new PrintTxInfo(),
requestOne,
new ReceiveReply
{
Request = requestOne,
},
// Transaction has flowed to service and has promoted to be a distributed transaction
new PrintTxInfo(),
new WriteLine { Text = "Scenario One Complete\n" },
}
}
},
new TryCatch
{
//Set up trycatch as we anticipate Scenario Two to fail
Try = new TransactionScope
{
// Initiate Transaction for Scenario Two
// When set to false a TransactionAbortedException will propogate instead of aborting the workflow.
AbortInstanceOnTransactionFailure = false,
Body = new Sequence
{
Activities =
{
new WriteLine { Text = "Scenario Two Started" },
// Transaction has not flowed yet, so it remains local
new PrintTxInfo(),
requestTwo,
new ReceiveReply
{
Request = requestTwo,
},
// Transaction has flowed to service and has promoted to be a distributed transaction
new PrintTxInfo(),
}
}
},
Catches =
{
new Catch<TransactionAbortedException>
{
Action = new ActivityAction<TransactionAbortedException>
{
Handler = new WriteLine { Text = "The transaction was aborted on the server and a TransactionAbortedException was sent." },
},
},
},
Finally = new WriteLine { Text = "Scenario Two Complete\n" },
},
new WriteLine { Text = "End Client Workflow" },
}
}
};
}
public static OperationDescription CreateTwoWayOperationDescription(Send send, ReceiveReply receiveReply)
{
Fx.Assert(send != null && receiveReply != null, "Arguments cannot be null!");
return CreateOperationDescriptionCore(send, receiveReply);
}
public static OperationDescription CreateTwoWayOperationDescription(Send send, ReceiveReply receiveReply)
{
return CreateOperationDescriptionCore(send, receiveReply);
}
public static OperationDescription CreateOneWayOperationDescription(Send send)
{
return CreateOperationDescriptionCore(send, null);
}
public SendRequest()
{
// Define the variables used by this workflow
Variable<ReservationRequest> request =
new Variable<ReservationRequest> { Name = "request" };
Variable<string> requestAddress =
new Variable<string> { Name = "RequestAddress" };
// Define the Send activity
Send submitRequest = new Send
{
ServiceContractName = "ILibraryReservation",
EndpointAddress = new InArgument<Uri>(env => new Uri("http://localhost:" + requestAddress.Get(env) + "/LibraryReservation")),
Endpoint = new Endpoint
{
Binding = new BasicHttpBinding()
},
OperationName = "RequestBook",
Content = SendContent.Create (new InArgument<ReservationRequest>(request))
};
// Define the SendRequest workflow
this.Implementation = () => new Sequence
{
DisplayName = "SendRequest",
Variables = { request, requestAddress },
Activities =
{
new CreateRequest
{
Title = new InArgument<string>(env => Title.Get(env)),
Author = new InArgument<string>(env => Author.Get(env)),
ISBN = new InArgument<string>(env => ISBN.Get(env)),
Request = new OutArgument<ReservationRequest>
(env => request.Get(env)),
RequestAddress = new OutArgument<string>
(env => requestAddress.Get(env))
},
new CorrelationScope
{
Body = new Sequence
{
Activities =
{
submitRequest,
new WriteLine
{
Text = new InArgument<string>
(env => "Request sent; waiting for response"),
},
new ReceiveReply
{
Request = submitRequest,
Content = ReceiveContent.Create
(new OutArgument<ReservationResponse>
(env => Response.Get(env)))
}
}
}
},
new WriteLine
{
Text = new InArgument<string>
(env => "Response received from " +
Response.Get(env).Provider.BranchName),
},
}
};
}
public static OperationDescription CreateTwoWayOperationDescription(Send send, ReceiveReply receiveReply)
{
return(CreateOperationDescriptionCore(send, receiveReply));
}
public static OperationDescription CreateOneWayOperationDescription(Send send)
{
return(CreateOperationDescriptionCore(send, null));
}
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;
}
public EnterLead()
{
// Define the variables used by this workflow
Variable<Lead> lead = new Variable<Lead> { Name = "lead" };
Variable<string> assignedTo = new Variable<string> { Name = "assignedTo" };
Send send = new Send
{
OperationName = "Assign",
ServiceContractName = "CreateAssignment",
Content = new SendParametersContent
{
Parameters =
{
{
"leadID",
new InArgument<int> (env => lead.Get(env).LeadID)
},
{
"assignedTo",
new InArgument<string>(env => assignedTo.Get(env))
}
}
},
EndpointAddress = new InArgument<Uri>
(env => new Uri("http://localhost/CreateAssignment")),
Endpoint = new Endpoint
{
Binding = new BasicHttpBinding()
}
};
// Define the SendRequest workflow
this.Implementation = () => new Sequence
{
DisplayName = "EnterLead",
Variables = { lead, assignedTo },
Activities =
{
new CreateLead
{
ContactName = new InArgument<string>
(env => ContactName.Get(env)),
ContactPhone = new InArgument<string>
(env => ContactPhone.Get(env)),
Interests = new InArgument<string>
(env => Interests.Get(env)),
Notes = new InArgument<string>(env => Notes.Get(env)),
//ConnectionString = new InArgument<string>(env => ConnectionString.Get(env)),
Lead = new OutArgument<Lead>(env => lead.Get(env)),
},
new WriteLine
{
Text = new InArgument<string>
(env => "Lead received [" + Rating.Get(env).ToString()
+ "]; waiting for assignment"),
TextWriter = new InArgument<TextWriter>
(env => Writer.Get(env))
},
new InvokeMethod
{
TargetType = typeof(ApplicationInterface),
MethodName = "NewLead",
Parameters =
{
new InArgument<Lead>(env => lead.Get(env))
}
},
new AddComment
{
Comment = new InArgument<string>(env => "Lead has been created")
},
new WaitForInput<string>
{
BookmarkName = "GetAssignment",
Input = new OutArgument<string>(env => assignedTo.Get(env))
},
//funziona capitolo 15
//new TransactionScope
//{
// Body = new Sequence
// {
// Activities =
// {
// new AssignLead
// {
// AssignedTo = new InArgument<string>(env => assignedTo.Get(env)),
// Lead = new InOutArgument<Lead>(env => lead.Get(env)),
// },
// new Delay
// {
// Duration = TimeSpan.FromSeconds(20)
// },
// new CreateAssignment
// {
// AssignedTo = new InArgument<string>(env => assignedTo.Get(env)),
// LeadID = new InArgument<int>(env => lead.Get(env).LeadID),
// }
// }
// },
// },
new AssignLead
{
AssignedTo = new InArgument<string>
(env => assignedTo.Get(env)),
Lead = new InOutArgument<Lead>(env => lead.Get(env)),
},
new CorrelationScope
{
Body = new Sequence
{
Activities =
{
send,
new ReceiveReply
{
Request = send
}
}
}
},
new InvokeMethod
{
TargetType = typeof(ApplicationInterface),
MethodName = "UpdateLead",
Parameters =
{
new InArgument<Lead>(env => lead.Get(env))
}
},
new AddComment
{
Comment = new InArgument<string>(env => "Lead is being assigned")
},
new WriteLine
{
Text = new InArgument<string>
(env => "Lead assigned [" + Rating.Get(env).ToString()
+ "] to " + lead.Get(env).AssignedTo),
TextWriter = new InArgument<TextWriter>
(env => Writer.Get(env))
}
}
};
}