用ExpressionTree实现JSON解析器

 1     public class Student
 2     {
 3         public int Id { get; set; }
 4         public string Name { get; set; }
 5         public Sex Sex { get; set; }
 6         public DateTime? Birthday { get; set; }
 7         public string Address { get; set; }
 8     }
 9 
10     public enum Sex
11     {
12         Unkown,Male,Female,
13     }

 1   public enum JsonTokenType : byte
 2     {
 3         None,    
 4         StartObject,  //{
 5         EndObject,    //}   
 6         StartArray,   //[
 7         EndArray,     //]
 8         PropertyName, //{标识后双引号包围的字符串或{内逗号后双引号包围的字符串 解析为PropertyName
 9         String,    //除PropertyName外双引号包围的字符串
10         Number,    //没有引号包围的数字  
11         True,      //true
12         False,     //false
13         Null,      //null
14         Comment    //注释
15     }

 1         public bool Read()
 2         {
 3             switch (_state)
 4             {
 5                 case ReadState.Start: _line = _position = 1; return ReadToken();
 6                 case ReadState.StartObject: return ReadProperty();
 7                 case ReadState.Property:
 8                 case ReadState.StartArray: return ReadToken();
 9                 case ReadState.EndObject:
10                 case ReadState.EndArray:
11                 case ReadState.Comma:
12                 case ReadState.Value: return ReadNextToken();
13                 case ReadState.End: return ValidateEndToken();
14                 default: throw new JsonException($"非法字符{_currentChar}", _line, _position);
15             }
16         }

 1 private bool ReadProperty()
 2 {
 3        var value =  MoveNext(true);
 4        switch (value)
 5        {
 6             case '"':
 7                 //读取propertyName值
 8                 return true;
 9             case '}':
10                 //readState状态值切换
11                 return true;
12             default: throw new JsonException($"非法字符{value }", _line, _position);
13         }
14 }
15     

1 public interface IConverterCreator
2     {
3         bool CanConvert(Type type);
4 
5         ITypeConverter Create(Type type);
6     }

 1  public abstract class TypeConverterProvider
 2     {
 3         public abstract IReadOnlyCollection<IConverterCreator> AllConverterFactories();
 4 
 5         public abstract void AddConverterFactory(IConverterCreator converter);
 6 
 7         public virtual ITypeConverter Build(Type type)
 8         {
 9             ITypeConverter convert = null;
10             foreach (var creator in AllConverterFactories())
11             {
12                 if (creator.CanConvert(type))
13                 {
14                     convert = creator.Create(type);
15                     break;
16                 }
17             }
18             if (convert == null) throw new JsonException($"创建{type}的{nameof(ITypeConverter)}失败，不支持的类型");
19             return convert;
20         }
21     }

 1  protected virtual Func<object> BuildCreateInstanceMethod(Type type)
 2         {
 3             NewExpression newExp;
 4             //优先获取无参构造函数
 5             var constructor = type.GetConstructor(Array.Empty<Type>());
 6             if (constructor != null)
 7                 newExp = Expression.New(type);
 8             else
 9             {
10                 //查找参数最少的一个构造函数
11                 constructor = type.GetConstructors().OrderBy(t => t.GetParameters().Length).FirstOrDefault();
12                 var parameters = constructor.GetParameters();
13                 List<Expression> parametExps = new List<Expression>();
14                 foreach (var para in parameters)
15                 {
16                     //有参构造函数使用默认值填充
17                     var defaultValue = GetDefaultValue(para.ParameterType);
18                     ConstantExpression constant = Expression.Constant(defaultValue);
19                     var paraValueExp = Expression.Convert(constant, para.ParameterType);
20                     parametExps.Add(paraValueExp);
21                 }
22                 newExp = Expression.New(constructor, parametExps);
23             }
24             Expression<Func<object>> expression = Expression.Lambda<Func<object>>(newExp);
25             return expression.Compile();
26         }

1         protected virtual Func<object, object> BuildGetValueMethod()
2         {
3             var instanceExp = Expression.Parameter(typeof(object), "instance");
4             var instanceTypeExp = Expression.Convert(instanceExp, MemberInfo.DeclaringType);
5             var memberExp = Expression.PropertyOrField(instanceTypeExp, MemberInfo.Name);
6             var body = Expression.TypeAs(memberExp, typeof(object));
7             Expression<Func<object, object>> exp = Expression.Lambda<Func<object, object>>(body, instanceExp);
8             return exp.Compile();
9         }

 1       protected virtual Action<object, object> BuildSetValueMethod()
 2         {
 3             var instanceExp = Expression.Parameter(typeof(object), "instance");
 4             var valueExp = Expression.Parameter(typeof(object), "memberValue");
 5 
 6             var instanceTypeExp = Expression.Convert(instanceExp, MemberInfo.DeclaringType);
 7             var memberExp = Expression.PropertyOrField(instanceTypeExp, MemberInfo.Name);
 8             //成员赋值
 9             var body = Expression.Assign(memberExp, Expression.Convert(valueExp, MemberType));
10             Expression<Action<object, object>> exp = Expression.Lambda<Action<object, object>>(body, instanceExp, valueExp);
11             return exp.Compile();
12         }

protected virtual Action<object, object, object> BuildSetKeyValueMethod(Type type)
        {
            var objExp = Expression.Parameter(typeof(object), "dic");
            var keyParaExp = Expression.Parameter(typeof(object), "key");
            var valueParaExp = Expression.Parameter(typeof(object), "value");
            var dicExp = Expression.TypeAs(objExp, Type);
            var keyExp = Expression.Convert(keyParaExp, KeyType);
            var valueExp = Expression.Convert(valueParaExp, ValueType);
            //调用索引器赋值
            var property = type.GetProperty("Item", new Type[] { KeyType });
            var indexExp = Expression.MakeIndex(dicExp, property, new Expression[] { keyExp });
            var body = Expression.Assign(indexExp, valueExp);
            var expression = Expression.Lambda<Action<object, object, object>>(body, objExp, keyParaExp, valueParaExp);
            return expression.Compile();
        }

 1         protected virtual Func<object, IEnumerator> BuildGetEnumberatorMethod(Type type)
 2         {
 3             var paramExp = Expression.Parameter(typeof(object), "list");
 4             var listExp = Expression.TypeAs(paramExp, type);
 5             var method = type.GetMethod(nameof(IEnumerable.GetEnumerator));//实现了IEnumerable的类一定有GetEnumerator方法
 6             var callExp = Expression.Call(listExp, method); //调用GetEnumerator()方法
 7             var body = Expression.TypeAs(callExp, typeof(IEnumerator)); //结果转换为IEnumerator类型
 8             var expression = Expression.Lambda<Func<object, IEnumerator>>(body, paramExp);  
 9             return expression.Compile();
10         }

 1         protected virtual Action<object, object> BuildAddItemMethod(Type type)
 2         {
 3             var listExp = Expression.Parameter(typeof(object), "list");
 4             var itemExp = Expression.Parameter(typeof(object), "item");
 5             var instanceExp = Expression.Convert(listExp, type);
 6             var argumentExp = Expression.Convert(itemExp, ItemType);
 7             var addMethod = type.GetMethod(AddMethodName);//添加数据方法AddMethodName有实现的子类去指定，默认为Add
 8             var callExp = Expression.Call(instanceExp, addMethod, argumentExp); //调用添加数据方法
 9             Expression<Action<object, object>> addItemExp = Expression.Lambda<Action<object, object>>(callExp, listExp, itemExp);
10             return addItemExp.Compile();
11         }