介绍

相比多线程开发，C#的多进程开发相对麻烦，无法像多线程一样对某个函数直接启动。只能将函数打包成exe文件，再使用process启动exe文件并传参，传入的参数必须序列化为字符串。

过程

1、构建执行函数

因为要将数据分进程处理，所以构建了一个函数，输入参数对象 bundleMerge，执行函数即可运行进程代码。

public static  void createBundle(bundleMerge bm){
    //业务代码
}

2、封装序列化类

输入的参数只能是字符串，因此将参数对象序列化，在序列化过程中使用各种第三方包都报错，最后找到一个序列化帮助类

/// <summary>
    /// 序列化帮助类
    /// </summary>
    public class SerializeHelper
    {
        /// <summary>
        /// 序列obj对象为base64字串
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static string Serialize(object obj)
        {
            if (obj == null)
                return string.Empty;

            try
            {
                var formatter = new BinaryFormatter();
                var stream = new MemoryStream();
                formatter.Serialize(stream, obj);
                stream.Position = 0;
                byte[] buffer = new byte[stream.Length];
                stream.Read(buffer, 0, buffer.Length);
                stream.Close();
                return Convert.ToBase64String(buffer);
            }
            catch (Exception ex)
            {
                throw new Exception(string.Format("序列化{0}失败，原因：{1}", obj, ex.Message));
            }
        }

        /// <summary>
        /// 反序列化字符串到对象
        /// </summary>
        /// <param name="str">要转换为对象的字符串</param>
        /// <returns>反序列化出来的对象</returns>
        public static T Deserialize<T>(string str)
        {
            var obj = default(T);
            if (string.IsNullOrEmpty(str))
                return obj;

            try
            {
                var formatter = new BinaryFormatter();
                byte[] buffer = Convert.FromBase64String(str);
                MemoryStream stream = new MemoryStream(buffer);
                obj = (T)formatter.Deserialize(stream);
                stream.Close();
            }
            catch (Exception ex)
            {
                throw new Exception(string.Format("序列化{0}失败，原因：{1}", obj, ex.Message));
            }
            return obj;
        }
    }

3、构建exe程序

新建一个项目，项目类型修改为应用程序

在项目main函数中使用业务代码和反序列化后的参数作为传入对象：

    public class tiles2bundleEXE
    {

        static void Main(string[] args) {
            // 获取传递的JSON字符串
            string json = args[0];
            // 反序列化JSON字符串为对象
            Console.WriteLine(json);
            bundleMerge bm = SerializeHelper.Deserialize<bundleMerge>(json);
            //bundleMerge bm = JsonConvert.DeserializeObject<bundleMerge>(json);
            // 业务代码
            tiles2bundle.createBundle(bm);
            //执行完成后结束进程
            Environment.Exit(0);

        }
    }

生成解决方案后，得到exe文件

4、多进程帮助类

copy了一个多进程帮助类，用来控制进程数量和创建进程

public class ProcessHelper
    {
        public delegate void countHandler(int i);
        public event countHandler count;

        public  bool processRun(string processPath, List<string> listBundle)
        {
            int maxProcessCount = Environment.ProcessorCount;
            List<Task> taskItems = new List<Task>();
            Queue<string> collectPathItems = new Queue<string>();
            foreach (var item in listBundle)
            {
                collectPathItems.Enqueue(item);
            }
            string exeName = Path.GetFileName(processPath);
            Process[] processItems;
            int cursor = 0;
            while (!(collectPathItems.Count == 0 && taskItems.Count == 0))
            {
                foreach (Task taskItem in new List<Task>(taskItems))
                {
                    if (taskItem.Status == TaskStatus.Canceled || taskItem.Status == TaskStatus.Faulted || taskItem.Status == TaskStatus.RanToCompletion)
                    {
                        taskItems.Remove(taskItem);
                    }
                }
                // 如果collectPathItems.Count == 0,则不会有新的任务被添加进来，因此不需要执行下边其他代码。
                // 而只需要等待上边的任务完成跳出循环即可。
                if (collectPathItems.Count == 0)
                {
                    Thread.Sleep(5 * 1000);
                    continue;
                }
                
                processItems = Process.GetProcessesByName(exeName);
                if (processItems.Length >= maxProcessCount)
                {
                    Thread.Sleep(5 * 1000);
                    continue;
                }
                int dequeueCount = ((maxProcessCount - processItems.Length) > collectPathItems.Count) ? collectPathItems.Count : (maxProcessCount - processItems.Length);
                for (int i = 0; i < dequeueCount; i++)
                {
                    taskItems.Add(Task.Factory.StartNew(
                        (object mystate) =>
                        {
                            Process process = Process.Start(processPath, mystate.ToString());
                            process.WaitForExit();
                            count?.Invoke(0);
                        }
                       , collectPathItems.Dequeue())
                       );
                }
                // sleep 30 seconds...
                Thread.Sleep(5 * 1000);
                cursor++;

            }
            //循环等待进程运行完成
            processItems = Process.GetProcessesByName(exeName);
            while (processItems.Length  != 0)
            {
                Thread.Sleep(10 * 1000);
            }
            return true;
        }
    }

5、在form中使用多进程帮助类和exe对象

//新建一个列表，用来接收序列化后的参数对象
List<string> listPara = new List<string>();
foreach (var item in listBundle)
{
    listPara.Add(SerializeHelper.Serialize(item)   );
}
//将路径指向生成后的exe文件
string exePath = Environment.CurrentDirectory + "\\tiles2bundle.exe";
ProcessHelper ph = new ProcessHelper();
ph.count += new ProcessHelper.countHandler(ProcessChanged);
//使用帮助类运行
ph.processRun(exePath, listPara);

总结

在c#中构建一个多进程程序比较麻烦，不如python中直接pool.starmap启动进程池方便。