/// <summary>
/// 发布事件，使之能作用到目标事件
/// </summary>
/// <param name="eventBus">命令总线</param>
/// <param name="context">事件上下文</param>
/// <param name="e">事件</param>
public static Task PublishEventAsync(this IEventBus eventBus, IEvent e, ICommandContext context)
{
if (e == null)
{
throw new ParameterNullException("e", "聚合根事件不能为空");
}
if (EmitBuilder.PreferredDynamic)
{
return(Task.FromResult(eventBus.Publish(context, (dynamic)e)));
}
var type = e.GetType();
var action = actionTable[type] as Func <IEventBus, IEvent, ICommandContext, Task>;
if (action == null)
{
var emit = EasyEmitBuilder <Func <IEventBus, IEvent, ICommandContext, Task> > .NewDynamicMethod();
emit.LoadArgument(0);
emit.LoadArgument(1);
emit.LoadArgument(2);
emit.Call(typeof(AnonymousExtension).GetMethod("PublishEventBuilderInvokerAsync", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Static).MakeGenericMethod(type));
emit.Return();
actionTable[type] = action = emit.CreateDelegate();
}
return(action.Invoke(eventBus, e, context));
}
/// <summary>
/// 发布消息
/// </summary>
/// <param name="publisher">发布者</param>
/// <param name="context">消息上下文</param>
/// <param name="message">消息内容</param>
public static void PublishMessage(this IMessagePublisher publisher, IMessage message, IMessageContext context)
{
if (message == null)
{
throw new ParameterNullException("message", "消息内容不能为空");
}
if (EmitBuilder.PreferredDynamic)
{
publisher.Publish(context, (dynamic)message);
return;
}
var type = message.GetType();
var action = actionTable[type] as Action <IMessagePublisher, IMessage, IMessageContext>;
if (action == null)
{
var emit = EasyEmitBuilder <Action <IMessagePublisher, IMessage, IMessageContext> > .NewDynamicMethod();
emit.LoadArgument(0);
emit.LoadArgument(1);
emit.LoadArgument(2);
emit.Call(typeof(AnonymousExtension).GetMethod("PublishMessageBuilderInvoker", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Static).MakeGenericMethod(type));
emit.Return();
actionTable[type] = action = emit.CreateDelegate();
}
action.Invoke(publisher, message, context);
}
/// <summary>
/// 发布事件
/// </summary>
/// <param name="publisher"></param>
/// <param name="context"></param>
/// <param name="message"></param>
/// <returns></returns>
public static Task PublishMessageAsync(this IMessagePublisher publisher, IMessage message, IMessageContext context)
{
if (message == null)
{
throw new ParameterNullException("message", "消息内容不能为空");
}
if (EmitBuilder.PreferredDynamic)
{
return(Task.FromResult(publisher.Publish(context, (dynamic)message)));
}
var type = message.GetType();
var function = asyncActionTable[type] as Func <IMessagePublisher, IMessage, IMessageContext, Task>;
if (function == null)
{
var emit = EasyEmitBuilder <Func <IMessagePublisher, IMessage, IMessageContext, Task> > .NewDynamicMethod();
emit.LoadArgument(0);
emit.LoadArgument(1);
emit.LoadArgument(2);
emit.Call(typeof(AnonymousExtension).GetMethod("PublishMessageAsyncBuilderInvoker", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Static).MakeGenericMethod(type));
emit.Return();
asyncActionTable[type] = function = emit.CreateDelegate();
}
return(function.Invoke(publisher, message, context));
}
/// <summary>
/// 发布命令
/// </summary>
/// <param name="commandBus">命令总线</param>
/// <param name="command">命令</param>
/// <param name="communication">上下文通讯</param>
public static ICommandHandlerResult SendCommand(this ICommandBus commandBus, ICommand @command, HandlerCommunication communication)
{
if (@command == null)
{
throw new ParameterNullException("command", "聚合根命令不能为空");
}
if (EmitBuilder.PreferredDynamic)
{
return(commandBus.Send((dynamic)command, communication));
}
var type = @command.GetType();
var action = actionTable[type] as Func <ICommandBus, ICommand, HandlerCommunication, ICommandHandlerResult>;
if (action == null)
{
var emit = EasyEmitBuilder <Func <ICommandBus, ICommand, HandlerCommunication, ICommandHandlerResult> > .NewDynamicMethod();
emit.LoadArgument(0);
emit.LoadArgument(1);
emit.LoadArgument(2);
emit.Call(typeof(AnonymousExtension).GetMethod("SendCommandBuilderInvoker", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Static).MakeGenericMethod(type));
emit.Return();
actionTable[type] = action = emit.CreateDelegate();
}
return(action.Invoke(commandBus, command, communication));
}
/// <summary>
/// 对常见的值类型进行emit操作
/// </summary>
/// <param name="emit">emit操作</param>
private static void BuildDefinedType(EasyEmitBuilder <Func <IDataRecord, T> > emit)
{
var type = typeof(T);
var dbnullLabel = emit.DefineLabel();
var retLbl = emit.DefineLabel();
var locals = new[]
{
emit.DeclareLocal(typeof(bool)),
emit.DeclareLocal(type),
};
emit.LoadArgument(0);
emit.LoadConstant(0);
emit.Call(DataRecordBuilderHelper._mIsDBNull);
emit.StoreLocal(locals[0]);
emit.LoadLocal(locals[0]);
emit.BranchIfTrue(dbnullLabel);
emit.LoadArgument(0);
emit.LoadConstant(0);
emit.Call(DataRecordBuilderHelper.DefinedTypeDict[type]);
emit.StoreLocal(locals[1]);
emit.Branch(retLbl);
emit.MarkLabel(dbnullLabel);
emit.LoadLocalAddress(locals[1]);
emit.InitializeObject(type);
emit.LoadLocal(locals[1]);
emit.StoreLocal(locals[1]);
emit.Branch(retLbl);
emit.MarkLabel(retLbl);
emit.LoadLocal(locals[1]);
emit.Return();
}
/// <summary>
/// 实现属性set方法
/// </summary>
/// <param name="field">字段</param>
/// <returns></returns>
public static Action <object, object> BuildSetMethod(this FieldInfo field)
{
if (field == null)
{
return(null);
}
if (!field.IsInitOnly)
{
return(null);
}
var emit = EasyEmitBuilder <Action <object, object> > .NewDynamicMethod();
/*静态方法可以不用加载this*/
if (!field.IsStatic)
{
emit.LoadArgument(0);
}
emit.LoadArgument(1);
if (field.FieldType.IsValueType)
{
emit.UnboxAny(field.FieldType);
}
else
{
emit.CastClass(field.FieldType);
}
emit.StoreField(field);
emit.Return();
return(emit.CreateDelegate());
}
/// <summary>
/// 进行构建
/// </summary>
/// <param name="target">目标对象</param>
/// <param name="setting">配置</param>
/// <param name="interceptors">所实现的拦截器接口</param>
/// <returns></returns>
public Func <Target, IInterceptor[], Target> Build(Target target, InterceptCompileSetting setting, Type[] interceptors)
{
var build = this.BuildNotCepaType(target);
if (build != null)
{
return(build);
}
var newType = default(Type);
/*构建接口，较为容易*/
if (this.TargetType.IsInterface)
{
newType = BuildInterface(this.TargetType, typeof(Target), interceptors, setting);
var interfaceEmit = EasyEmitBuilder <Func <Target, IInterceptor[], Target> > .NewDynamicMethod();
interfaceEmit.LoadArgument(0);
interfaceEmit.LoadArgument(1);
interfaceEmit.NewObject(newType.GetConstructor(new[] { typeof(Target), typeof(IInterceptor[]) }));
interfaceEmit.Return();
return(interfaceEmit.CreateDelegate());
}
newType = BuildClass(target.GetType(), interceptors, setting);
var classEmit = EasyEmitBuilder <Func <Target, IInterceptor[], Target> > .NewDynamicMethod();
//classEmit.LoadArgument(0);
classEmit.LoadArgument(1);
classEmit.NewObject(newType.GetConstructor(new[] { typeof(IInterceptor[]) }));
classEmit.Return();
return(classEmit.CreateDelegate());
}
/// <summary>
/// 进行构建
/// </summary>
/// <returns></returns>
public Action <ISerializerWriter, JsonSerializeSetting, TException, byte> Build(JsonSerializeSetting setting)
{
var emit = EasyEmitBuilder <Action <ISerializerWriter, JsonSerializeSetting, TException, byte> > .NewDynamicMethod();
this.Build(emit, setting);
emit.Return();
return(emit.CreateDelegate());
}
/// <summary>
/// 使用Type来构造<see cref="DbProviderFactory"/>
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
protected static DbProviderFactory CreateDbProviderFactory(Type type)
{
var emit = EasyEmitBuilder <Func <DbProviderFactory> > .NewDynamicMethod();
emit.NewObject(type.GetConstructors(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)[0]);
emit.Return();
return(emit.CreateDelegate().Invoke());
}
/// <summary>
/// 进行构建
/// </summary>
public Func <IDeserializerReader, JsonDeserializeSetting, int, TException> Build(JsonDeserializeSetting setting)
{
var emit = EasyEmitBuilder <Func <IDeserializerReader, JsonDeserializeSetting, int, TException> > .NewDynamicMethod();
this.Build(emit);
emit.Return();
return(emit.CreateDelegate());
}
public void TestCtor()
{
var emit = EasyEmitBuilder <Func <MyCommand> > .NewDynamicMethod();
emit.NewObject(typeof(MyCommandTwo), Type.EmptyTypes);
emit.Return();
var com = emit.CreateDelegate()();
}
/// <summary>
/// 进行构建
/// </summary>
/// <param name="sourceType"></param>
/// <returns></returns>
public virtual Type BuildClass(Type sourceType)
{
/*检查支持类型*/
this.SupportType(sourceType);
/*是接口类型，则要在内存中生成一个类，用于实现该接口所有定义*/
/*生命一个类对象构造*/
var nextTypename = this.GetNextTypeName(sourceType);
var typeBuilder = EasyEmitBuilder <Type> .NewTypeBuilder(nextTypename.NameSplace, nextTypename.TypeName, TypeAttributes.Public, sourceType, Type.EmptyTypes);
/*获取成员，接口全部都是方法，对象可能返回，属性，字段等成员，但我们主要是代理方法*/
var members = this.GetMembers(sourceType);
var exists = new List <MemberInfo>(members.Length);
foreach (var member in members)
{
if (exists.Contains(member))
{
continue;
}
if (member.MemberType == MemberTypes.Field)
{
this.BuildField(member, members, exists, typeBuilder, sourceType, false);
continue;
}
if (member.MemberType == MemberTypes.Property)
{
this.BuildProperty(member, members, exists, typeBuilder, sourceType, false);
continue;
}
if (member.MemberType == MemberTypes.Event)
{
this.BuildEvent(member, members, exists, typeBuilder, sourceType, false);
continue;
}
}
foreach (var member in members)
{
if (exists.Contains(member))
{
continue;
}
if (member.MemberType == MemberTypes.Method)
{
this.BuildMethod(member, members, exists, typeBuilder, sourceType, false);
continue;
}
}
return(EasyEmitBuilder <Type> .CreateTypeInfo(typeBuilder));
}
/// <summary>
/// 进行构建
/// </summary>
/// <param name="interfaceType"></param>
/// <returns></returns>
public virtual Type BuildInterface(Type interfaceType)
{
/*检查支持类型*/
this.SupportType(interfaceType);
/*是接口类型，则要在内存中生成一个类，用于实现该接口所有定义*/
/*生命一个类对象构造*/
var nextTypename = this.GetNextTypeName(interfaceType);
var typeBuilder = EasyEmitBuilder <Type> .NewTypeBuilder(nextTypename.NameSplace, nextTypename.TypeName, typeof(object), new[] { interfaceType });
/*构造函数*/
var ctorBuilder = typeBuilder.DefineDefaultConstructor(MethodAttributes.Public);
/*获取成员，接口全部都是方法*/
var members = this.GetInterfaceMembers(interfaceType);
var exists = new List <MemberInfo>(members.Length);
foreach (var member in members)
{
if (exists.Contains(member))
{
continue;
}
if (member.MemberType == MemberTypes.Event)
{
this.BuildEvent(member, members, exists, typeBuilder, interfaceType, true);
continue;
}
if (member.MemberType == MemberTypes.Property)
{
this.BuildProperty(member, members, exists, typeBuilder, interfaceType, true);
continue;
}
}
foreach (var member in members)
{
if (exists.Contains(member))
{
continue;
}
if (member.MemberType == MemberTypes.Method)
{
this.BuildMethod(member, members, exists, typeBuilder, interfaceType, true);
continue;
}
}
return(EasyEmitBuilder <Type> .CreateTypeInfo(typeBuilder));
}
/// <summary>
/// long
/// </summary>
private Func <T, string> BuildWithNumberForLong()
{
var emit = EasyEmitBuilder <Func <T, string> > .NewDynamicMethod();
var local = emit.DeclareLocal(typeof(long));
emit.LoadArgument(0);
emit.Convert(typeof(long));
emit.StoreLocal(local);
emit.LoadLocalAddress(local);
emit.CallVirtual(typeof(long).GetMethod("ToString", Type.EmptyTypes));
emit.Return();
return(emit.CreateDelegate());
}
/// <summary>
/// 进行构建
/// </summary>
public Func <IDeserializerReader, JsonDeserializeSetting, int, T> Build(JsonDeserializeSetting setting)
{
var emit = EasyEmitBuilder <Func <IDeserializerReader, JsonDeserializeSetting, int, T> > .NewDynamicMethod();
if (!IsComplexType(this.TargetType) || this.IsType(this.TargetType) || this.IsAssignableFrom(this.TargetType, typeof(Exception)))
{
this.BuildNotCepaType(emit, this.TargetType);
emit.Return();
return(emit.CreateDelegate());
}
this.Build(emit);
emit.Return();
return(emit.CreateDelegate());
}
/// <summary>
/// 对枚举进行emit操作
/// </summary>
/// <param name="emit"></param>
/// <param name="innerType">对象类型</param>
private static void BuildNullableEnumType(EasyEmitBuilder <Func <IDataRecord, T> > emit, Type innerType)
{
var type = typeof(T);
var dbnullLabel = emit.DefineLabel();
var retLbl = emit.DefineLabel();
var underlyingType = Enum.GetUnderlyingType(innerType);
var locals = new[]
{
emit.DeclareLocal(typeof(bool)),
emit.DeclareLocal(underlyingType),
emit.DeclareLocal(type),
};
emit.LoadArgument(0);
emit.LoadConstant(0);
emit.Call(DataRecordBuilderHelper._mIsDBNull);
emit.StoreLocal(locals[0]);
emit.LoadLocal(locals[0]);
emit.BranchIfTrue(dbnullLabel);
emit.LoadArgument(0);
emit.LoadConstant(0);
emit.Call(DataRecordBuilderHelper.DefinedTypeDict[underlyingType]);
emit.StoreLocal(locals[1]);
emit.LoadLocal(locals[1]);
emit.Call(typeof(DataRecordBuilderHelper).GetMethod("_EnumParse", BindingFlags.NonPublic | BindingFlags.Static).MakeGenericMethod(new[] { innerType, underlyingType }));
//emit.Call(DataRecordBuilderHelper.DefinedTypeDict[typeof(long)]);
//emit.StoreLocal(locals[1]);
//emit.LoadLocal(locals[1]);
//emit.Call(typeof(DataRecordBuilderHelper).GetMethod("_Int64EnumParse", BindingFlags.NonPublic | BindingFlags.Static).MakeGenericMethod(innerType));
emit.NewObject(typeof(T).GetConstructor(new[] { innerType }));
emit.StoreLocal(locals[2]);
emit.Branch(retLbl);
emit.MarkLabel(dbnullLabel);
emit.LoadLocalAddress(locals[2]);
emit.InitializeObject(type);
emit.LoadLocal(locals[2]);
emit.StoreLocal(locals[2]);
emit.Branch(retLbl);
emit.MarkLabel(retLbl);
emit.LoadLocal(locals[2]);
emit.Return();
}
/// <summary>
/// 反序列化对象
/// </summary>
/// <param name="input">源字符串</param>
/// <param name="targetType">目标类型</param>
/// <returns></returns>
public object DeserializeObject(string input, Type targetType)
{
if (string.IsNullOrEmpty(input))
{
return(null);
}
#if NET35
var action = typeAction[targetType] as Func <JavaScriptSerializer, string, object>;
if (action == null)
{
var members = typeof(JavaScriptConverter).GetMembers(BindingFlags.Instance | BindingFlags.Public);
foreach (var member in members)
{
if (member.MemberType != MemberTypes.Method)
{
continue;
}
if (member.Name != "Deserialize")
{
continue;
}
var method = (MethodInfo)member;
if (!method.IsGenericMethod)
{
continue;
}
var emit = EasyEmitBuilder <Func <JavaScriptSerializer, string, object> > .NewDynamicMethod();
emit.LoadArgument(0);
emit.LoadArgument(1);
emit.Call(method.MakeGenericMethod(targetType));
emit.Return();
typeAction[targetType] = action = emit.CreateDelegate();
return(action.Invoke(this, input));
}
}
return(action.Invoke(this, input));
#else
return(ser.Deserialize(input, targetType));
#endif
}
/// <summary>
/// 实现属性set方法
/// </summary>
/// <param name="prop">属性</param>
/// <returns></returns>
public static Action <object, object> BuildSetMethod(this PropertyInfo prop)
{
if (prop == null)
{
return(null);
}
if (!prop.CanWrite)
{
return(null);
}
var emit = EasyEmitBuilder <Action <object, object> > .NewDynamicMethod();
var setMethod = prop.GetSetMethod(true);
/*静态方法可以不用加载this*/
if (!setMethod.IsStatic)
{
emit.LoadArgument(0);
}
emit.LoadArgument(1);
if (prop.PropertyType.IsValueType)
{
emit.UnboxAny(prop.PropertyType);
}
else
{
emit.CastClass(prop.PropertyType);
}
if (setMethod.IsVirtual)
{
emit.CallVirtual(setMethod);
}
else
{
emit.Call(setMethod);
}
emit.Return();
return(emit.CreateDelegate());
}
/// <summary>
/// 进行构建
/// </summary>
public Action <ISerializerWriter, JsonSerializeSetting, T, byte> Build(JsonSerializeSetting setting)
{
var emit = EasyEmitBuilder <Action <ISerializerWriter, JsonSerializeSetting, T, byte> > .NewDynamicMethod();
if (!IsComplexType(this.TargetType) || this.IsType(this.TargetType) || this.IsAssignableFrom(this.TargetType, typeof(Exception)))
{
this.BuildNotCepaType(emit, setting, this.TargetType);
emit.Return();
return(emit.CreateDelegate());
}
//this.WriteObjectFrontSigil(emit);
this.Build(emit, setting);
// this.WriteObjectLastSigil(emit);
emit.Return();
return(emit.CreateDelegate());
}
/// <summary>
/// Build
/// </summary>
/// <returns></returns>
public static Func <IDataRecord, T> Build()
{
if (Func != null)
{
return(Func);
}
var type = typeof(T);
var emit = EasyEmitBuilder <Func <IDataRecord, T> > .NewDynamicMethod(string.Format("{0}", type.Name));
/*normal*/
if (DataRecordBuilderHelper.DefinedTypeDict.ContainsKey(type))
{
BuildDefinedType(emit);
return(emit.CreateDelegate());
}
else if (type.IsEnum)
{
BuildEnumType(emit);
return(emit.CreateDelegate());
}
/* nullable<T> */
var nullableType = Nullable.GetUnderlyingType(type);
if (nullableType != null)
{
var genericType = type.GetGenericArguments()[0];
if (DataRecordBuilderHelper.DefinedTypeDict.ContainsKey(genericType))
{
BuildNullableDefinedType(emit, genericType);
return(emit.CreateDelegate());
}
else if (genericType.IsEnum)
{
BuildNullableEnumType(emit, genericType);
return(emit.CreateDelegate());
}
}
BuildObject(emit);
return(emit.CreateDelegate());
}
public Action <SqlTagFormat, ArrayLabel, TextLabel, object, int> Build()
{
if (Action != null)
{
return(Action);
}
var emit = EasyEmitBuilder <Action <SqlTagFormat, ArrayLabel, TextLabel, object, int> > .NewDynamicMethod();
var method = typeof(ArrayLabel).GetMethod("LoadUsingDelegated").MakeGenericMethod(typeof(T));
emit.LoadArgument(0);
emit.LoadArgument(1);
emit.LoadArgument(2);
emit.LoadArgument(3);
emit.LoadArgument(4);
emit.Call(method);
emit.Return();
Action = emit.CreateDelegate();
return(Action);
}
static MyObject()
{
var type = typeof(T);
var emit = EasyEmitBuilder <Func <T> > .NewDynamicMethod();
var local = emit.DeclareLocal(type);
if (type.IsValueType)
{
emit.LoadLocalAddress(local);
emit.InitializeObject(type);
emit.LoadLocal(local);
emit.Return();
Go = emit.CreateDelegate();
return;
}
var ctors = typeof(T).GetConstructors(BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic);
foreach (var ctor in ctors)
{
if (ctor.GetParameters().Length == 0)
{
emit.NewObject(ctor);
emit.StoreLocal(local);
emit.LoadLocal(local);
emit.Return();
Go = emit.CreateDelegate();
return;
}
}
emit.LoadConstant(type);
emit.Call(typeof(Activator).GetMethod("CreateInstance", new[] { typeof(Type) }));
emit.StoreLocal(local);
emit.LoadLocal(local);
emit.Return();
Go = emit.CreateDelegate();
return;
}
/// <summary>
/// 用历史事件来重新还原聚合根最新状态
/// </summary>
/// <param name="history">历史领域事件</param>
public void ReplyEvent(IEnumerable <IEvent> history)
{
foreach (var e in history)
{
if (EmitBuilder.PreferredDynamic)
{
this.ApplyReplyEvent((dynamic)e);
}
else
{
var type = e.GetType();
var action = this.eventAction[type] as Action <AggregateRoot, IEvent>;
if (action == null)
{
//使用Delegate.CreateDelegate方法
//eventAction[type] = action = (Action<AggregateRoot, IEvent>)Delegate.CreateDelegate(typeof(Action<AggregateRoot, IEvent>), typeof(AggregateRoot).GetMethod("ApplyReplyEvent", BindingFlags.Instance | BindingFlags.NonPublic).MakeGenericMethod(type));
/*装一下逼*/
var emit = EasyEmitBuilder <Action <IAggregateRoot, IEvent> > .NewDynamicMethod();
//load(this)
emit.LoadArgument(0);
emit.LoadArgument(1);
emit.Call(typeof(AggregateRoot).GetMethod("ApplyReplyEvent", BindingFlags.Instance | BindingFlags.NonPublic).MakeGenericMethod(type));
emit.Return();
this.eventAction[type] = action = emit.CreateDelegate();
}
if (action == null)
{
continue;
}
action.Invoke(this, e);
}
this.Version++;
}
}
/// <summary>
/// 构建异常模块
/// </summary>
/// <param name="emit">emit构建</param>
/// <param name="setting">配置</param>
/// <param name="instanceLocal">当前对象变量</param>
/// <param name="sourceType">节点成员</param>
/// <param name="member">成员</param>
/// <param name="memberType">成员类型</param>
/// <param name="attributes">特性</param>
/// <returns></returns>
protected override bool BuildForExceptionModule(EasyEmitBuilder <Action <ISerializerWriter, JsonSerializeSetting, TException, byte> > emit, JsonSerializeSetting setting, ILocal instanceLocal, Type sourceType, MemberInfo member, Type memberType, Attribute[] attributes)
{
if (member.Name != "InnerException" || !TypeHelper.IsAssignableFrom(memberType, typeof(Exception)))
{
return(false);
}
var nullValue = emit.DefineLabel();
var relLabel = emit.DefineLabel();
if (instanceLocal == null)
{
if (sourceType.IsValueType)
{
emit.LoadArgumentAddress(2);
}
else
{
emit.LoadArgument(2);
}
}
else
{
if (sourceType.IsValueType)
{
emit.LoadLocalAddress(instanceLocal);
}
else
{
emit.LoadLocal(instanceLocal); // @object
}
}
if (member.MemberType == MemberTypes.Property) // @object.get_item()
{
emit.Call(((PropertyInfo)member).GetGetMethod());
}
else
{
emit.LoadField(((FieldInfo)member));
}
emit.LoadNull();
emit.CompareGreaterThan();
emit.BranchIfFalse(nullValue);
this.WriteMemberName(emit, setting, member, attributes);
this.WriteColon(emit, setting);
this.WriteObjectFrontSigil(emit, setting);
emit.LoadArgument(0);
emit.LoadArgument(1);
if (instanceLocal == null)
{
if (sourceType.IsValueType)
{
emit.LoadArgumentAddress(2);
}
else
{
emit.LoadArgument(2);
}
}
else
{
if (sourceType.IsValueType)
{
emit.LoadLocalAddress(instanceLocal);
}
else
{
emit.LoadLocal(instanceLocal); // @object
}
}
if (member.MemberType == MemberTypes.Property) // @object.get_item()
{
emit.Call(((PropertyInfo)member).GetGetMethod(true));
}
else
{
emit.LoadField(((FieldInfo)member));
}
emit.Call(Serialize.SerialierBuilderHelper.GetExceptionParseMethod(memberType));
this.WriteObjectLastSigil(emit, setting);
emit.Branch(relLabel);
emit.MarkLabel(nullValue);
this.WriteMemberName(emit, setting, member, attributes);
this.WriteColon(emit, setting);
if (setting.WriteNullWhenObjectIsNull)
{
this.WriteNull(emit, setting);
}
else
{
this.WriteObjectSigil(emit, setting);
}
emit.Branch(relLabel);
emit.MarkLabel(relLabel);
emit.Nop();
return(true);
}
/// <summary>
/// ctor
/// </summary>
/// <param name="typeHandler"></param>
public TypeHandlerAttribute(Type typeHandler)
{
if (!typeHandler.IsAssignableFromType(typeof(ITypeHandler)))
{
throw new ArgumentException("ITypeHandler is not AssignableFrom typehanlder");
}
this.TypeHandler = typeHandler;
//toVlaue
if (this.TypeHandler.IsAssignableFromType(typeof(IReadingFromDataRecordToValueTypeHandler <>)))
{
var types = this.TypeHandler.MatchTargetType(typeof(IReadingFromDataRecordToValueTypeHandler <>));
if (types.IsNullOrEmpty())
{
return;
}
foreach (var type in types)
{
if (type.IsInterface && type.IsGenericType && type.GetGenericTypeDefinition() == typeof(IReadingFromDataRecordToValueTypeHandler <>))
{
var genraiceArgs = type.GetGenericArguments();
if (genraiceArgs != null && genraiceArgs.Length > 0)
{
var emit = EasyEmitBuilder <Func <TypeHandlerAttribute, System.Data.IDataRecord, string, object> > .NewDynamicMethod();
emit.LoadArgument(0);
emit.LoadArgument(1);
emit.LoadArgument(2);
emit.Call(typeof(TypeHandlerAttribute).GetMethod("OnDataReadingUsingEmit", BindingFlags.NonPublic | BindingFlags.Static).MakeGenericMethod(genraiceArgs));
emit.Return();
toValue = emit.CreateDelegate();
break;
}
}
}
}
//toParameter
if (this.TypeHandler.IsAssignableFromType(typeof(ICastingValueToParameterTypeHandler <>)))
{
var types = this.TypeHandler.MatchTargetType(typeof(ICastingValueToParameterTypeHandler <>));
if (types.IsNullOrEmpty())
{
return;
}
foreach (var type in types)
{
if (type.IsInterface && type.IsGenericType && type.GetGenericTypeDefinition() == typeof(ICastingValueToParameterTypeHandler <>))
{
var genraiceArgs = type.GetGenericArguments();
if (genraiceArgs != null && genraiceArgs.Length > 0)
{
var emit = EasyEmitBuilder <Func <TypeHandlerAttribute, object, object> > .NewDynamicMethod();
emit.LoadArgument(0);
emit.LoadArgument(1);
emit.Call(typeof(TypeHandlerAttribute).GetMethod("OnInitingParameterUsingEmit", BindingFlags.NonPublic | BindingFlags.Static).MakeGenericMethod(genraiceArgs));
emit.Return();
toParameter = emit.CreateDelegate();
break;
}
}
}
}
}
/// <summary>
/// 快速实现方法
/// </summary>
/// <param name="method">方法</param>
/// <returns></returns>
public static Func <object, object[], object> GetMethodInvoker(this MethodInfo method)
{
var emit = EasyEmitBuilder <Func <object, object[], object> > .NewDynamicMethod();
var parameters = method.GetParameters();
var parameterTypes = new List <Type>(parameters.Length);
foreach (var parameter in parameters)
{
parameterTypes.Add(parameter.ParameterType.IsByRef ? parameter.ParameterType.GetElementType() : parameter.ParameterType);
}
var locals = new List <ILocal>(emit.ParameterTypes.Length);
for (var i = 0; i < parameterTypes.Count; i++)
{
var local = emit.DeclareLocal(parameterTypes[i]);
emit.LoadArgument(1);
emit.LoadConstant(i);
emit.LoadElementReference();
if (parameterTypes[i].IsValueType)
{
emit.UnboxAny(parameterTypes[i]);
}
else
{
emit.CastClass(parameterTypes[i]);
}
emit.StoreLocal(local);
locals.Add(local);
}
if (!method.IsStatic)
{
emit.LoadArgument(0);
}
for (var i = 0; i < parameterTypes.Count; i++)
{
if (parameterTypes[i].IsByRef)
{
emit.LoadLocalAddress(locals[i]);
}
else
{
emit.LoadLocal(locals[i]);
}
}
if (method.IsVirtual)
{
emit.CallVirtual(method);
}
else
{
emit.Call(method);
}
if (method.ReturnType == typeof(void))
{
emit.LoadNull();
}
else if (method.ReturnType.IsValueType)
{
emit.Box(method.ReturnType);
}
emit.Return();
return(emit.CreateDelegate());
}
/// <summary>
/// ulong
/// </summary>
private Func <T, string> BuildForULong()
{
var emit = EasyEmitBuilder <Func <T, string> > .NewDynamicMethod();
IDictionary <ulong, KeyValuePair <string, T> > enumValus = null;
enumValus = EnumValues <T> .ToULongDictionary();
if (enumValus.Count == 0)
{
emit.LoadConstant("");
emit.Return();
return(emit.CreateDelegate());
}
var type = typeof(ulong);
var donelbl = emit.DefineLabel();
var defaultLbl = emit.DefineLabel();
var local = emit.DeclareLocal(type);
var stringLocal = emit.DeclareLocal(typeof(string));
var writeLabels = new List <ILabel>(enumValus.Count);
var jumpLabels = new List <ILabel>(enumValus.Count);
foreach (var i in enumValus)
{
writeLabels.Add(emit.DefineLabel());
jumpLabels.Add(emit.DefineLabel());
}
emit.LoadArgument(0);
emit.Convert(type);
emit.StoreLocal(local);
emit.Branch(jumpLabels[0]);
var index = -1;
foreach (var l in enumValus)
{
index++;
emit.MarkLabel(jumpLabels[index]);
emit.LoadConstant(l.Key);
emit.LoadLocal(local);
if (index == enumValus.Count - 1)
{
emit.UnsignedBranchIfNotEqual(defaultLbl);
emit.Nop();
}
else
{
emit.UnsignedBranchIfNotEqual(jumpLabels[index + 1]);
emit.Nop();
}
emit.Branch(writeLabels[index]);
emit.Nop();
}
index = -1;
foreach (var l in enumValus)
{
index++;
emit.MarkLabel(writeLabels[index]);
emit.LoadConstant(l.Value.Key);
emit.StoreLocal(stringLocal);
emit.Branch(donelbl);
}
/*default*/
emit.MarkLabel(defaultLbl);
emit.LoadLocalAddress(local);
emit.CallVirtual(typeof(ulong).GetMethod("ToString", Type.EmptyTypes));
emit.StoreLocal(stringLocal);
emit.Branch(donelbl);
/*done*/
emit.MarkLabel(donelbl);
emit.LoadLocal(stringLocal);
emit.Return();
return(emit.CreateDelegate());
}
/// <summary>
/// 对对象进行emit操作
/// </summary>
/// <param name="emit">The emit.</param>
public static void BuildObject(EasyEmitBuilder <Func <IDataRecord, T> > emit)
{
var type = typeof(T);
var targetMembers = GetMembers(type);
/*实例*/
var instanceLocal = emit.DeclareLocal(type);
if (type.IsValueType)
{
if (targetMembers == null || targetMembers.Count == 0)
{
emit.LoadLocalAddress(instanceLocal);
emit.InitializeObject(type);
emit.LoadLocal(instanceLocal);
emit.Return();
return;
}
emit.LoadLocalAddress(instanceLocal);
emit.InitializeObject(type);
emit.LoadLocal(instanceLocal);
emit.StoreLocal(instanceLocal);
goto _Read;
}
else
{
/*object*/
var ctors = typeof(T).GetConstructors(BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic);
foreach (var ctor in ctors)
{
if (ctor.GetParameters().Length == 0)
{
emit.NewObject(ctor);
emit.StoreLocal(instanceLocal);
if (targetMembers == null || targetMembers.Count == 0)
{
emit.LoadLocal(instanceLocal);
emit.Return();
return;
}
goto _Read;
}
}
throw new ArgumentException(string.Format("the type {0} can not find the no parameter of ctor method", typeof(T).FullName));
}
_Read:
{
var locals = new[]
{
emit.DeclareLocal(typeof(bool)),
emit.DeclareLocal(typeof(int)),
};
var retlbl = emit.DefineLabel();
var labels = new List <ILabel>(targetMembers.Count);
for (var i = 0; i < targetMembers.Count; i++)
{
labels.Add(emit.DefineLabel());
}
for (var i = 0; i < targetMembers.Count; i++)
{
var member = targetMembers[i];
Type memberType = member.MemberType == MemberTypes.Property ? ((PropertyInfo)member).PropertyType : ((FieldInfo)member).FieldType;
if (i > 0)
{
emit.MarkLabel(labels[i]);
}
var attribute = member.GetCustomAttribute <TypeHandlerAttribute>();
if (attribute != null && attribute.TypeHandler.IsAssignableFromType(typeof(IReadingFromDataRecordToValueTypeHandler <>)))
{
TypeHandlerAttributeStorager <T> .Storage(attribute, member.Name);
if (type.IsValueType)
{
emit.LoadLocalAddress(instanceLocal);
}
else
{
emit.LoadLocal(instanceLocal);
}
emit.LoadArgument(0);
emit.LoadConstant(member.Name);
if (member.MemberType == MemberTypes.Property)
{
emit.Call(typeof(DataRecordBuilderHelper).GetMethod("ReadingValueFromDataRecordTypeHandler").MakeGenericMethod(new[] { ((PropertyInfo)member).PropertyType, type }));
emit.Call(((PropertyInfo)member).GetSetMethod(true));
}
else
{
emit.Call(typeof(DataRecordBuilderHelper).GetMethod("ReadingValueFromDataRecordTypeHandler").MakeGenericMethod(new[] { ((FieldInfo)member).FieldType, type }));
emit.StoreField(((FieldInfo)member));
}
if (i < labels.Count - 1)
{
emit.Branch(labels[i + 1]);
}
else
{
emit.Branch(retlbl);
}
continue;
}
/*reader*/
emit.LoadArgument(0);
emit.LoadConstant(member.Name);
emit.Call(DataRecordBuilderHelper._mGetOrdinal);
emit.StoreLocal(locals[1]);
emit.LoadLocal(locals[1]);
emit.LoadConstant(0);
if (i < labels.Count - 1)
{
emit.BranchIfLess(labels[i + 1]);
}
else
{
emit.BranchIfLess(retlbl);
}
emit.LoadArgument(0);
emit.LoadLocal(locals[1]);
emit.Call(DataRecordBuilderHelper._mIsDBNull);
emit.StoreLocal(locals[0]);
emit.LoadLocal(locals[0]);
if (i < labels.Count - 1)
{
emit.BranchIfTrue(labels[i + 1]);
}
else
{
emit.BranchIfTrue(retlbl);
}
if (DataRecordBuilderHelper.DefinedTypeDict.ContainsKey(memberType))
{
if (type.IsValueType)
{
emit.LoadLocalAddress(instanceLocal);
}
else
{
emit.LoadLocal(instanceLocal);
}
emit.LoadArgument(0);
emit.LoadLocal(locals[1]);
emit.Call(DataRecordBuilderHelper.DefinedTypeDict[memberType]);
if (member.MemberType == MemberTypes.Property)
{
emit.Call(((PropertyInfo)member).GetSetMethod(true));
}
else
{
emit.StoreField(((FieldInfo)member));
}
if (i < labels.Count - 1)
{
emit.Branch(labels[i + 1]);
}
else
{
emit.Branch(retlbl);
}
continue;
}
else if (memberType.IsEnum)
{
if (type.IsValueType)
{
emit.LoadLocalAddress(instanceLocal);
}
else
{
emit.LoadLocal(instanceLocal);
}
emit.LoadArgument(0);
emit.LoadLocal(locals[1]);
var underlyingType = Enum.GetUnderlyingType(memberType);
emit.Call(DataRecordBuilderHelper.DefinedTypeDict[underlyingType]);
emit.Call(typeof(DataRecordBuilderHelper).GetMethod("_EnumParse", BindingFlags.NonPublic | BindingFlags.Static).MakeGenericMethod(new[] { memberType, underlyingType }));
//emit.Call(DataRecordBuilderHelper.DefinedTypeDict[typeof(long)]);
//emit.Call(typeof(DataRecordBuilderHelper).GetMethod("_EnumParse", BindingFlags.NonPublic | BindingFlags.Static).MakeGenericMethod(memberType));
if (member.MemberType == MemberTypes.Property)
{
emit.Call(((PropertyInfo)member).GetSetMethod(true));
}
else
{
emit.StoreField(((FieldInfo)member));
}
if (i < labels.Count - 1)
{
emit.Branch(labels[i + 1]);
}
else
{
emit.Branch(retlbl);
}
continue;
}
else if (Nullable.GetUnderlyingType(memberType) != null)
{
var nullable = Nullable.GetUnderlyingType(memberType);
if (nullable.IsEnum)
{
if (type.IsValueType)
{
emit.LoadLocalAddress(instanceLocal);
}
else
{
emit.LoadLocal(instanceLocal);
}
emit.LoadArgument(0);
emit.LoadLocal(locals[1]);
var underlyingType = Enum.GetUnderlyingType(nullable);
emit.Call(DataRecordBuilderHelper.DefinedTypeDict[underlyingType]);
emit.Call(typeof(DataRecordBuilderHelper).GetMethod("_EnumParse", BindingFlags.NonPublic | BindingFlags.Static).MakeGenericMethod(new[] { nullable, underlyingType }));
//emit.Call(DataRecordBuilderHelper.DefinedTypeDict[typeof(long)]);
//emit.Call(typeof(DataRecordBuilderHelper).GetMethod("_EnumParse", BindingFlags.NonPublic | BindingFlags.Static).MakeGenericMethod(nullable));
emit.NewObject(memberType, new[] { nullable });
if (member.MemberType == MemberTypes.Property)
{
emit.Call(((PropertyInfo)member).GetSetMethod(true));
}
else
{
emit.StoreField(((FieldInfo)member));
}
if (i < labels.Count - 1)
{
emit.Branch(labels[i + 1]);
}
else
{
emit.Branch(retlbl);
}
continue;
}
if (!DataRecordBuilderHelper.DefinedTypeDict.ContainsKey(nullable))
{
continue;
}
if (type.IsValueType)
{
emit.LoadLocalAddress(instanceLocal);
}
else
{
emit.LoadLocal(instanceLocal);
}
emit.LoadArgument(0);
emit.LoadLocal(locals[1]);
emit.Call(DataRecordBuilderHelper.DefinedTypeDict[nullable]);
emit.NewObject(memberType, new[] { nullable });
if (member.MemberType == MemberTypes.Property)
{
emit.Call(((PropertyInfo)member).GetSetMethod(true));
}
else
{
emit.StoreField(((FieldInfo)member));
}
if (i < labels.Count - 1)
{
emit.Branch(labels[i + 1]);
}
else
{
emit.Branch(retlbl);
}
continue;
}
else
{
emit.Nop();
}
}
emit.MarkLabel(retlbl);
emit.LoadLocal(instanceLocal);
emit.Return();
};
return;
}
private Func <string, T> BuildForULong()
{
var emit = EasyEmitBuilder <Func <string, T> > .NewDynamicMethod();
var ulongValues = EnumValues <T> .ToULongDictionary();
var enumValus = new Dictionary <string, ulong>(ulongValues.Count * 2);
foreach (var x in ulongValues)
{
enumValus[x.Key.ToString()] = x.Key;
enumValus[x.Value.Key] = x.Key;
}
if (enumValus.Count == 0)
{
emit.LoadConstant(0UL);
emit.Return();
return(emit.CreateDelegate());
}
var writeLabels = new List <ILabel>(enumValus.Count);
var jumpLabels = new List <ILabel>(enumValus.Count);
foreach (var i in enumValus)
{
writeLabels.Add(emit.DefineLabel());
jumpLabels.Add(emit.DefineLabel());
}
var ulongLocal = emit.DeclareLocal(typeof(ulong));
var equalLocal = emit.DeclareLocal(typeof(bool));
var donelbl = emit.DefineLabel();
var defaultLbl = emit.DefineLabel();
emit.Branch(jumpLabels[0]);
var index = -1;
foreach (var l in enumValus)
{
index++;
emit.MarkLabel(jumpLabels[index]);
emit.LoadConstant(l.Key);
emit.LoadArgument(0);
//emit.Call(typeof(String).GetMethod("op_Equality", new[] { typeof(string), typeof(string) }));
emit.Call(typeof(DeseralizerBuilderHelper).GetMethod("StringEqualityOnDeseralizing", new[] { typeof(string), typeof(string) }));
emit.StoreLocal(equalLocal);
emit.LoadLocal(equalLocal);
emit.BranchIfTrue(writeLabels[index]);
if (index == enumValus.Count - 1)
{
emit.Branch(defaultLbl);
}
else
{
emit.Branch(jumpLabels[index + 1]);
}
}
;
/*write lbl*/
index = -1;
foreach (var l in enumValus)
{
index++;
emit.MarkLabel(writeLabels[index]);
emit.LoadConstant(l.Value);
// emit.LoadConstant(3L);
emit.StoreLocal(ulongLocal);
emit.Branch(donelbl);
}
;
/*default*/
emit.MarkLabel(defaultLbl);
emit.LoadArgument(0);
emit.Call(typeof(DeseralizerBuilderHelper).GetMethod("UlongParseFromStringOnDeseralizing", new[] { typeof(string) }));
emit.StoreLocal(ulongLocal);
emit.Branch(donelbl);
/*done*/
emit.MarkLabel(donelbl);
emit.LoadLocal(ulongLocal);
emit.Call(typeof(DeseralizerBuilderHelper).GetMethod("UlongParseToEnumOnDeseralizing", new[] { typeof(long) }).MakeGenericMethod(new[] { typeof(T) }));
emit.Return();
//Console.WriteLine(emit.ToString());
return(emit.CreateDelegate());
}
/// <summary>
/// 构建异常模块
/// </summary>
/// <param name="emit">emit构建</param>
/// <param name="setting">配置</param>
/// <param name="sourceType">成员类型</param>
/// <returns></returns>
protected override bool BuildForExceptionModule(EasyEmitBuilder <Action <ISerializerWriter, JsonSerializeSetting, TException, byte> > emit, JsonSerializeSetting setting, Type sourceType)
{
return(base.BuildForExceptionModule(emit, setting, sourceType));
}
