private void Initialize(ElementInit elementInit)
{
if (elementInit == null) throw new ArgumentNullException("elementInit");
AddMethod = new MethodInfoNode(Context, elementInit.AddMethod);
Arguments = new ExpressionNodeList(Context, elementInit.Arguments);
}
public static ElementInit Serialize(E.ElementInit elementInit)
{
return(new ElementInit()
{
AddMethod = MethodRef.Serialize(elementInit.AddMethod),
Arguments = elementInit.Arguments.Select(Node.Serialize).ToArray(),
});
}
protected override ElementInit VisitElementInit(ElementInit node)
{
var args = Visit(node.Arguments);
foreach(var arg in args)
AddParameter(arg);
return null;
}
void ElementInit(ElementInit elementInit)
{
indent++;
Write("Arguments:");
foreach (var argument in elementInit.Arguments) {
Expression(argument);
}
indent--;
}
public EditableElementInit(ElementInit elmInit)
: this()
{
AddMethod = elmInit.AddMethod;
foreach (Expression ex in elmInit.Arguments)
{
Arguments.Add(EditableExpression.Create(ex));
}
}
private ElementInit[] GetInitializers(MethodInfo invoke, out ParameterExpression[] parameters)
{
ParameterInfo[] parameterInfos = invoke.GetParameters();
var initializers = new ElementInit[parameterInfos.Length];
parameters = new ParameterExpression[parameterInfos.Length];
for (var i = 0; i < parameterInfos.Length; i++)
{
Expression dictionaryValue;
Expression dictionaryKey;
ParameterExpression parameter;
BuildInitializer(out dictionaryValue, out dictionaryKey, out parameter, parameterInfos[i]);
parameters[i] = parameter;
initializers[i] = Expression.ElementInit(Tokens.DictionaryAdd, new[] { dictionaryKey, dictionaryValue });
}
return initializers;
}
protected virtual void PVisitElementInitializer(ElementInit initializer)
{
}
private ElementInit Convert(LinqExp.ElementInit linqElementInit)
{
return(Expression.ElementInit(
linqElementInit.AddMethod,
Convert(linqElementInit.Arguments)));
}
protected virtual void VisitElementInitializer(ElementInit initializer)
{
VisitExpressionList(initializer.Arguments);
}
/// <summary>
/// Visits the children of the <see cref="ElementInit"/>.
/// </summary>
/// <param name="node">The expression to visit.</param>
/// <returns>The modified expression, if it or any subexpression was modified;
/// otherwise, returns the original expression.</returns>
protected virtual ElementInit VisitElementInit(ElementInit node)
{
return(node.Update(Visit(node.Arguments)));
}
//protected internal virtual Expression VisitDebugInfo(DebugInfoExpression node)
//{
// return (Expression)null;
//}
//protected internal virtual Expression VisitDefault(DefaultExpression node)
//{
// return (Expression)null;
//}
//protected internal virtual Expression VisitDynamic(DynamicExpression node)
//{
// return (Expression)null;
//}
protected virtual ElementInit VisitElementInit(ElementInit node)
{
return((ElementInit)null);
}
protected virtual ElementInit VisitElementInitializer(ElementInit initializer)
{
var arguments = VisitExpressionList(initializer.Arguments);
return(arguments != initializer.Arguments ? Expression.ElementInit(initializer.AddMethod, arguments) : initializer);
}
/// <summary>
/// Gets the debug view for the specified element initializer.
/// </summary>
/// <param name="initializer">The element initializer to get a debug view for.</param>
/// <returns>Debug view for the specified element initializer.</returns>
public XNode GetDebugView(ElementInit initializer)
{
return(Visit(initializer));
}
protected override ElementInit VisitElementInitializer(ElementInit initializer) => InvokeEvent(ElementInitializerVisited, initializer, base.VisitElementInitializer);
protected override ElementInitExpressionTree MakeElementInit(ElementInit node, ReadOnlyCollection <ExpressionTree> arguments) => new(node, arguments);
protected virtual void VisitElementInitializer(ElementInit initializer)
{
this.VisitExpressionList(initializer.Arguments);
throw new NotImplementedException ();
}
private new RemoteLinq.ElementInit VisitElementInitializer(SystemLinq.ElementInit initializer)
{
var arguments = VisitExpressionList(initializer.Arguments).Select(Unwrap);
return(new RemoteLinq.ElementInit(_typeInfoProvider.GetMethodInfo(initializer.AddMethod), arguments));
}
public EditableElementInit(ElementInit elementInit)
{
AddMethod = elementInit.AddMethod;
arguments = new EditableExpressionCollection<Expression>(elementInit.Arguments);
}
/// <summary>
/// Creates a <see cref="ListInitExpression"/> that uses a specified method to add elements to a collection.
/// </summary>
/// <param name="newExpression">A <see cref="NewExpression"/> to set the <see cref="P:ListInitExpression.NewExpression"/> property equal to.</param>
/// <param name="addMethod">A <see cref="MethodInfo"/> that represents an instance method named "Add" (case insensitive), that adds an element to a collection. </param>
/// <param name="initializers">An <see cref="IEnumerable{T}"/> that contains <see cref="Expression"/> objects to use to populate the Initializers collection.</param>
/// <returns>A <see cref="ListInitExpression"/> that has the <see cref="P:ListInitExpression.NodeType"/> property equal to ListInit and the <see cref="P:ListInitExpression.NewExpression"/> property set to the specified value.</returns>
public static ListInitExpression ListInit(NewExpression newExpression, MethodInfo addMethod, IEnumerable<Expression> initializers)
{
if (addMethod == null)
{
return ListInit(newExpression, initializers);
}
ContractUtils.RequiresNotNull(newExpression, "newExpression");
ContractUtils.RequiresNotNull(initializers, "initializers");
var initializerlist = initializers.ToReadOnly();
if (initializerlist.Count == 0)
{
throw Error.ListInitializerWithZeroMembers();
}
ElementInit[] initList = new ElementInit[initializerlist.Count];
for (int i = 0; i < initializerlist.Count; i++)
{
initList[i] = ElementInit(addMethod, initializerlist[i]);
}
return ListInit(newExpression, new TrueReadOnlyCollection<ElementInit>(initList));
}
protected override void VisitElementInitializer (ElementInit initializer)
{
object target = null;
if (!initializer.AddMethod.IsStatic)
target = Pop ();
var arguments = VisitListExpressions (initializer.Arguments);
InvokeMethod (initializer.AddMethod, target, arguments);
if (!initializer.AddMethod.IsStatic)
Push (target);
}
/// <summary>
/// Constructor with an <see cref="ElementInit"/> and an <see cref="ExpressionConverter"/>.
/// </summary>
/// <param name="elementInit">The original, not serializable <see cref="ElementInit"/>.</param>
/// <param name="expConverter">The <see cref="ExpressionConverter"/> to convert contained <see cref="Expression">Expressions</see>.</param>
public SerializableElementInit(ElementInit elementInit, ExpressionConverter expConverter)
{
Arguments = elementInit.Arguments.MakeSerializableCollection<SerializableExpression>(expConverter);
AddMethod = elementInit.AddMethod;
}
protected override ElementInit VisitElementInitializer(ElementInit initializer)
{
if (initializer.Arguments.Count > 1)
{
this.Write("{");
for (int i = 0, n = initializer.Arguments.Count; i < n; i++)
{
this.Visit(initializer.Arguments[i]);
if (i < n - 1)
{
this.Write(", ");
}
}
this.Write("}");
}
else
{
this.Visit(initializer.Arguments[0]);
}
return initializer;
}
protected virtual ElementInit VisitElementInitializer(ElementInit initializer)
{
var arguments = VisitExpressionList(initializer.Arguments);
return arguments != initializer.Arguments ? Expression.ElementInit(initializer.AddMethod, arguments) : initializer;
}
/// <summary>
/// Creates a <see cref="ListInitExpression"/> that uses a specified method to add elements to a collection.
/// </summary>
/// <param name="newExpression">A <see cref="NewExpression"/> to set the <see cref="ListInitExpression.NewExpression"/> property equal to.</param>
/// <param name="addMethod">A <see cref="MethodInfo"/> that represents an instance method named "Add" (case insensitive), that adds an element to a collection.</param>
/// <param name="initializers">An <see cref="IEnumerable{T}"/> that contains <see cref="Expression"/> objects to use to populate the Initializers collection.</param>
/// <returns>A <see cref="ListInitExpression"/> that has the <see cref="NodeType"/> property equal to <see cref="ExpressionType.ListInit"/> and the <see cref="ListInitExpression.NewExpression"/> property set to the specified value.</returns>
public static ListInitExpression ListInit(NewExpression newExpression, MethodInfo addMethod, IEnumerable<Expression> initializers)
{
if (addMethod == null)
{
return ListInit(newExpression, initializers);
}
ContractUtils.RequiresNotNull(newExpression, nameof(newExpression));
ContractUtils.RequiresNotNull(initializers, nameof(initializers));
ReadOnlyCollection<Expression> initializerlist = initializers.ToReadOnly();
ElementInit[] initList = new ElementInit[initializerlist.Count];
for (int i = 0; i < initializerlist.Count; i++)
{
initList[i] = ElementInit(addMethod, initializerlist[i]);
}
return ListInit(newExpression, new TrueReadOnlyCollection<ElementInit>(initList));
}
protected virtual bool CompareElementInit(ElementInit a, ElementInit b)
{
return a.AddMethod == b.AddMethod
&& this.CompareExpressionList(a.Arguments, b.Arguments);
}
protected virtual ElementInit VisitElementInitializer(ElementInit initializer, Stack<string> stack, Stack<IElasticPropertyAttribute> properties)
{
ReadOnlyCollection<Expression> arguments = this.VisitExpressionList(initializer.Arguments, stack, properties);
if (arguments != initializer.Arguments)
{
return Expression.ElementInit(initializer.AddMethod, arguments);
}
return initializer;
}
/// <summary>
/// Visits an ElementInit.
/// </summary>
/// <param name="node">The ElementInit.</param>
/// <returns>The ElementInit (possibly modified).</returns>
protected virtual ElementInit VisitElementInit(ElementInit node)
{
ReadOnlyCollection<Expression> arguments = VisitExpressionList(node.Arguments);
if (arguments != node.Arguments)
{
return Expression.ElementInit(node.AddMethod, arguments);
}
return node;
}
public ElementInitExpressionTree Visit(ElementInit node) => base.VisitElementInit(node);
public virtual bool IsEvaluatableElementInit (ElementInit node)
{
ArgumentUtility.CheckNotNull ("node", node);
return true;
}
internal virtual ElementInit VisitElementInitializer(ElementInit initializer)
{
var arguments = VisitExpressionList(initializer.Arguments);
if (arguments != initializer.Arguments)
{
return Expression.ElementInit(initializer.AddMethod, arguments);
}
return initializer;
}
/// <summary>
/// Visits an ElementInit node.
/// </summary>
/// <param name="node">The ElementInit node.</param>
/// <returns>The ElementInit node.</returns>
protected override ElementInit VisitElementInit(ElementInit node)
{
_sb.Append("<ElementInit>");
return node;
}
protected override ElementInit VisitElementInitializer(ElementInit expression)
{
ElementInit current;
if (!TryGetCurrent(expression, out current))
{
return expression;
}
if (!(this.result &= current.AddMethod == expression.AddMethod))
{
return expression;
}
this.currentObject = current.Arguments;
this.VisitExpressionList(expression.Arguments);
if (!this.result)
{
return expression;
}
this.currentObject = current;
return expression;
}
/// <summary>
/// ElementInit visit method
/// </summary>
/// <param name="initializer">The ElementInit expression to visit</param>
/// <returns>The visited ElementInit expression </returns>
internal override ElementInit VisitElementInitializer(ElementInit initializer)
{
this.VisitExpressionList(initializer.Arguments);
return initializer;
}
/// <summary>
/// Visits the children of the <c>ElementInit</c>.
/// </summary>
/// <param name="initializer">The expression to visit.</param>
/// <returns>The modified expression, if it or any subexpression was modified;
/// otherwise, returns the original expression.</returns>
protected virtual ElementInit VisitElementInitializer(ElementInit initializer)
{
if (initializer == null)
throw new ArgumentNullException("initializer");
var arguments = VisitExpressionList(initializer.Arguments);
return arguments == initializer.Arguments ? initializer : Expression.ElementInit(initializer.AddMethod, arguments);
}
protected virtual ElementInit VisitElementInitializer (ElementInit initializer)
{
Expression[] args;
if (VisitExpressionList (initializer.Arguments, out args))
return Expression.ElementInit (initializer.AddMethod, args);
return initializer;
}
public ElementInitNode(INodeFactory factory, ElementInit elementInit)
: base(factory)
{
this.Initialize(elementInit);
}
/// <summary>
/// Creates a <see cref="ListInitExpression"/> that uses a specified method to add elements to a collection.
/// </summary>
/// <param name="newExpression">A <see cref="NewExpression"/> to set the <see cref="P:ListInitExpression.NewExpression"/> property equal to.</param>
/// <param name="addMethod">A <see cref="MethodInfo"/> that represents an instance method named "Add" (case insensitive), that adds an element to a collection. </param>
/// <param name="initializers">An <see cref="IEnumerable{T}"/> that contains <see cref="Expression"/> objects to use to populate the Initializers collection.</param>
/// <returns>A <see cref="ListInitExpression"/> that has the <see cref="P:ListInitExpression.NodeType"/> property equal to ListInit and the <see cref="P:ListInitExpression.NewExpression"/> property set to the specified value.</returns>
public static ListInitExpression ListInit(NewExpression newExpression, MethodInfo addMethod, IEnumerable <Expression> initializers)
{
if (addMethod == null)
{
return(ListInit(newExpression, initializers));
}
ContractUtils.RequiresNotNull(newExpression, "newExpression");
ContractUtils.RequiresNotNull(initializers, "initializers");
List <ElementInit> initList = null;
ElementInit[] initArray = null;
initializers = initializers.NullOrEmptyChecked
(
() =>
{
throw Error.ListInitializerWithZeroMembers();
},
() => initList = new List <ElementInit>(),
count => initArray = new ElementInit[count]
);
var enumerator = initializers.GetEnumerator();
try
{
enumerator.MoveNext();
var initializer = enumerator.Current;
if (addMethod == null)
{
return(ListInit(newExpression, initializers));
}
if (initList != null)
{
initList.Add(ElementInit(addMethod, initializer));
while (enumerator.MoveNext())
{
initializer = enumerator.Current;
initList.Add(ElementInit(addMethod, initializer));
}
initArray = initList.ToArray();
}
else
{
var index = 0;
initArray[index] = ElementInit(addMethod, initializer);
index++;
while (enumerator.MoveNext())
{
initializer = enumerator.Current;
initArray[index] = ElementInit(addMethod, initializer);
index++;
}
}
}
finally
{
enumerator.Dispose();
}
ValidateListInitArgs(newExpression.Type, initArray);
return(new ListInitExpression(newExpression, initArray));
}
/// <summary>
/// Visits an ElementInit.
/// </summary>
/// <param name="initializer">The ElementInit.</param>
/// <returns>The ElementInit (possibly modified).</returns>
protected virtual ElementInit VisitElementInitializer(ElementInit initializer)
{
ReadOnlyCollection<Expression> arguments = this.VisitExpressionList(initializer.Arguments);
if (arguments != initializer.Arguments)
{
return Expression.ElementInit(initializer.AddMethod, arguments);
}
return initializer;
}
/// <summary>
/// Visit a element initialized expression.
/// </summary>
/// <param name="elementInitExp"></param>
/// <returns></returns>
protected virtual ElementInit VisitElementInitializer(ElementInit elementInitExp)
{
ReadOnlyCollection<Expression> arguments = VisitList(elementInitExp.Arguments);
if (arguments != elementInitExp.Arguments)
{
return Expression.ElementInit(elementInitExp.AddMethod, arguments);
}
return elementInitExp;
}
/// <summary>
/// ElementInit visit method
/// </summary>
/// <param name="initializer">The ElementInit expression to visit</param>
/// <returns>The visited ElementInit expression </returns>
internal override ElementInit VisitElementInitializer(ElementInit initializer)
{
throw new NotImplementedException();
}
/// <summary>
/// Visits an ElementInit node.
/// </summary>
/// <param name="node">The ElementInit node.</param>
/// <returns>The ElementInit node.</returns>
protected override ElementInit VisitElementInit(ElementInit node)
{
throw new NotImplementedException();
}
private static ElementInit VisitElementInit(ElementInit node)
{
throw new NotImplementedException();
}