/// <summary>
/// 通过模式1提交到监听者
/// 检查是否在缓存中已经存在相应的工厂类,
// 如果不存在，根据ListenerFactoryTypeUseDI决定是通过DIContainerContainer获取工厂类，
// 还是使用反射创建工厂类
// 将创建出来的工厂类缓存在缓存中
/// </summary>
/// <param name="listener"></param>
/// <param name="message"></param>
/// <returns></returns>
private async Task <ValidateResult> PostToListenerByMode1(SMessageTypeListener listener, SMessage message)
{
if (!_listenerFactorys.TryGetValue(listener.ListenerFactoryType, out IFactory <ISMessageListener> listenerFactory))
{
lock (_listenerFactorys)
{
Type listenerFactoryType = Type.GetType(listener.ListenerFactoryType);
if (!_listenerFactorys.TryGetValue(listener.ListenerFactoryType, out listenerFactory))
{
object objListenerFactory;
if (listener.ListenerFactoryTypeUseDI == true)
{
//通过DI容器创建
//objListenerFactory = DIContainerContainer.Get(listenerFactoryType);
objListenerFactory = DIContainerGetHelper.Get().Get(listenerFactoryType);
}
else
{
//通过反射创建
objListenerFactory = listenerFactoryType.Assembly.CreateInstance(listenerFactoryType.FullName);
}
if (!(objListenerFactory is IFactory <ISMessageListener>))
{
var fragment = new TextFragment()
{
Code = TextCodes.SMessageTypeListenerTypeError,
DefaultFormatting = "消息类型{0}中，名称为{1}的监听者工厂的类型{2}未实现接口IFactory<ISMessageListener>",
ReplaceParameters = new List <object>()
{
listener.MessageType.Name, listener.Name, listener.ListenerFactoryType
}
};
throw new UtilityException((int)Errors.SMessageTypeListenerTypeError, fragment);
}
listenerFactory = (IFactory <ISMessageListener>)objListenerFactory;
_listenerFactorys.Add(listener.ListenerFactoryType, listenerFactory);
}
}
}
var listenerObj = listenerFactory.Create();
return(await listenerObj.Execute(message));
}
/// <summary>
/// 通过模式1直接调用由工厂类创建的调度作业服务
/// </summary>
/// <param name="action"></param>
/// <returns></returns>
private async Task <IScheduleActionResult> ExecuteByMode1(ScheduleAction action)
{
if (!_actionServiceFactories.TryGetValue(action.ScheduleActionServiceFactoryType, out IFactory <IScheduleActionService> actionFactory))
{
lock (_actionServiceFactories)
{
Type actionFactoryType = Type.GetType(action.ScheduleActionServiceFactoryType);
if (!_actionServiceFactories.TryGetValue(action.ScheduleActionServiceFactoryType, out actionFactory))
{
object objActionFactory;
if (action.ScheduleActionServiceFactoryTypeUseDI == true)
{
//通过DI容器创建
//objActionFactory = DIContainerContainer.Get(actionFactoryType);
objActionFactory = DIContainerGetHelper.Get().Get(actionFactoryType);
}
else
{
//通过反射创建
objActionFactory = actionFactoryType.Assembly.CreateInstance(actionFactoryType.FullName);
}
if (!(objActionFactory is IFactory <IScheduleActionService>))
{
var fragment = new TextFragment()
{
Code = TextCodes.ScheduleActionServiceTypeError,
DefaultFormatting = "调度作业{0}中，调度动作服务工厂的类型{1}未实现接口IFactory<IScheduleActionService>",
ReplaceParameters = new List <object>()
{
action.Name, action.ScheduleActionServiceFactoryType
}
};
throw new UtilityException((int)Errors.ScheduleActionServiceTypeError, fragment);
}
actionFactory = (IFactory <IScheduleActionService>)objActionFactory;
_actionServiceFactories.Add(action.ScheduleActionServiceFactoryType, actionFactory);
}
}
}
var actionObj = actionFactory.Create();
return(await actionObj.Execute(action.Configuration));
}
