（转）lambda表达式的解析（七） 对象的创建

C#里用来创建对象的方式有以下几种

调用构造函数 new obj(...)

初始化成员列表 new obj { f1 = xxx, f2 = xxx, ... }

创建数组 new arraytype[] { e1, e2, e3, ...}

如果是匿名对象话，创建方式只有后2种。

非匿名对象的创建：

view plaincopy to clipboardprint?
  1. private Expression ProcessNewExpression(ParseTreeNode expNode)
  2. {
  3. var typeName = expNode.GetChild("qual_name_with_targs").FindTokenAndGetText();
  4. var args = expNode.GetChild("creation_args").GetDescendant("argument_list");
  5. var arglist = new List<Expression>();
  6. if (args != null)
  7. {
  8. foreach (var arg in args.ChildNodes)
  9. {
  10. arglist.Add(ProcessExpression(arg.FirstChild));
  11. }
  12. }
  13. var type = GetType(typeName);
  15. if (expNode.GetChild("creation_args").HasChild("array_creation_args"))
  16. {
  17. var elements = expNode.GetChild("array_initializer_opt").GetDescendant("elem_initializer_list");
  18. var elemlist = new List<Expression>();
  19. if (elements != null)
  20. {
  21. foreach (var child in elements.ChildNodes)
  22. {
  23. elemlist.Add(ProcessExpression(child.GetChild("initializer_value").FirstChild));
  24. }
  25. }
  26. return Expression.NewArrayInit(type, elemlist);
  27. }
  29. var newexp = Expression.New(type.GetConstructor(arglist.Select(e => e.Type).ToArray()), arglist);
  30. var members = expNode.GetChild("array_initializer_opt").GetDescendant("elem_initializer_list");
  31. var bindlist = new List<MemberBinding>();
  32. if (members != null)
  33. {
  34. foreach (var child in members.ChildNodes)
  35. {
  36. var memberName = child.GetChild("Identifier").GetValue();
  37. var expr = ProcessExpression(child.GetChild("initializer_value").FirstChild);
  38. bindlist.Add(Expression.Bind(type.GetMember(memberName).First(), expr));
  39. }
  40. }
  41. return Expression.MemberInit(newexp, bindlist);
  42. }


大致过程就是先获得创建对象的类型，然后分析是否有调用构造方法并获取构造参数列表，如是创建数组对象则获取元素列表并返回数组初始化表达式，最后就是如果有成员初始化列表就和new表达式一起使用。

匿名类型创建：

view plaincopy to clipboardprint?
  1. private Expression ProcessNewAnonymousExpression(ParseTreeNode expNode)
  2. {
  3. if (expNode.HasChild("anonymous_array_creation_expression"))
  4. {
  5. var elements = expNode.GetDescendant("element_declarator_list");
  6. var elemlist = new List<Expression>();
  7. var elemtype = typeof(void);
  8. if (elements != null)
  9. {
  10. foreach (var child in elements.ChildNodes)
  11. {
  12. var exp = ProcessExpression(child.FirstChild);
  13. elemtype = exp.Type;
  14. elemlist.Add(exp);
  15. }
  16. }
  17. return Expression.NewArrayInit(elemtype, elemlist);
  18. }
  20. var members = expNode.GetDescendant("member_declarator_list");
  21. var memblist = new List<Expression>();
  22. var names = new List<string>();
  23. var types = new List<Type>();
  24. List<AnonymousMetaProperty> properties = new List<AnonymousMetaProperty>();
  25. if (members != null)
  26. {
  27. foreach (var child in members.ChildNodes)
  28. {
  29. var name = child.GetChild("Identifier").GetValue();
  30. var expr = ProcessExpression(child.GetChild("primary_expression"));
  31. names.Add(name);
  32. types.Add(expr.Type);
  33. memblist.Add(expr);
  34. }
  35. }
  37. return GetAnonymousExpression(names.ToArray(), types.ToArray(), memblist.ToArray());
  38. }


创建匿名表达式最大的问题是需要对匿名类型进行引用，也就是说需要在解析的时候动态创建匿名类型，在项目里使用了InterLinq创建匿名类型部分的代码（InterLinq是一个提供远程执行LINQ方法的框架）来创建一个匿名类型：

view plaincopy to clipboardprint?
  1. private static Type GetAnonymousType(string[] propertyNames, Type[] propertyTypes)
  2. {
  3. List<AnonymousMetaProperty> properties = new List<AnonymousMetaProperty>();
  4. for (int i = 0; i < propertyNames.Length; ++i)
  5. {
  6. properties.Add(new AnonymousMetaProperty(propertyNames[i], propertyTypes[i]));
  7. }
  8. return AnonymousTypeHelper.GetAnonymousType(properties.ToArray()).GetClrType();
  9. }
  11. private Expression GetAnonymousExpression(IEnumerable<string> names, IEnumerable<Type> types, IEnumerable<Expression> membs)
  12. {
  13. var newobj = GetAnonymousType(names.ToArray(), types.ToArray());
  14. return Expression.New(newobj.GetConstructor(types.ToArray()), membs, newobj.GetProperties());
  15. }


不过匿名数组可以根据初始化参数确定数组元素类型所以无需创建匿名类型这个过程。

至此大部分的表达式都能被顺利解析转换了，用Irony对lambda表达式解析的介绍就告一段落了，对typeof、泛型调用以及BlockExpression等的支持和grammar的进一步完善留着下次再介绍了。

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/liuhaili/p/2210995.html