// 事件
//public event FaimDelegate.delOnMessage OnMessage;
// 变量
//clsMethodWhile_BLL bo_MethodWhile = null;
// 构造
public F_ThManager(clsFaim3 v_faim3, DAL_CommData v_dao_comm)
{
_faim3 = v_faim3;
_dao_comm = v_dao_comm;
//bo_MethodWhile = new clsMethodWhile_BLL(_faim3);
//bo_MethodWhile.OnMessage += new FaimDelegate.delOnMessage(evt_OnMessage_MethodWhile);
}
static void _SetValue(clsFaim3 _faim3, clsDevTestBits _line, int _val_2)
{
int _bit = -1;// 位
if (_faim3.dict_DevFunction.ContainsKey(_line.vName))
{
#region // BT_OUT
clsDevFunction _df = _faim3.dict_DevFunction[_line.vName]; //
int _devNo = _df.devNo; //设备号
int _refIdx = _faim3.sect_idev * _devNo;
_bit = _refIdx + _df.Index;//内存位
if (_df.varName.ToUpper() == "BT_OUT")
{
_faim3.Comm_Data.bt_out[0][_bit] = _val_2;//输出电位
}
#endregion
}
else if (_faim3._dim_dict.ContainsKey(_line.vName))
{
#region // _dim_dict 动态变量 dim[Feeder05_unLink] <== Value
_bit = _faim3._dim_dict[_line.vName]; // 内存位
_faim3._dim[_bit] = _val_2; // 直接设置, 用以联动
#endregion
}
else if (_line.vName.ToUpper().StartsWith("_FAIM3") ||
_line.vName.ToUpper().StartsWith("CLSFAIM3"))
{
F_TransCalc.doSetValue_byName(_faim3, _line.vName, _val_2);
}
}
protected int do_BaseNew(clsFaim3 v_faim3, DAL_CommData v_dao_comm)
{
_faim3 = v_faim3;
_dao_comm = v_dao_comm;
_ret = do_InitData();
return(_ret);
}
static string _dao_comm_set_msg(clsFaim3 _faim3, string _flowName, int caseLineIdx, ref int _loc)
{
string _msg = "";
clsFlow _flow = _faim3.dict_Flow[_flowName];
clsCaseState _caseState = _faim3.dict_CaseState[_flow.alartCase];
clsDevTestBits _line = _faim3.lst_DevTestBits[caseLineIdx];
foreach (var item in _faim3.dict_Flow)
{
if (item.Key == _flowName)// 流程名 转 流程号
{
// 0当前步骤, 1流程名, 1流程状态/步骤, 3行号, 4命令语句:5变量名=6值 7.转入模式 8.转出模式
_msg = string.Format("{0} {1} {2} {3} {4}{5} {6} {7} {8} {9}",
_flow.currCase,
_flowName,
_flow.eState.ToString(),
caseLineIdx,
_line.isDebug == 1 ? "#" : ".",
_line.IfType,
_line.vName,
_line.HL,
_caseState.beginMode,
_caseState.endMode
);
break;
}
_loc++;
}
return(_msg);
}
public clsWhile204(clsFaim3 v_faim3, DAL_CommData v_dao_comm, string vDevNo)
{
_CMD = "";
int _bit = 1;
// 常数
int _use_Axis = Convert.ToInt32(v_faim3.dict_KV["use_Axis"]);
for (int i = 0; i < 8; i++)
{
if ((_use_Axis & _bit) == _bit)
{
_lstAxisId.Add(i);
}
_bit = _bit << 1;
}
// 参数
_devNo = Convert.ToInt32(vDevNo);
_flowName = string.Format("{0}_{1}", v_faim3.dict_DevCards[_devNo].Name, _devNo); // [2]
// 初始化 基类
base.do_New(v_faim3, v_dao_comm, _flowName);
_protocol = new clsProtocol(_faim3, _dao_comm); // 协议
if (!_dao_comm.dict_DevIo.ContainsKey(_devNo.ToString())) // 注册设备号 对应 设备对象
{
_device = new cls204C(_faim3, _dao_comm, _devNo); // 设备
_dao_comm.dict_DevIo.Add(_devNo.ToString(), (IFaimIO)_device);
}
_dao_comm.OnEchoIO += new F_Delegate.delEcho(evt_comm_OnEchoIO); // 加消息
_dict_cmd.Add(_CMD01_Read_status, ""); // 第1命令
_dict_cmd.Add(_CMD02_Read_input, ""); // 第2命令
}
// MOVR 204C 011/3 -- 命令 设备 轴号/行号
public static void _204C(clsFaim3 _faim3, DAL_CommData _dao_comm, int idx)
{
clsDevTestBits _line = _faim3.lst_DevTestBits[idx];
clsDevFunction _df = _faim3.dict_DevFunction[_line.vName];//
_204C(_faim3, _dao_comm, _line.IfType, _line.HL, _df.devNo);
}
public frmFreeCode_09(clsFaim3 v_faim3, DAL_CommData v_dao_comm)
{
_faim3 = v_faim3;
_dao_comm = v_dao_comm;
CheckForIllegalCrossThreadCalls = false;
InitializeComponent();
}
// 线程名/流程名/设备ID, 忽略返回值
protected int do_New(clsFaim3 v_faim3, DAL_CommData v_dao_comm, string vflowName)
{
_faim3 = v_faim3;
_dao_comm = v_dao_comm;
// 无流程名， 则取类名
_flowName = (string.IsNullOrEmpty(vflowName)) ? this.GetType().Name : vflowName;
#region // dict_Threads 线程池
if (_faim3.dict_Threads.ContainsKey(_flowName)) // 存在key
{
FACC.F_Log.Debug_1("do_New()", string.Format("--->>>> {0}流程/设备存在", _flowName));
return(-1); //
}
clsThread _en = new clsThread(); // 线程消息
_en.Info = new clsThreadInfo();
_en.Name = _flowName;
_en.Info.flowName = _flowName;
// 专用线程代理 dict_Threads.Add
_en.Del = new System.Threading.ThreadStart(do_Sub_While); // 实例化代理
_faim3.dict_Threads.Add(_flowName, _en);
#endregion
F_Log.Debug_1("do_New()", string.Format("初始化 流程:{0}", _flowName));
return(0);
}
public frmCaseStep_06(clsFaim3 v_faim3, DAL_CommData v_dao_comm, F_ThManager v_bo_ThreadMana)
{
_faim3 = v_faim3;
_dao_comm = v_dao_comm;
_dao_comm.OnEchoIO += new F_Delegate.delEcho(_dao_comm_OnEchoIO);
_bo_ThreadMana = v_bo_ThreadMana;
CheckForIllegalCrossThreadCalls = false;
InitializeComponent();
}
public clsFlowWhile(clsFaim3 v_faim3, DAL_CommData v_dao_comm, string vflowName)
{
base.do_New(v_faim3, v_dao_comm, vflowName);
if (!_faim3.dict_Flow.ContainsKey(vflowName))
{
FACC.F_Log.Debug_1(this.GetType().Name, "--->>>> 无 流程 " + vflowName);
return;
}
_flow = _faim3.dict_Flow[vflowName];
}
//'直接以值正(1)/负(0)决定输出1/0 _do2_AR(_devNo, 6, eSwitch.On)
internal void doSend(clsFaim3 _faim3, int vDevNo, int vBit, eHL val)
{
int _bit = vBit; //
if (Math.Abs(_bit) < 99 && 99 < _faim3.sect_iDev) // 需要设备号，以调整绝对寻址
{
_bit = vDevNo * _faim3.sect_iDev + Math.Abs(vBit); //
}
_faim3.Comm_Data.bt_out[0][_bit] = ((int)val > 0 ? 1 : 0); //
}
public static void doCreateInstance(clsFaim3 v_faim3, DAL_CommData v_dao_comm, string vflowName)
{
string _fn = F_Const.path_flowDLL + vflowName + ".dll";
string _ns = "F_CaseWhile";
object _obj = null;
if (vflowName == "clsWhile485" || vflowName == "clsWhile74x" || vflowName == "clsWhileTcp")
{
// 命名空间 / 类名 / faim3 / dao / new(形参：用户类名)
_obj = doCreateInstance_byName_Para <object>(
_ns,
vflowName,
v_faim3,
v_dao_comm,
vflowName //
);
}
else
{
#region // flow . do while
// 命名空间 / 类名 / faim3 / dao / new(形参：用户类名)
_obj = doCreateInstance_byName_Para <object>(
_ns,
"clsFlowWhile",
v_faim3,
v_dao_comm,
vflowName // xxx
);
if (_obj == null)
{
FACC.F_Log.Debug_1("clsTool_ASM", string.Format("！！01 未创建对象 :{0}", vflowName));
return;
}
FACC.F_Log.Debug_1("clsTool_ASM", string.Format("加入流程:{0}", vflowName));
// PartA
IDAL_Temp_Part _Idal = null;
_obj = doCreateInstance_byFile <object>(
_fn,
vflowName,
"PartA"
);
_Idal = _obj as IDAL_Temp_Part;
_Idal.do_New(v_faim3, v_dao_comm);
// PartB
FACC.F_Log.Debug_1("clsTool_ASM", string.Format("加入步骤: {0}_PartA", vflowName));
_obj = doCreateInstance_byFile <object>(
_fn, vflowName,
"PartB"
);
_Idal = _obj as IDAL_Temp_Part;
_Idal.do_New(v_faim3, v_dao_comm);
#endregion }
}
FACC.F_Log.Debug_1("clsTool_ASM", string.Format("按钮: 加入步骤: {0}_PartB", vflowName));
}
bool doPartA(clsFaim3 v_faim3, DAL_CommData v_dao_comm, string vflowName)
{
string _cls_Name = "DAL_PartA";
clsLogs _logs = new clsLogs();
clsFlow _flow = v_faim3.dict_Flow[vflowName];
string _currCase = _flow.nextCase;
F_Log.Debug_1(_cls_Name, String.Format("流程:{0}: 步骤:{1}",
vflowName, _currCase));
_flow.alartCase = _currCase;
if (!v_faim3.dict_CaseState.ContainsKey(_currCase))
{
//'A: 步骤.txt 文件中没有注册该步骤参数
_logs.No = v_faim3.dict_CaseState[_currCase].No;
_logs.Name = (_currCase + "_没注册 步骤");
_flow.RunLog.Add(_logs);
F_Log.Debug_1(_cls_Name, string.Format("--->>>> 没注册 流程:{0}: 步骤:{1}", vflowName, _currCase));
return(true);
}
clsCaseState _en_State = v_faim3.dict_CaseState[_currCase];
if ((_en_State.Times > 0)) // 逻辑模型: 执行次数至少有一次, 如 <1, 则不执行AR(), 只执行判断, 以实现流程在等待联动消息的逻辑
{
F_Delegate.delCasePartA_R _doPartA = _dao_comm.dict_Methods.doPartA_R[_currCase]; // 通过代理, 从步骤集中取出一个步骤, 执行其方法()
//
_logs.No = v_faim3.dict_CaseState[_currCase].No;
_logs.Name = _currCase;
_flow.RunLog.Add(_logs);
_doPartA(v_faim3, v_dao_comm);
// AR
// Delay
if ((_en_State.Delay > -1))//
{
Thread.Sleep(_en_State.Delay);
}
//
}
if (string.IsNullOrEmpty(_en_State.No))//逻辑模型: 无BT报警号 检测的步骤, 只执行 AR(), 不执行AR(), 实现两个 AR() 串联（直通）的逻辑
{
doGet_NextCase(_faim3, ref _flow, _currCase);
}
else
{
// 逻辑模型: 无BT报警号 无报警延时, 只执行 AR(), 不执行AR(), 实现两个 AR() 串联（直通）的逻辑
string _testCase = (_currCase + F_Const.fix_CaseT);
if (_flow.nextCase == _flow.currCase)
{
_flow.alartCase = _currCase;
_flow.nextCase = _testCase; // ==> Test 当前流程名 + _T
F_Log.Debug_1(_cls_Name, String.Format("取到 测试步骤名:{0}", _flow.nextCase));
}
}
return(true);
}
public clsWhileTcp(clsFaim3 v_faim3, DAL_CommData v_dao_comm, string vDevNo)
{
_CMD = "";
MaxAxisNum = Convert.ToInt32(v_faim3.dict_KV["cnt_Axis"]);
_devNo = Convert.ToInt32(vDevNo);
_flowName = string.Format("{0}_{1}", v_faim3.dict_DevCards[_devNo].Name, vDevNo);
base.do_New(v_faim3, v_dao_comm, _flowName);
_device = new clsTCP(_faim3, _dao_comm, _devNo);
if (!_dao_comm.dict_DevIo.ContainsKey(_devNo.ToString()))
{
_dao_comm.dict_DevIo.Add(_devNo.ToString(), (IFaimIO)_device);
}
}
// 设备号的来源可能为多个因素
public static void _204C(clsFaim3 _faim3, DAL_CommData _dao_comm, string IfType, string HL, int _devNo)
{
int _ref_1i = _devNo * _faim3.sect_iDev; // 偏移
int _ref_1s = _devNo * _faim3.sect_sDev + _faim3.sect_sDev_start; // 偏移
// 行号为消息
_faim3._sss[_ref_1s + _faim3.snd_sAsc] = IfType; // 命令
int _val_2 = F_TransCalc._Get_Value_2(_faim3, HL); // 文档的值: 数值
_faim3._sss[_ref_1s + _faim3.snd_sLen] = _val_2.ToString(); // 轴号表/行号
_faim3.Comm_Data.bt_out[0][_ref_1i] = -99;
_dao_comm.set_bt_out(_ref_1i, _devNo); // 设备 消息
}
// from : file
static T doCreateInstance <T>(
string vFn, string nsName, string clsName,
clsFaim3 _faim3, string userClassName = "")
{
string _name = nsName + "." + clsName;
string _fn = vFn;
_fn = do_GetFullFileName(_fn);
//if (!_fn.Contains("file://"))
// return default(T);
return(do_CreateInstance <T>(_fn, _name, _faim3, userClassName));
}
static void _do_math(clsFaim3 _faim3, clsDevTestBits _line, int _val_2)
{
int _bit = 0;
if (_faim3._dim_dict.ContainsKey(_line.vName))
{
_bit = _faim3._dim_dict[_line.vName]; // 内存位 自定义名为下标, 分配地址, 寻址
_faim3._dim[_bit] += _val_2; // 直接设置, 无联动 dim[Feeder05] = Value
}
else if (_line.vName.ToUpper().StartsWith("_FAIM3") ||
_line.vName.ToUpper().StartsWith("CLSFAIM3"))
{
int _ls = Convert.ToInt32(F_TransCalc.doGetValue_byName(_faim3, _line.vName));
F_TransCalc.doSetValue_byName(_faim3, _line.vName, _ls + _val_2);
}
}
public bool Part_2(clsFaim3 v_faim3, DAL_CommData v_dao_comm)
{
Part_BT(v_faim3, v_dao_comm);
#region // xls
do_TEST2(v_faim3, v_dao_comm, _flowName, _caseName, ref _bl);
if (_bl)
{
do_PART_C(v_faim3, v_dao_comm, _flowName, _caseName);
}
else
{
NG(v_faim3, v_dao_comm, _flowName, _caseName);
}
#endregion
return(_bl);
}
protected int do_New(clsFaim3 v_faim3, DAL_CommData v_dao_comm)
{
_ret = do_BaseNew(v_faim3, v_dao_comm);
if (_dao_comm.dict_Methods.doCase.ContainsKey(_caseName))
{
FACC.F_Log.Debug_1(_clsName, String.Format("--->>>> 初始化失败-3: {0} 步骤名 已存在", _caseName));
_ret = -3;
}
if (_ret < 0)
{
return(_ret);
}
_dao_comm.dict_Methods.doCase.Add(_caseName, new F_Delegate.delCase(PartA)); //'通用代理1
_dao_comm.dict_Methods.doPartA_R.Add(_caseName, new F_Delegate.delCasePartA_R(Part_1)); //'通用代理2
FACC.F_Log.Debug_1(_clsName, String.Format("初始化 步骤:{0}", _caseName));
return(0);
}
static void _dao_comm_set_arr_str800(clsFaim3 _faim3, DAL_CommData _dao_comm, string _flowName, int caseLineIdx)
{
int _loc = 0;
string _msg = "";
clsFlow _flow = _faim3.dict_Flow[_flowName];
if (!_flow.isStepLine)
{
return; // 是“行步进”调试
}
clsCaseState _caseState = _faim3.dict_CaseState[_flow.alartCase];
_msg = _dao_comm_set_msg(_faim3, _flowName, caseLineIdx, ref _loc);
if (!string.IsNullOrEmpty(_msg))
{
_dao_comm.set_arr_str(_loc + 800, _msg);
}
}
//protected void btOUT(int vDevNo, int vBit)
//{
// doSend(_faim3, vDevNo, vBit, (eHL)(vBit > 0 ? 1 : 0), _sect_iDev);
//}
//'计划中取下一流程名, 用于一步延时后进行下一步
//'直接以值正(1)/负(0)决定输出1/0 _do2_AR(_devNo, 6, eSwitch.On)
//protected void doSend(int vDevNo, int vBit, eHL val)
//{
// btOUT(_faim3, vDevNo, vBit, val, _sect_iDev);
//}
//'直接以位置正(1)/负(0)决定输出1/0 _do2_AR(_devNo, -6)
public static void doGet_NextCase(clsFaim3 _faim3, ref clsFlow _flow, string vCaseName)
{
string _alartCase = _flow.alartCase;
//if (_faim3.dict_CaseState.ContainsKey(_alartCase)) return; //
clsCaseState _caseState = _faim3.dict_CaseState[_alartCase];
if (_flow.dictCases.ContainsKey(vCaseName))
{
_caseState.endMode = eCaseFlag.Next;
_flow.nextCase = _flow.dictCases[vCaseName].nextCase;
}
else// '流程结束
{
F_Log.Debug_1("DAL_Part", String.Format("--->>>> {0} 没有指定下一个步骤名", vCaseName));
_caseState.endMode = eCaseFlag.Exist;
_flow.nextCase = "Free";
}
}
public clsWhile74x(clsFaim3 v_faim3, DAL_CommData v_dao_comm, string vDevNo)
{
_devNo = Convert.ToInt32(vDevNo);
_flowName = string.Format("{0}_{1}", v_faim3.dict_DevCards[_devNo].Name, vDevNo); //[2]
base.do_New(v_faim3, v_dao_comm, _flowName);
if (_flowName.Contains("7432"))
{
_device = new cls7432(_faim3, _dao_comm, _devNo);
}
if (_flowName.Contains("7230"))
{
_device = new cls7230(_faim3, _dao_comm, _devNo);
}
if (!_dao_comm.dict_DevIo.ContainsKey(_devNo.ToString()))
{
_dao_comm.dict_DevIo.Add(_devNo.ToString(), (IFaimIO)_device);
}
}
public clsWhile485(clsFaim3 v_faim3, DAL_CommData v_dao_comm, string vDevNo)
{
_CMD = "";
_cnt_Axis15 = Convert.ToInt32(v_faim3.dict_KV["cnt_Axis"]);
_devNo = Convert.ToInt32(vDevNo);
_flowName = string.Format("{0}_{1}", v_faim3.dict_DevCards[_devNo].Name, _devNo);
base.do_New(v_faim3, v_dao_comm, _flowName);
_device = new cls485(_faim3, _dao_comm, _devNo);
_bo_protocol = new clsProt485(_faim3);
if (!_dao_comm.dict_DevIo.ContainsKey(_devNo.ToString())) // 加功能接口
{
_dao_comm.dict_DevIo.Add(_devNo.ToString(), (IFaimIO)_device);
}
_dao_comm.OnEchoIO += new F_Delegate.delEcho(evt_comm_OnEchoIO); // 加消息
_dict_cmd.Add(_CMD_Read01, "");
_dict_cmd.Add(_CMD_Read08, "");
}
// from : file 命名空间.类名 / faim3 / dao / new(形参：用户类名)
static T do_CreateInstance_byName_Para <T>(string vName, clsFaim3 v_faim3, DAL_CommData v_dao_comm, string userClassName)
{
object obj = null;
Type vT = Type.GetType(vName);
obj = Activator.CreateInstance(
vT,
new object[] { v_faim3, v_dao_comm, userClassName });
T _en = (T)obj;//
if (_en == null)
{
F_Log.Debug_1("clsTool_ASM", string.Format("--->>>> 04 未创建对象_{0} {1}", vName, userClassName));
}
else
{
F_Log.Debug_1("clsTool_ASM", string.Format("成功创建对象_{0}", _en.GetType().Name));
}
return(_en);
}
//1 PartB --> doPartB --> Part_2 -- Part_BT
protected int do_New(clsFaim3 v_faim3, DAL_CommData v_dao_comm)
{
_ret = do_BaseNew(v_faim3, v_dao_comm);
_testName = (_flowName + (_caseFix + F_Const.fix_CaseT));//测试步骤方法名
if (_dao_comm.dict_Methods.doCase.ContainsKey(_testName))
{
FACC.F_Log.Debug_1(_clsName, string.Format("", _testName));
_ret = -30;
}
if (_ret < 0)
{
return(_ret);
}
_dao_comm.dict_Methods.doCase.Add(_testName, new F_Delegate.delCase(PartB)); //'通用代理1
_dao_comm.dict_Methods.doPartB_T.Add(_caseName, new F_Delegate.delCasePartB_T(Part_2)); //'通用代理2
_dao_comm.dict_Methods.doPartB_R.Add(_caseName, new F_Delegate.delCasePartB_R(Part_BR)); //'通用代理3
FACC.F_Log.Debug_1(_clsName, string.Format("初始化 步骤:{0}", _testName));
return(0);
}
// 根据设备名读取设备号 条件：名称 ， 如失败，返回-1
public static int do_GetDevNo(clsFaim3 _faim3, string vName)
{
int _devNo = -1;
string[] _arr = vName.Split('_'); // 204C_3 ==> 204C, 3
if (_arr.Length < 2)
{
return(_devNo);
}
foreach (var item in _faim3.dict_DevCards) // clsDev_Cards.xls
{
// 0.isEnable 1.devNo 2.Name 3.cardType 4.card_num
if (item.Value.devNo.ToString() == _arr[1].ToUpper().Trim() &&
item.Value.Name == _arr[0].ToUpper().Trim())
{
_devNo = item.Value.devNo;
break;
}
}
return(_devNo);
}
static T do_CreateInstance <T>(
string vFn, string vName,
clsFaim3 vFaim3, string userClassName)
{
if (!File.Exists(vFn))
{
return(default(T));
}
byte[] _buf = File.ReadAllBytes(vFn);
Assembly _asm = Assembly.Load(_buf);
//Assembly _asm = Assembly.LoadFrom(vFile);
object obj = null;
if (string.IsNullOrEmpty(userClassName))
{
obj = _asm.CreateInstance(vName, false);
}
else
{
Type vT = Type.GetType(vName);
obj = Activator.CreateInstance(
vT,
new object[] { vFaim3, userClassName });
}
T _en = (T)obj;//
if (_en == null)
{
F_Log.Debug_1("clsTool_ASM", string.Format("!! 未创建对象_{0}", vName));
}
else
{
F_Log.Debug_1("clsTool_ASM", string.Format("成功创建对象_{0}", _en.GetType().Name));
}
return(_en);
}
static void _do_WaitLine(clsFaim3 _faim3, DAL_CommData _dao_comm, string _flowName, eWF_State vStopState, int vCaseLineIdx)
{
#region // 是“行步进”调试
clsFlow _flow = _faim3.dict_Flow[_flowName];
if (!_flow.isStepLine)
{
return; // 是“行步进”调试
}
clsDevTestBits _line = _faim3.lst_DevTestBits[vCaseLineIdx];
if (_line.isDebug == 1) /*#*/ // cfgDev_testBits #
{
if (_faim3.dict_KV["isDebug"] != "1") // 非 debug 状态下，不运行 debug 行 cfgDev_Cards.xls
{
return;
}
}
_flow.caseLineIdx = vCaseLineIdx;
while (_flow.caseLineIdx == vCaseLineIdx)//
{
if (_faim3.isEmergency > 0)
{
break; // 急停
}
if (_flow.eState == eWF_State.End || _flow.eState == eWF_State.Wait)
{
break;
}
if (_flow.eState != vStopState)
{
_flow.eState = vStopState; //
_dao_comm_set_arr_str800(_faim3, _dao_comm, _flowName, vCaseLineIdx); // “行步进”消息 arr_str[0][800 + _flowIdx]
}
System.Threading.Thread.Sleep(100);
}
_flow.eState = eWF_State.Running; //
#endregion
}
static void doCreateInstance(clsFaim3 vFaim3, string vFlowName)
{
string _fn = F_Const.path_flowDLL + vFlowName + ".dll";
object _obj = doCreateInstance <object>(
_fn, "F_FlowTemp", "clsTempSub",
vFaim3,
vFlowName
);
if (_obj == null)
{
return;
}
FACC.F_Log.Debug_1("clsTool_ASM", string.Format("加入流程:{0}", vFlowName));
IDAL_Temp_Part _Idal = null;
_obj = doCreateInstance <object>(
_fn, vFlowName,
"PartA",
vFaim3
);
_Idal = _obj as IDAL_Temp_Part;
_Idal.do_New(vFaim3);
FACC.F_Log.Debug_1("clsTool_ASM", string.Format("加入步骤: {0}_PartA", vFlowName));
_obj = doCreateInstance <object>(
_fn, vFlowName,
"PartB",
vFaim3
);
_Idal = _obj as IDAL_Temp_Part;
_Idal.do_New(vFaim3);
FACC.F_Log.Debug_1("clsTool_ASM", string.Format("按钮: 加入步骤: {0}_PartB", vFlowName));
}
//F_ThManager _bo_ThreadMana = null;
public clsFrm50_BLL(clsFaim3 v_faim3, DAL_CommData v_dao_comm)//, F_ThManager v_bo_ThreadMana)
{
_faim3 = v_faim3;
_dao_comm = v_dao_comm;
//_bo_ThreadMana = v_bo_ThreadMana;
}
