前几篇文章，我把前提都铺垫好了，下面就说说具体的代码。
我为这个转换类取名为 ExpressionParserCore ：
- 需要 SymbolParseResult 类的实例对象和 TypeParser 类的实例对象，分别用于字符串解析和类型解析
- 需要待分析表达式树的传入参数和传出参数
TypeParser 还需要分析用的命名空间数组、额外的 Assembly 列表。其中 Assembly 列表可以使用 Assembly.LoadFrom("D:\abc.dll") 的方式加载，这对于后续的插件扩展很有帮助。下面这段代码是类的构造函数：
/// <summary>
/// Initializes a new instance of the <see cref="ExpressionParserCore"/> class.
/// </summary>
/// <param name="spResult">The sp result.</param>
/// <param name="delegateType">Type of the delegate.</param>
/// <param name="namespaces">The namespaces.</param>
public ExpressionParserCore(SymbolParseResult spResult, Type delegateType, IEnumerable<string> namespaces = null, IEnumerable<Assembly> assemblies = null)
{
this.spResult = spResult;
this.typeParser = new TypeParser(ref this.spResult);
typeParser.SetNamespaces(namespaces);
typeParser.SetAssemblies(assemblies);
var method = delegateType.GetMethod("Invoke");
parameterTypes = method.GetParameters().Select(p => p.ParameterType).ToArray();
returnType = method.ReturnType;
}
但是这样还不够。一般 Lambda 表达式都是有参数的，而且在表达式中也有用到，所以解析的过程中对于 Lambda 参数的解析也必须包含进来：
/// <summary>
/// 处理表达式前缀.
/// </summary>
private void ProcessLambdaPrefix()
{
// 检查是否有 Lambda 前置符(如: m => )
if (spResult.Any(p => p.ID == TokenId.LambdaPrefix))
{
Token token = spResult.Next();
if (token.ID == TokenId.OpenParen)
{
var bracketContent = spResult.SkipUntil(p => p.ID == TokenId.CloseParen);
bracketContent.RemoveAt(bracketContent.Count - 1);
if (bracketContent.Any(p => p.ID == TokenId.OpenParen))
throw new ParserSyntaxErrorException();
// 如果读取到 => 符号表示有
if (!spResult.NextIs(TokenId.LambdaPrefix))
{
spResult.ReturnToIndex(-1);
return;
}
// 解析参数
ResolveParameters(bracketContent).Foreach((p, i) =>
{
if (p.ExistType)
expParams.Add(Expression.Parameter(typeParser.GetType(p.Type), p.Variable));
else
expParams.Add(Expression.Parameter(parameterTypes[i], p.Variable));
});
}
else if (token.ID == TokenId.Identifier &&
(char.IsLetter(token.Text[0]) || token.Text[0] == '_') &&
!(token.Text == "true" ||
token.Text == "false" ||
token.Text == "null" ||
token.Text == "sizeof" ||
token.Text == "new" ||
token.Text == "typeof"))
{
if (!spResult.NextIs(TokenId.LambdaPrefix))
{
spResult.ReturnToIndex(-1);
return;
}
expParams.Add(Expression.Parameter(parameterTypes[0], token.Text));
}
// 参数表达式个数和传入委托参数个数不匹配判断
if (expParams.Count != parameterTypes.Length)
throw new ApplicationException("The count of parameters is not equal.");
}
}
/// <summary>
/// 解析参数并返回配对（类型/变量）的字符单元列表.
/// </summary>
/// <param name="obj">待解析的字符单元列表.</param>
/// <returns>解析完成的字符单元列表.</returns>
private TypeVariable[] ResolveParameters(IEnumerable<Token> obj)
{
Token selector = new Token { ID = TokenId.Comma, Text = "," };
var result = new List<TypeVariable>();
if (ReferenceEquals(obj, null) || !obj.Any())
return result.ToArray();
if (obj.Last() != selector)
{
var list = obj.ToList();
list.Add(selector);
obj = list;
}
var data = obj.ToArray();
int firstIndex = 0, secondIndex = 0;
while ((secondIndex = Array.IndexOf(data, selector, firstIndex)) != -1)
{
if (secondIndex == firstIndex + 1)
result.Add(new TypeVariable(null, data[firstIndex]));
else if (secondIndex == firstIndex + 2)
result.Add(new TypeVariable(data[firstIndex], data[firstIndex + 1]));
else
throw new ParserSyntaxErrorException();
firstIndex = secondIndex + 1;
}
return result.ToArray();
}
这个方法，可以把它放在构造函数中，也可以放在 ToLambdaExpression 方法里面。忘记了，这涉及到一个类，用于记录类型和变量的键值对：
/// <summary>
/// 【类型：变量】键值对
/// </summary>
[DebuggerStepThrough]
[DebuggerDisplay("{Type.Text}, {Variable.Text}")]
public class TypeVariable
{
/// <summary>
/// 获取类型字符单元.
/// </summary>
public Token Type { get; private set; }
/// <summary>
/// 获取变量字符单元.
/// </summary>
public Token Variable { get; private set; }
/// <summary>
/// 获取一个值, 通过该值指示是否包含类型定义. <c>true</c> 表示包含类型定义.
/// </summary>
public bool ExistType { get; private set; }
/// <summary>
/// 初始化新建一个 <see cref="TypeVariable"/> 类的实例对象.
/// </summary>
/// <param name="type">类型字符单元.</param>
/// <param name="variable">变量字符单元.</param>
public TypeVariable(Token? type, Token variable)
{
Variable = variable;
if (ExistType = type.HasValue)
Type = type.Value;
}
}
在这之后，就是正式的解析入口了：
public Expression<T> ToLambdaExpression<T>()
{
ProcessLambdaPrefix();
var exp = ReadExpression();
return LambdaExpression.Lambda<T>(exp.Expression, expParams);
}
这里要说明的是 expParams 参数，这个是用作 Lambda 表达式的参数必不可少的部分。ReadExpression 方法，递归调用解析 Lambda 表达式：
/// <summary>
/// Reads the expression.
/// </summary>
/// <param name="level">The level.</param>
/// <param name="wrapStart">The wrap start.</param>
/// <returns>The read result.</returns>
private ReadResult ReadExpression(int level = 0)
{
var exp = ReadFirstExpression();
//int nextLevel = 0;
//var next = spResult.PeekNext();
//while (!exp.IsClosedWrap &&
// (nextLevel = PriorityManager.GetOperatorLevel(next)) > level)
//{
// exp = ReadNextExpression(nextLevel, exp, next.ID);
// next = spResult.PeekNext();
//}
return exp;
}
具体的 ReadFirstExpression 方法如下：
/// <summary>
/// Reads the first expression.
/// </summary>
/// <returns>The read result.</returns>
private ReadResult ReadFirstExpression()
{
ReadResult result = ReadResult.Empty;
var token = spResult.Next();
switch (token.ID)
{
case TokenId.Identifier:
result = ParseIdentifier(token);
break;
case TokenId.StringLiteral:
if (token.Text.StartsWith("\""))
result.Expression = Expression.Constant(token.Text.Substring(1, token.Text.Length - 2), typeof(string));
else if (token.Text.StartsWith("'"))
result.Expression = Expression.Constant(token.Text[1], typeof(char));
break;
case TokenId.IntegerLiteral:
result.Expression = Expression.Constant(int.Parse(token.Text), typeof(int));
break;
case TokenId.LongIntegerLiteral:
result.Expression = Expression.Constant(long.Parse(DeleteDigitTypeReference(token.Text)), typeof(long));
break;
case TokenId.RealLiteral:
result.Expression = Expression.Constant(double.Parse(DeleteDigitTypeReference(token.Text)), typeof(double));
break;
case TokenId.SingleRealLiteral:
result.Expression = Expression.Constant(float.Parse(DeleteDigitTypeReference(token.Text)), typeof(float));
break;
case TokenId.DecimalRealLiteral:
result.Expression = Expression.Constant(decimal.Parse(DeleteDigitTypeReference(token.Text)), typeof(decimal));
break;
case TokenId.Exclamation:
result.Expression = Expression.Not(ReadExpression().Expression);
break;
case TokenId.Plus:
case TokenId.Comma:
result = ReadExpression();
break;
case TokenId.Minus:
result.Expression = Expression.Negate(ReadExpression().Expression);
break;
case TokenId.OpenParen:
result = ParseConvertType();
break;
case TokenId.CloseParen:
case TokenId.CloseBracket:
case TokenId.CloseBrace:
result.IsClosedWrap = true;
break;
default:
throw new ParserSyntaxErrorException();
}
return result;
}
private ReadResult ParseIdentifier(Token token)
{
ReadResult result = ReadResult.Empty;
switch (token.Text)
{
case "true":
result.Expression = Expression.Constant(true);
break;
case "false":
result.Expression = Expression.Constant(false);
break;
case "null":
result.Expression = Expression.Constant(null);
break;
case "sizeof":
if (spResult.NextIs(TokenId.OpenParen))
{
result.Expression = Expression.Constant(Marshal.SizeOf(typeParser.ReadType()));
spResult.NextIs(TokenId.CloseParen);
}
else
throw new ParserSyntaxErrorException();
break;
case "typeof":
if (spResult.NextIs(TokenId.OpenParen))
{
result.Expression = Expression.Constant(typeParser.ReadType(), typeof(Type));
spResult.NextIs(TokenId.CloseParen);
}
else
throw new ParserSyntaxErrorException();
break;
case "new":
{
var type = typeParser.ReadType();
// 判断初始化的类型
token = spResult.Next();
// 构造函数成员初始化/集合项初始化
if (token.ID == TokenId.OpenParen || token.ID == TokenId.OpenBrace)
{
// 构建构造函数 new 的部分
if (token.ID == TokenId.OpenParen)
{
// 获取参数
var listParam = GetCollectionInits(true).ToArray();
var paramTypes = listParam.Select(m => m.Type).ToArray();
// 获取构造函数
var constructor = type.GetConstructors()
.Select(p => new
{
Parameters = p.GetParameters().Select(r => r.ParameterType).ToArray(),
Constructor = p,
})
.Where(p => p.Parameters.Length == paramTypes.Length)
.First(p => p.Parameters.Select(r => r.GetNoneNullableType())
.SequenceEqual(paramTypes.Select(r => r.GetNoneNullableType())))
.Constructor;
// 获取匹配的构造函数参数
var constructorParamTypes =
constructor.GetParameters()
.Select(p => p.ParameterType)
.Zip(listParam, (x, y) => new { Left = x, Right = y })
.Select((p, i) =>
{
if (p.Left.IsNullable() && p.Left != p.Right.Type)
return Expression.Convert(p.Right, p.Left.GetNullableType());
else
return p.Right;
})
.ToArray();
// 构造函数调用
result.Expression = Expression.New(constructor, constructorParamTypes);
}
else
result.Expression = Expression.New(type.GetConstructor(Type.EmptyTypes));
// 构建构造函数属性成员初始化或者集合初始化
if (spResult.PeekNextIs(TokenId.OpenBrace) || token.ID == TokenId.OpenBrace)
{
if (token.ID == TokenId.OpenParen)
spResult.Next();
// 测试是否属性成员初始化
bool isMemberInit = spResult.PeekNextIs(TokenId.Equal, 2);
if (isMemberInit)
result.Expression =
Expression.MemberInit((NewExpression)result.Expression, GetObjectMembers(type).ToArray());
else
result.Expression =
Expression.ListInit((NewExpression)result.Expression, GetCollectionInits().ToArray());
}
}
else if (token.ID == TokenId.OpenBracket)
{
Expression[] @params = null;
if (spResult.PeekNextIs(TokenId.CloseBracket))
spResult.Next();
else
@params = GetCollectionInits().ToArray();
if (spResult.PeekNextIs(TokenId.OpenBrace))
result.Expression = Expression.NewArrayInit(type, GetCollectionInits().ToArray());
else
result.Expression = Expression.NewArrayBounds(type, @params);
}
else
throw new ParserSyntaxErrorException();
break;
}
default:
// 参数
if (expParams.Any(p => p.Name == token.Text))
result.Expression = expParams.First(p => p.Name == token.Text);
// 类型
else
{
var type = typeParser.ReadType(token.Text);
spResult.NextIs(TokenId.Dot, true);
var name = spResult.Next();
// 跳过尖括号 <> 中的元素
if (spResult.PeekNextIs(TokenId.LessThan))
spResult.SkipUntil(p => p.ID == TokenId.GreaterThan);
if (spResult.PeekNextIs(TokenId.OpenParen))
{
var @params = GetCollectionInits().ToArray();
var method = FindBestMethod(type, name, @params, true);
result.Expression = Expression.Call(method, @params);
}
else
{
var member = type.GetMember(name)[0];
if (member.MemberType == MemberTypes.Property)
result.Expression = Expression.Property(null, (PropertyInfo)member);
else
result.Expression = Expression.Field(null, (FieldInfo)member);
}
}
break;
}
return result;
}
private string DeleteDigitTypeReference(string number)
{
if (char.IsLetter(number.Last()))
return number.Substring(0, number.Length - 1);
return number;
}
private ReadResult ParseConvertType()
{
var originPos = spResult.Index;
var type = typeParser.ReadType(ignoreException: true);
if (type != null)
{
spResult.NextIs(TokenId.CloseParen, true);
var inner = ReadExpression();
return new ReadResult
{
Expression = Expression.Convert(inner.Expression, type),
IsClosedWrap = inner.IsClosedWrap,
};
}
else
{
spResult.ReturnToIndex(originPos);
var result = ReadExpression();
if (!spResult.PeekNextIs(TokenId.End))
result.IsClosedWrap = false;
return result;
}
}
好了，这次就写到这里吧，下次把 ReadNextExpression 方法写出来，顺便也把整个的源码提供下载。没时间写了，不要说我不厚道，谢谢了！对了，补上 ReadResult 类的源码：
/// <summary>
/// 表达式读取结果
/// </summary>
[DebuggerStepThrough]
[DebuggerDisplay("IsClosedWrap = {IsClosedWrap}, Expression = {Expression}")]
public struct ReadResult
{
private Expression _expression;
private bool _isClosedWrap;
/// <summary>
/// 获取一个空的读取结果.
/// </summary>
public static ReadResult Empty
{
get { return new ReadResult(); }
}
/// <summary>
/// 获取或设置读取到的表达式.
/// </summary>
public Expression Expression
{
get { return _expression; }
set { _expression = value; }
}
/// <summary>
/// 获取或设置一个值, 通过该值指示是否已经读取了关闭符号.
/// </summary>
public bool IsClosedWrap
{
get { return _isClosedWrap; }
set { _isClosedWrap = value; }
}
}
如果你感觉这篇文章对你有帮助，请帮忙点击一下推荐，谢谢了！