1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
|
//-----------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
namespace System.Activities.Runtime
{
using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.Serialization;
using System.Runtime;
using System.Security;
[DataContract]
class FuncCompletionCallbackWrapper<T> : CompletionCallbackWrapper
{
static readonly Type callbackType = typeof(CompletionCallback<T>);
static readonly Type[] callbackParameterTypes = new Type[] { typeof(NativeActivityContext), typeof(ActivityInstance), typeof(T) };
T resultValue;
public FuncCompletionCallbackWrapper(CompletionCallback<T> callback, ActivityInstance owningInstance)
: base(callback, owningInstance)
{
this.NeedsToGatherOutputs = true;
}
[DataMember(EmitDefaultValue = false, Name = "resultValue")]
internal T SerializedResultValue
{
get { return this.resultValue; }
set { this.resultValue = value; }
}
int GetResultId(ActivityWithResult activity)
{
if (activity.Result != null)
{
return activity.Result.Id;
}
else
{
for (int i = 0; i < activity.RuntimeArguments.Count; i++)
{
RuntimeArgument argument = activity.RuntimeArguments[i];
if (argument.IsResult)
{
return argument.Id;
}
}
}
return -1;
}
protected override void GatherOutputs(ActivityInstance completedInstance)
{
int resultId = -1;
if (completedInstance.Activity.HandlerOf != null)
{
DelegateOutArgument resultArgument = completedInstance.Activity.HandlerOf.GetResultArgument();
if (resultArgument != null)
{
resultId = resultArgument.Id;
}
else
{
ActivityWithResult activity = completedInstance.Activity as ActivityWithResult;
// for auto-generated results, we should bind the value from the Handler if available
if (activity != null && TypeHelper.AreTypesCompatible(activity.ResultType, typeof(T)))
{
resultId = GetResultId(activity);
}
}
}
else
{
Fx.Assert(completedInstance.Activity is ActivityWithResult, "should only be using FuncCompletionCallbackWrapper with ActivityFunc and ActivityWithResult");
resultId = GetResultId((ActivityWithResult)completedInstance.Activity);
}
if (resultId >= 0)
{
Location location = completedInstance.Environment.GetSpecificLocation(resultId);
Location<T> typedLocation = location as Location<T>;
if (typedLocation != null)
{
this.resultValue = typedLocation.Value;
}
else if (location != null)
{
this.resultValue = TypeHelper.Convert<T>(location.Value);
}
}
}
[Fx.Tag.SecurityNote(Critical = "Because we are calling EnsureCallback",
Safe = "Safe because the method needs to be part of an Activity and we are casting to the callback type and it has a very specific signature. The author of the callback is buying into being invoked from PT.")]
[SecuritySafeCritical]
protected internal override void Invoke(NativeActivityContext context, ActivityInstance completedInstance)
{
// Call the EnsureCallback overload that also looks for SomeMethod<T> where T is the result type
// and the signature matches.
EnsureCallback(callbackType, callbackParameterTypes, callbackParameterTypes[2]);
CompletionCallback<T> completionCallback = (CompletionCallback<T>)this.Callback;
completionCallback(context, completedInstance, this.resultValue);
}
protected override void OnSerializingGenericCallback()
{
ValidateCallbackResolution(callbackType, callbackParameterTypes, callbackParameterTypes[2]);
}
}
}
|
