第五章 工作流定义工具的设计与实现（四）

5.7 开发工作流图形定义工具

5.7.5 迁移定义类及迁移对象数组   

    1、迁移定义类文件TransitionClass.cs

    迁移定义类比较简单，只需记录迁移的引出节点、指向节点等信息。

    using System;

    namespace drawtaskbytoolbar
    {
        public class TransitionClass
        {

            //迁移名称
            public string Name;

            //引出迁移的节点名称
            public string FromNode;

            //迁移指向的节点名称
            public string ToNode;

            //空的构造函数

            public TransitionClass()｛｝
        }

    ｝

    2、迁移对象数组类文件TransitionRecords.cs   

    封装了保存前一对象的数组，以及添加、删除迁移对象等操作。   

    using System;
    using System.Collections;
    using System.Windows.Forms;

    namespace drawtaskbytoolbar
    {
        public class TransitionRecords
        {

            //初始化对象数组
            public ArrayList TransitionList=new ArrayList();
            //空的构造函数
            public TransitionRecords()｛｝

            //公共属性(记录迁移元素对象的个数)
            public int Count
            {
                get
                {
                     return TransitionList.Count;
                }
            }

            //添加迁移对象

            public bool AddTransition(TransitionClass transition)
            {
                 TransitionList.Add(transition);
                 return true;
            }

            //删除与给定节点关联（从节点引出或指向节点）的迁移对象

            public bool DeleteTransition(string  nodeName)
            {
                for(int i=0;i<TransitionList.Count;i++)
                {
                    if(((TransitionClass)TransitionList[i]).FromNode == nodeName

                           || ((TransitionClass)TransitionList[i]).ToNode == nodeName)
                    {
                         TransitionList.RemoveAt(i);
                         i=i-1;//删除数组第i个元素，后续元素递补，须从第i个位置重新开始遍历
                    }
                }
                    return true;
            }

            //获取数组中第i个迁移对象
            public TransitionClass GetTransition(int i)
            {
                if(i>=0 & i<Count)
                    return (TransitionClass)TransitionList[i];
                else
                    return null;
            }

            //获取从给定节点引出的迁移对象集合
            public TransitionRecords GetFromNodeTransition(string nodename)
            {

                //定义临时数组
                TransitionRecords temparray=new TransitionRecords();

                //遍历迁移对象数组，找出符合条件的迁移对象并添加到临时数组
                for(int i=0;i<TransitionList.Count;i++)
                {

                     //判断迁移是否是从给定节点引出
                     if(GetTransition(i).FromNode == nodename)
                     temparray.AddTransition(GetTransition(i));
                }
                if(temparray.Count >= 1)
                    return temparray;
                else
                    return null;
           }

           //获取指向给定节点的迁移对象集合
           public TransitionRecords GetToNodeTransition(string nodename)
           {
               TransitionRecords temparray=new TransitionRecords();

               //遍历迁移对象数组，找出符合条件的迁移对象并添加到临时数组
               for(int i=0;i<TransitionList.Count;i++)
               {

                   //判断迁移是否指向给定节点
                   if(GetTransition(i).ToNode == nodename)
                        temparray.AddTransition(GetTransition(i));
               }
               if(temparray.Count >= 1)
                   return temparray;
               else
                   return null;
          }
          //判断两个节点之间是否已经存在一条迁移（两个节点间只能存在一条迁移）
          public bool HasTransitionBetweenTwoNodes(string node1,string node2)
          {

              //遍历迁移数组，判断迁移是否是连接给定的两个节点
              for(int i=0;i<TransitionList.Count;i++)
              {
                 if((GetTransition(i).ToNode == node1 || GetTransition(i).ToNode == node2)

                         & (GetTransition(i).FromNode == node1 || GetTransition(i).FromNode

                               == node2))
                 return true;
              }
              return false;
          }
          //保存迁移
          public bool SaveTransitions(NodeRecords nodearray,int processid)
          {
              //如果在画图时先添加了连接节点，再添加其分支任务节点，由于处理join节点时将迁移数

              //组中与join节点关联的迁移改为了join节点前后的两个任务节点相连（同时设置join节点

              //后继任务节点的过程逻辑属性，以代替join节点的过程逻辑功能），因此可能造成保存了

              //两个相同的迁移。为解决这个问题，一个方法是在保存迁移数组到数据库之前,删除重复

              //的迁移;另一个办法是在修改迁移前应该通过新建迁移对象，复制迁移数组中的对应的迁

              //移属性，然后对新建的迁移对象修改并保存到要保存的savedarray迁移数组中，而不是让

              //新建的迁移对象直接等于（=）原迁移数组的对应对象（这实际上是引用方式，两个对象

              //指针指向同样的数据区），使得修改影响到原来的迁移数组。第二种方式可以保证原来的

              //迁移数组不变,从而保证重绘原流程图时能保持不变.

              //定义要保存到数据库的迁移数组   
              TransitionRecords savedarray=new TransitionRecords();

              //定义临时数组
              TransitionRecords temparray=new TransitionRecords();

              //定义临时节点对象指针
              NodeClass tempnode=null;

              //定义记录节点名称的变量
              string nodename="";

              //遍历节点数组

              for(int i=0;i<nodearray.Count;i++)
              {
                  tempnode=nodearray.GetNode(i);
                  //保存从开始节点引出的迁移
                  if(tempnode.NodeType == nodetypedefine.start)
                      savedarray.AddTransition(GetFromNodeTransition(tempnode.NodeName)

                                   .GetTransition(0));
                  //如果是任务节点
                  if(tempnode.NodeType == nodetypedefine.tasknode)
                  {

                       //定义临时迁移对象
                       TransitionClass temptransition=new TransitionClass();

                       //设置临时迁移对象的FromNode属性为当前节点名称
                       temptransition.FromNode=tempnode.NodeName;

                       //设置临时迁移对象的ToNode属性为以当前节点为起点的迁移所指向的节点（从

                       //任务节点只能引出一条迁移）
                       temptransition.ToNode=GetFromNodeTransition(tempnode.NodeName)

                                                      .GetTransition(0).ToNode;

                       //如果临时迁移对象的目标节点是任务节点，则把迁移添加到要保存的迁移数组
                       if(nodearray.GetNode(temptransition.ToNode).NodeType

                                == nodetypedefine.tasknode)
                       savedarray.AddTransition(temptransition);
                  }
                  //将与逻辑节点关联的迁移重新关联到相关任务节点，并保存到新的迁移数组中

                  //分支节点
                  if(tempnode.NodeType == nodetypedefine.andsplit || tempnode.NodeType ==

                        nodetypedefine.orsplit)
                  {
                       if(tempnode.NodeType == nodetypedefine.andsplit)
                       {

                           //获取并行分支节点的前驱节点（只能是任务节点）名称
                           nodename=GetToNodeTransition(tempnode.NodeName)

                                .GetTransition(0).FromNode;

                           //获取从并行分支接点引出的所有迁移
                           temparray=GetFromNodeTransition(tempnode.NodeName);
                           for(int j=0;j<temparray.Count;j++)
                           {
                              //定义临时对象
                              TransitionClass temptransition=new TransitionClass();

                              //定义对象的ToNode为从并行分支节点引出的第j条迁移指向的任务节点
                              temptransition.ToNode=temparray.GetTransition(j).ToNode;

                              //定义对象的FromNode为并行分支节点的前驱任务节点
                              temptransition.FromNode=nodename;

                              //将临时迁移对象添加到要保存的迁移对象数组
                              savedarray.AddTransition(temptransition);
                           }
                       }
                       //处理选择分支的旁路迁移
                       if(tempnode.NodeType == nodetypedefine.orsplit)
                       {

                           //获取或分支节点的前驱节点（只能是任务节点）名称
                           nodename=GetToNodeTransition(tempnode.NodeName)

                                       .GetTransition(0).FromNode;

                           //获取从或分支接点引出的所有迁移
                           temparray=GetFromNodeTransition(tempnode.NodeName);
                           for(int j=0;j<temparray.Count;j++)
                           {

                              //定义临时对象
                              TransitionClass temptransition=new TransitionClass();

                              //定义对象的ToNode为从或分支节点引出的第j条迁移指向的任务节点
                              temptransition.ToNode=temparray.GetTransition(j).ToNode;

                              //定义对象的FromNode为或分支节点的前驱任务节点
                              temptransition.FromNode=nodename;
                              //如果temptransition指向的节点是或连接节点（旁路）,则还要修改

                              //temptransition的tonode为或连接节点的后继任务节点
                              if(nodearray.GetNode(temptransition.ToNode).NodeType

                                       == nodetypedefine.orjoin)
                              temptransition.ToNode=GetFromNodeTransition(temptransition

                                       .ToNode).GetTransition(0).ToNode;

                              //将临时迁移对象添加到要保存的迁移数组
                              savedarray.AddTransition(temptransition);
                           }
                        }
                   }
                   //连接节点
                   if(tempnode.NodeType == nodetypedefine.andjoin || tempnode.NodeType ==

                            nodetypedefine.orjoin)
                   {

                       //获取连接节点所指向的任务节点名称
                       nodename=GetFromNodeTransition(tempnode.NodeName)

                                       .GetTransition(0).ToNode;
                       //获取指向连接节点的所有迁移
                       temparray=GetToNodeTransition(tempnode.NodeName);
                       for(int j=0;j<temparray.Count;j++)
                       {
                           //如果连接节点的前驱节点不是或分支节点（旁路，因为选择路由的旁路迁

                           //移已在或分支节点处理,这里就不需要再处理了）
                           if(nodearray.GetNode(temparray.GetTransition(j).FromNode)

                                         .NodeType != nodetypedefine.orsplit)
                           {

                               //定义临时迁移对象
                               TransitionClass temptransition=new TransitionClass();

                               //设置临时对象的FromNode为连接节点的第i个前驱任务节点
                               temptransition.FromNode=temparray.GetTransition(j).FromNode;

                               //设置临时对象的ToNode为连接节点的后继任务节点
                               temptransition.ToNode=nodename;

                               //把临时迁移对象添加到要保存的迁移数组
                               savedarray.AddTransition(temptransition);
                           }
                       }
                   }
                   //结束节点
                   if(tempnode.NodeType == nodetypedefine.end)
                      savedarray.AddTransition(GetToNodeTransition(tempnode.NodeName)

                                          .GetTransition(0));
              }//结束遍历节点数组
              //将新的迁移数组各元素保存到数据库中
              string strSql="";
              for(int i=0;i<savedarray.Count;i++)
                  strSql=strSql+"insert into Transition(ProcessID,ToNodeName,FromNodeName)

                       values("+processid.ToString()+",'"+savedarray.GetTransition(i)

                           .ToNode+"','"+savedarray.GetTransition(i).FromNode+"');";
              DataAccess database=new DataAccess();
              if(! database.ExeSQLNonQueryTransaction(strSql))
              {
                   MessageBox.Show("保存节点失败!"+database.BaseSqlErrDes);
                   return false;
              }
              return true;
          }
       }

    }