/// <summary>
/// 调度
/// 1.这里要处理好异步任务，并且组装好事件队列
/// 2.异步会堵塞同步方法，同一时间只有1个dispatch能执行
/// </summary>
async public void Dispatch(UFluxAction action)
{
var oldState = GetCurrentState();
var ret = this.reducers.IsAsyncLoad(action.ActionEnum);
if (!ret) //同步模式
{
//先执行await
var _newstate = await this.reducers.ExcuteAsync(action.ActionEnum, action.Params, oldState);
//再执行普通
if (_newstate == null)
{
this.reducers.Excute(action.ActionEnum, action.Params, oldState);
}
//素质三连
CacheCurrentState();
this.state = _newstate;
TriggerAllCallback();
}
else //回调模式
{
this.reducers.ExcuteByCallback(action.ActionEnum, action.Params, GetCurrentState, (_newState) =>
{
//素质三连
CacheCurrentState();
this.state = _newState;
TriggerAllCallback();
});
}
}
/// <summary>
/// 调度
/// 1.这里要处理好异步任务，并且组装好事件队列
/// 2.异步会堵塞同步方法，同一时间只有1个dispatch能执行
/// </summary>
public void Dispatch(UFluxAction action)
{
//新对象
var newState = GetCurrentState();
var ret = this.reducers.IsAsyncLoad(action.ActionEnum);
if (!ret) //同步模式
{
this.reducers.Excute(action.ActionEnum, action.Params, newState);
//素质三连
CacheCurrentState();
this.state = newState;
TriggerAllCallback();
}
else //异步模式
{
this.reducers.AsyncExcute(action.ActionEnum, action.Params, GetCurrentState, (_newState) =>
{
//素质三连
CacheCurrentState();
this.state = _newState;
TriggerAllCallback();
});
}
}
/// <summary>
/// 调度
/// 1.这里要处理好异步任务，并且组装好事件队列
/// 2.异步会堵塞同步方法，同一时间只有1个dispatch能执行
/// </summary>
async public void Dispatch(UFluxAction action)
{
var oldState = GetCurrentState();
foreach (var reducer in reducerList)
{
var ret = reducer.IsAsyncLoad(action.ActionEnum);
if (!ret) //同步模式
{
//先执行await
var newstate = await reducer.ExcuteAsync(action.ActionEnum, action.Params, oldState);
//再执行普通
if (newstate == null)
{
newstate = reducer.Excute(action.ActionEnum, action.Params, oldState);
}
//设置new state
SetNewState(newstate);
}
else //回调模式
{
reducer.ExcuteByCallback(action.ActionEnum, action.Params, GetCurrentState, (newState) =>
{
//设置new state
SetNewState(newState);
});
}
}
}
/// <summary>
/// 分发
/// </summary>
/// <param name="actionEnum"></param>
public void Dispatch(Enum actionEnum, object @params = null)
{
var action = new UFluxAction()
{
ActionEnum = actionEnum
};
action.SetParams(@params);
//分发
Dispatch(action);
}
/// <summary>
/// 分发
/// </summary>
/// <param name="actionEnum"></param>
/// <param name="params"></param>
public bool Dispatch(Enum actionEnum, object @params = null)
{
var type = this.reducer.GetExecuteType(@actionEnum);
if (type != AReducers <S> .ExecuteTypeEnum.None)
{
var action = new UFluxAction()
{
ActionTag = actionEnum
};
action.SetParams(@params);
//分发
Dispatch(action);
return(true);
}
return(false);
}
/// <summary>
/// 调度
/// 1.这里要处理好异步任务，并且组装好事件队列
/// 2.异步会堵塞同步方法，同一时间只有1个dispatch能执行
/// </summary>
async private void Dispatch(UFluxAction action)
{
var executeType = reducer.GetExecuteType(action.ActionTag);
switch (executeType)
{
case AReducers <S> .ExecuteTypeEnum.Synchronization:
{
var oldState = GetCurrentState();
var newstate = reducer.Excute(action.ActionTag, action.Params, oldState);
//设置new state
SetNewState(action.ActionTag, newstate);
}
break;
case AReducers <S> .ExecuteTypeEnum.Async:
{
var oldState = GetCurrentState();
var newstate = await reducer.ExcuteAsync(action.ActionTag, action.Params, oldState);
//设置new state
SetNewState(action.ActionTag, newstate);
}
break;
case AReducers <S> .ExecuteTypeEnum.Callback:
{
reducer.ExcuteByCallback(action.ActionTag, action.Params, GetCurrentState, (newState) =>
{
//设置new state
SetNewState(action.ActionTag, newState);
});
}
break;
}
}
