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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
/* ****************************************************************************
*
* Copyright (c) Microsoft Corporation.
*
* This source code is subject to terms and conditions of the Apache License, Version 2.0. A
* copy of the license can be found in the License.html file at the root of this distribution. If
* you cannot locate the Apache License, Version 2.0, please send an email to
* dlr@microsoft.com. By using this source code in any fashion, you are agreeing to be bound
* by the terms of the Apache License, Version 2.0.
*
* You must not remove this notice, or any other, from this software.
*
*
* ***************************************************************************/
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Reflection;
using System.Text;
using System.Dynamic.Utils;
#if SILVERLIGHT
using System.Core;
#endif
#if CLR2
namespace Microsoft.Scripting.Ast {
#else
namespace System.Linq.Expressions {
#endif
/// <summary>
/// Represents the initialization of a list.
/// </summary>
public sealed class ElementInit : IArgumentProvider {
private MethodInfo _addMethod;
private ReadOnlyCollection<Expression> _arguments;
internal ElementInit(MethodInfo addMethod, ReadOnlyCollection<Expression> arguments) {
_addMethod = addMethod;
_arguments = arguments;
}
/// <summary>
/// Gets the <see cref="MethodInfo"/> used to add elements to the object.
/// </summary>
public MethodInfo AddMethod {
get { return _addMethod; }
}
/// <summary>
/// Gets the list of elements to be added to the object.
/// </summary>
public ReadOnlyCollection<Expression> Arguments {
get { return _arguments; }
}
Expression IArgumentProvider.GetArgument(int index) {
return _arguments[index];
}
int IArgumentProvider.ArgumentCount {
get {
return _arguments.Count;
}
}
/// <summary>
/// Creates a <see cref="String"/> representation of the node.
/// </summary>
/// <returns>A <see cref="String"/> representation of the node.</returns>
public override string ToString() {
return ExpressionStringBuilder.ElementInitBindingToString(this);
}
/// <summary>
/// Creates a new expression that is like this one, but using the
/// supplied children. If all of the children are the same, it will
/// return this expression.
/// </summary>
/// <param name="arguments">The <see cref="Arguments" /> property of the result.</param>
/// <returns>This expression if no children changed, or an expression with the updated children.</returns>
public ElementInit Update(IEnumerable<Expression> arguments) {
if (arguments == Arguments) {
return this;
}
return Expression.ElementInit(AddMethod, arguments);
}
}
public partial class Expression {
/// <summary>
/// Creates an <see cref="T:ElementInit">ElementInit</see> expression that represents the initialization of a list.
/// </summary>
/// <param name="addMethod">The <see cref="MethodInfo"/> for the list's Add method.</param>
/// <param name="arguments">An array containing the Expressions to be used to initialize the list.</param>
/// <returns>The created <see cref="T:ElementInit">ElementInit</see> expression.</returns>
public static ElementInit ElementInit(MethodInfo addMethod, params Expression[] arguments) {
return ElementInit(addMethod, arguments as IEnumerable<Expression>);
}
/// <summary>
/// Creates an <see cref="T:ElementInit">ElementInit</see> expression that represents the initialization of a list.
/// </summary>
/// <param name="addMethod">The <see cref="MethodInfo"/> for the list's Add method.</param>
/// <param name="arguments">An <see cref="IEnumerable{T}"/> containing <see cref="Expression"/> elements to initialize the list.</param>
/// <returns>The created <see cref="T:ElementInit">ElementInit</see> expression.</returns>
public static ElementInit ElementInit(MethodInfo addMethod, IEnumerable<Expression> arguments) {
ContractUtils.RequiresNotNull(addMethod, "addMethod");
ContractUtils.RequiresNotNull(arguments, "arguments");
var argumentsRO = arguments.ToReadOnly();
RequiresCanRead(argumentsRO, "arguments");
ValidateElementInitAddMethodInfo(addMethod);
ValidateArgumentTypes(addMethod, ExpressionType.Call, ref argumentsRO);
return new ElementInit(addMethod, argumentsRO);
}
private static void ValidateElementInitAddMethodInfo(MethodInfo addMethod) {
ValidateMethodInfo(addMethod);
ParameterInfo[] pis = addMethod.GetParametersCached();
if (pis.Length == 0) {
throw Error.ElementInitializerMethodWithZeroArgs();
}
if (!addMethod.Name.Equals("Add", StringComparison.OrdinalIgnoreCase)) {
throw Error.ElementInitializerMethodNotAdd();
}
if (addMethod.IsStatic) {
throw Error.ElementInitializerMethodStatic();
}
foreach (ParameterInfo pi in pis) {
if (pi.ParameterType.IsByRef) {
throw Error.ElementInitializerMethodNoRefOutParam(pi.Name, addMethod.Name);
}
}
}
}
}
|
