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
118
119
120
121
|
//----------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//----------------------------------------------------------------
namespace System.Activities.Expressions
{
using System.Activities;
using System.Collections.ObjectModel;
using System.Reflection;
using System.Runtime.Collections;
using System.Windows.Markup;
[ContentProperty("Bounds")]
public sealed class NewArray<TResult> : CodeActivity<TResult>
{
Collection<Argument> bounds;
ConstructorInfo constructorInfo;
public Collection<Argument> Bounds
{
get
{
if (this.bounds == null)
{
this.bounds = new ValidatingCollection<Argument>
{
// disallow null values
OnAddValidationCallback = item =>
{
if (item == null)
{
throw FxTrace.Exception.ArgumentNull("item");
}
}
};
}
return this.bounds;
}
}
protected override void CacheMetadata(CodeActivityMetadata metadata)
{
if (!typeof(TResult).IsArray)
{
metadata.AddValidationError(SR.NewArrayRequiresArrayTypeAsResultType);
// We shortcut any further processing in this case.
return;
}
bool foundError = false;
// Loop through each argument, validate it, and if validation
// passed expose it to the metadata
Type[] types = new Type[this.Bounds.Count];
for (int i = 0; i < this.Bounds.Count; i++)
{
Argument argument = this.Bounds[i];
if (argument == null || argument.IsEmpty)
{
metadata.AddValidationError(SR.ArgumentRequired("Bounds", typeof(NewArray<TResult>)));
foundError = true;
}
else
{
if (!isIntegralType(argument.ArgumentType))
{
metadata.AddValidationError(SR.NewArrayBoundsRequiresIntegralArguments);
foundError = true;
}
else
{
RuntimeArgument runtimeArgument = new RuntimeArgument("Argument" + i, this.Bounds[i].ArgumentType, this.bounds[i].Direction, true);
metadata.Bind(this.Bounds[i], runtimeArgument);
metadata.AddArgument(runtimeArgument);
types[i] = argument.ArgumentType;
}
}
}
// If we didn't find any errors in the arguments then
// we can look for an appropriate constructor.
if (!foundError)
{
this.constructorInfo = typeof(TResult).GetConstructor(types);
if (this.constructorInfo == null)
{
metadata.AddValidationError(SR.ConstructorInfoNotFound(typeof(TResult).Name));
}
}
}
protected override TResult Execute(CodeActivityContext context)
{
object[] objects = new object[this.Bounds.Count];
int i = 0;
foreach (Argument argument in this.Bounds)
{
objects[i] = argument.Get(context);
i++;
}
TResult result = (TResult)this.constructorInfo.Invoke(objects);
return result;
}
bool isIntegralType(Type type)
{
if (type == typeof(sbyte) || type == typeof(byte) || type == typeof(char) || type == typeof(short) ||
type == typeof(ushort) || type == typeof(int) || type == typeof(uint) || type == typeof(long) || type == typeof(ulong))
{
return true;
}
else
{
return false;
}
}
}
}
|
