实现标记datagridview标题并导出Excel的功能

最近在学习winform，国庆前被布置了一个小任务，好不容易大致做出来了，决定记录下来，以此加深印象。

先说下需求：这是一个导入话单标记后并导出的功能

1. 选择excel文件

2. 定义字段
   日期 时间 对方号码 通话时长 呼叫类型
3. 点击datagridview 标题 出现下拉菜单 显示定义的字段
4. 标记定义字段列
5. 保存定义字段数据 到 datatable
6  导出datatable

按照需求一步一步来，先设计界面，需要一个DataGridView和两个Button，一个导入，一个导出，我加了个Label和TextBox来提示文件路径。

先在类里面定义几个全局变量，下面的代码中会用到。

         int colIndex;//点击的单元格列索引
         int rowIndex;//点击的单元格行索引
         Dictionary<int, string> dic = new Dictionary<int, string>();//存放excel标题
         List<string> list = new List<string>();    //存放标记后的标题
         DataTable dt;//导入的table
         string filename = "";//Excel文件名

第一步：导入Excel预览，我从网上找了一段excel导入datagridview的代码，具体如下:

         private DataTable ExcelToDataTable(string path)
         {

             FileStream fs = File.OpenRead(path);   //打开.xls文件

             HSSFWorkbook wk = new HSSFWorkbook(fs);   //把xls文件中的数据写入wk中

             var sheet = wk.GetSheetAt();   //提取第一个sheet
             var headerRow = sheet.GetRow();//提取sheet第一行
             var cellCount = headerRow.LastCellNum;//提取行的最后一列
             DataTable table = new DataTable();
             //给table添加一个列
             for (int i = headerRow.FirstCellNum; i < cellCount; i++)
             {
                 DataColumn col = new DataColumn(headerRow.GetCell(i).StringCellValue);
                 table.Columns.Add(col);
             }
             //获取sheet的行数
             var rowCount = sheet.LastRowNum;
             //循环逐行将sheet中数据写入table
             for (int i = (sheet.FirstRowNum + ); i < rowCount; i++)
             {
                 var row = sheet.GetRow(i);
                 DataRow datarow = table.NewRow();
                 for (int j = row.FirstCellNum; j < cellCount; j++)
                 {
                     if (row.GetCell(j) != null)
                     {
                         datarow[j] = row.GetCell(j).ToString();
                     }
                 }
                 table.Rows.Add(datarow);
             }
             wk = null;
             sheet = null;
             return table;
         }

导入方法

这是个导入的方法，双击导入按钮，在事件里添加如下代码：

         private void btnImport_Click(object sender, EventArgs e)
         {
             OpenFileDialog ofd = new OpenFileDialog();
             ofd.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
             ofd.Filter = "Excel Files(*.xls)|*.xls";
             if (ofd.ShowDialog() != DialogResult.OK)
             { return; }
             filename = ofd.FileName;
             textBox1.Text = ofd.FileName;
             dt = ExcelToDataTable(filename);
             dataGridView1.DataSource = dt;//ExcelToDataTable(ofd.FileName);

             int ColCount = dataGridView1.Columns.Count;
             //将Excel所有标题存入dic中
             for (int i = ; i < ColCount; i++)
             {
                 dic.Add(i, dataGridView1.Columns[i].HeaderText);
             }
         }

导入预览

为了方便我将测试的Excel文档放到桌面，Excel的标题我存到了字典里，下面会用到。

到这里基本实现了第一步，点击导入按钮，选中excel文件，显示在datagridview上预览。

第二步、第三步：要求的样式大概是这样：

aaarticlea/png;base64,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" alt="" />

点击datagridview的标题，弹出下拉菜单，显示定义的字段。因此添加一个ContextMenuStrip控件，将字段一个个添加进去。

要求点击标题弹出下拉菜单，我用到了datagridview的CellCilck事件，这个事件里代码非常简单，只要弹出contexmenustrip就行了，然后加一个对是否为标题行的判断。

  private void dataGridView1_CellClick(object sender, DataGridViewCellEventArgs e)
         {
             colIndex = e.ColumnIndex;//获取选中列
             rowIndex = e.RowIndex;
             if (e.RowIndex != -)//只允许设置标题行
             { return; }
             contextMenuStrip1.Show(MousePosition.X, MousePosition.Y);
             //获取点击的标题内容
             // title = dataGridView1.Columns[e.ColumnIndex].HeaderText;
         }

Cell_Click

第四步比较复杂，大概思路是，下拉菜单的选项是固定的，通过contextMenuStrip1_ItemClicked事件里的e.ItemClicked.Text可以获取到你选择的菜单，因此我用了switch case语句来进行判断。

首先是点击datagridview一列的标题，然后选中一个菜单，这一列的标题要变成e.itemClicked,并且标记这一列，所以我写了一个标记的方法表示标记后操作和样式。

         private void Mark(string item)
         {
             dt.Columns[colIndex].ColumnName = item;
             dataGridView1.Columns[colIndex].HeaderText = item;
             dataGridView1.Columns[colIndex].DefaultCellStyle.BackColor = Color.LightSteelBlue;
             dataGridView1.EnableHeadersVisualStyles = false;
             dataGridView1.Columns[colIndex].HeaderCell.Style.BackColor = Color.LightSlateGray;
         }

Mark

因为涉及到匹配的问题，例如日期格式的列无法标记成“呼叫类型”，“通话时间”等，所以加了一些正则判断，正则表达式以前从没用过，也是网上现学的，写得比较差。

又写了一个判断后的方法：

  private void MatchItem(string match, string str, string item)
         {
             Match m = Regex.Match(match, str);
             if (m.Success)
             {
                 Mark(item);
                 //如果该列已标记，则不添加item到list
                 foreach (var i in list)
                 {
                     if (item == i)
                         return;
                 }
                 list.Add(item);
             }
             else
             {
                 contextMenuStrip1.Hide();
                 MessageBox.Show("该列不为" + item + "！");
             }
         }

判断格式

至于contextmenustrip_itemClicked事件里只要在每个case里调用MatchItem方法就可以了。

   private void contextMenuStrip1_ItemClicked(object sender, ToolStripItemClickedEventArgs e)
         {
             //dt = ExcelToDataTable(filename);
             //获取想要标记的的标题
             string item = e.ClickedItem.Text;
             //获取用于判断的内容
             var BeMatch = dataGridView1.Rows[rowIndex + ].Cells[colIndex].Value.ToString();
             //当前列在table是否已经存在
             int i = ;
             foreach (DataColumn dataCol in dt.Columns)
             {
                 if (i != colIndex && dataCol.ColumnName == item)
                 {
                     contextMenuStrip1.Hide();
                     var index = i + ;
                     MessageBox.Show("该表第" + index + "列为" + dataCol.ColumnName + "，无法标记");
                     return;
                 }
                 i++;
             }

             switch (item)
             {
                 case "呼叫类型":
                     {
                         string strType = @"[\u4e00-\u9fbb]";
                         MatchItem(BeMatch, strType, item);
                     }
                     break;
                 case "对方号码":
                     {
                         string strNum = @"0?[1]+[358]+\d{9}";
                         MatchItem(BeMatch, strNum, item);
                     }
                     break;
                 case "日期":
                     {
                         string strDate = @"^2\d{7}$";
                         MatchItem(BeMatch, strDate, item);
                     }
                     break;
                 case "时间":
                     {
                         string strTime = @"^[0-2]\d{1}[0-5]\d{1}[0-5]\d{1}$";
                         MatchItem(BeMatch, strTime, item);
                     }
                     break;
                 case "通话时长":
                     {
                         string strOften = @"\d";
                         MatchItem(BeMatch, strOften, item);
                     }
                     break;
                 case "取消设置":
                     {
                         //遍历原标题，获取取消设置的列，移出dt
                         foreach (var kv in dic)
                         {
                             if (kv.Key == colIndex)
                             {
                                 list.Remove(dataGridView1.Columns[colIndex].HeaderText);
                                 //list.Insert(colIndex,kv.Value);
                                 item = kv.Value;
                                 dt.Columns[colIndex].ColumnName = item;
                             }
                         }
                         //还原标题和样式
                         dataGridView1.Columns[colIndex].DefaultCellStyle.BackColor = Color.White;
                         dataGridView1.Columns[colIndex].HeaderCell.Style.BackColor = DefaultBackColor;
                     }
                     break;
             }
         }

标记列

第五步 ：保存标记后的字段数据到datatable里，我在网上找了一个方法，附上链接：http://www.jb51.net/article/80620.htm

  public bool DataToExcel(DataTable dgv, string FileName, string tableName, bool IsWriteRowHeader)
         {
             if (dgv == null || dgv.Rows.Count <=  || dgv.Columns.Count <= )
             { throw new Exception("请确认表格中有数据"); }

             HSSFWorkbook workbook = new HSSFWorkbook();
             MemoryStream ms = new MemoryStream();
             try
             {
                 // 表单名
                 var sheet = workbook.CreateSheet(tableName);

                 //DataGridView行数
                 int rowCount = dgv.Rows.Count;
                 //DataGridView列数
                 int colCount = ;
                 foreach (DataColumn item in dgv.Columns)
                 {
                     if (item.ColumnName != "地图" && item.ColumnName != "详细" && item.ColumnName != "")
                     { colCount++; }
                 }

                 var font = workbook.CreateFont();
                 font.Boldweight = (short)NPOI.SS.UserModel.FontBoldWeight.BOLD;
                 font.FontHeightInPoints = ;

                 var font1 = workbook.CreateFont();
                 font1.Boldweight = (short)NPOI.SS.UserModel.FontBoldWeight.BOLD;
                 font1.FontHeightInPoints = ;

                 //数据表格样式
                 var dataStyle = workbook.CreateCellStyle();
                 dataStyle.BorderBottom = NPOI.SS.UserModel.BorderStyle.THIN;
                 dataStyle.BorderLeft = NPOI.SS.UserModel.BorderStyle.THIN;
                 dataStyle.BorderTop = NPOI.SS.UserModel.BorderStyle.THIN;
                 dataStyle.BorderRight = NPOI.SS.UserModel.BorderStyle.THIN;
                 dataStyle.Alignment = NPOI.SS.UserModel.HorizontalAlignment.CENTER;
                 dataStyle.VerticalAlignment = VerticalAlignment.CENTER;
                 dataStyle.WrapText = true;

                 var dataStyle1 = workbook.CreateCellStyle();
                 dataStyle1.BorderBottom = NPOI.SS.UserModel.BorderStyle.THIN;
                 dataStyle1.BorderLeft = NPOI.SS.UserModel.BorderStyle.THIN;
                 dataStyle1.BorderTop = NPOI.SS.UserModel.BorderStyle.THIN;
                 dataStyle1.BorderRight = NPOI.SS.UserModel.BorderStyle.THIN;
                 dataStyle1.Alignment = NPOI.SS.UserModel.HorizontalAlignment.LEFT;
                 dataStyle1.VerticalAlignment = VerticalAlignment.CENTER;
                 dataStyle1.WrapText = true;

                 //标题表格样式
                 var cellTitleStyle = workbook.CreateCellStyle();
                 cellTitleStyle.BorderBottom = NPOI.SS.UserModel.BorderStyle.THIN;
                 cellTitleStyle.BorderLeft = NPOI.SS.UserModel.BorderStyle.THIN;
                 cellTitleStyle.BorderTop = NPOI.SS.UserModel.BorderStyle.THIN;
                 cellTitleStyle.BorderRight = NPOI.SS.UserModel.BorderStyle.THIN;
                 cellTitleStyle.SetFont(font1);
                 cellTitleStyle.Alignment = NPOI.SS.UserModel.HorizontalAlignment.CENTER;
                 cellTitleStyle.VerticalAlignment = VerticalAlignment.CENTER;
                 cellTitleStyle.WrapText = true;

                 //标题表格样式
                 var cellTitleStyle1 = workbook.CreateCellStyle();
                 cellTitleStyle1.BorderBottom = NPOI.SS.UserModel.BorderStyle.THIN;
                 cellTitleStyle1.BorderLeft = NPOI.SS.UserModel.BorderStyle.THIN;
                 cellTitleStyle1.BorderTop = NPOI.SS.UserModel.BorderStyle.THIN;
                 cellTitleStyle1.BorderRight = NPOI.SS.UserModel.BorderStyle.THIN;
                 cellTitleStyle1.SetFont(font1);
                 cellTitleStyle1.Alignment = NPOI.SS.UserModel.HorizontalAlignment.LEFT;
                 cellTitleStyle1.VerticalAlignment = VerticalAlignment.CENTER;
                 cellTitleStyle1.WrapText = true;

                 //标题表格样式
                 var titleStyle = workbook.CreateCellStyle();
                 titleStyle.BorderBottom = NPOI.SS.UserModel.BorderStyle.THIN;
                 titleStyle.BorderLeft = NPOI.SS.UserModel.BorderStyle.THIN;
                 titleStyle.BorderTop = NPOI.SS.UserModel.BorderStyle.THIN;
                 titleStyle.BorderRight = NPOI.SS.UserModel.BorderStyle.THIN;
                 titleStyle.SetFont(font);
                 titleStyle.Alignment = NPOI.SS.UserModel.HorizontalAlignment.CENTER;
                 titleStyle.VerticalAlignment = VerticalAlignment.CENTER;
                 titleStyle.WrapText = true;

                 //数据表标题
                 NPOI.SS.Util.CellRangeAddress rangTitle = new NPOI.SS.Util.CellRangeAddress(, , , colCount - );
                 sheet.AddMergedRegion(rangTitle);
                 var titleCel = sheet.CreateRow().CreateCell();
                 titleCel.SetCellValue(tableName);
                 titleCel.CellStyle = titleStyle;
                 sheet.GetRow().HeightInPoints = ;

                 //数据表列头
                 var colNameRow = sheet.CreateRow();
                 for (int i = ; i < dgv.Columns.Count; i++)
                 {
                     if (dgv.Columns[i].ColumnName != "地图" && dgv.Columns[i].ColumnName != "详细" && dgv.Columns[i].ColumnName != "")
                     {
                         //把表头存入
                         var cel = colNameRow.CreateCell(colNameRow.Cells.Count);
                         cel.SetCellValue(dgv.Columns[i].ColumnName.ToString());

                         if (dgv.Columns[i].ColumnName.ToString() == "通话地址")
                         {
                             cel.CellStyle = cellTitleStyle1;
                             sheet.SetColumnWidth(colNameRow.Cells.Count - ,  *  * );
                         }
                         else if (dgv.Columns[i].ColumnName.ToString() == "姓名" || dgv.Columns[i].ColumnName.ToString() == "日期")
                         {
                             cel.CellStyle = cellTitleStyle;
                             sheet.SetColumnWidth(colNameRow.Cells.Count - ,  *  *  * );
                         }
                         else
                         {
                             cel.CellStyle = cellTitleStyle;
                             sheet.SetColumnWidth(colNameRow.Cells.Count - , dgv.Columns[i].ColumnName.ToString().Length *  * );
                         }
                     }
                 }

                 //数据表数据
                 for (int j = ; j < rowCount; j++)
                 {
                     var dataRow = sheet.CreateRow(j + );
                     var col_index = ;
                     for (int k = ; k < dgv.Columns.Count; k++)
                     {
                         if (dgv.Columns[k].ColumnName != "地图" && dgv.Columns[k].ColumnName != "详细" && dgv.Columns[k].ColumnName != "")
                         {
                             //把数据保存到二维数组
                             var cel = dataRow.CreateCell(col_index++);
                             cel.SetCellValue(dgv.Rows[j][k] == null ? "" : dgv.Rows[j][k].ToString());

                             if (dgv.Columns[k].ColumnName.ToString() == "通话地址")
                             {
                                 cel.CellStyle = dataStyle1;
                             }
                             else
                             {
                                 cel.CellStyle = dataStyle;
                             }
                         }
                     }
                 }
                 workbook.Write(ms);
                 FileStream file = new FileStream(FileName, FileMode.Create);
                 workbook.Write(file);
                 file.Close();
                 workbook = null;
                 ms.Close();
                 ms.Dispose();
                 return true;
             }
             catch (Exception ex)
             {
                 workbook = null;
                 ms.Close();
                 ms.Dispose();
                 throw ex;
             }
         }

DataToExcel

    private void btnExport_Click(object sender, EventArgs e)
         {
             //添加标记的列到table
             DataTable table = dt.DefaultView.ToTable(false, list.ToArray());

             try
             {
                 SaveFileDialog sfd = new SaveFileDialog();
                 //sfd.FileName = "测试导出.xls";
                 sfd.Filter = "Excel Files(*.xls)|*.xls";
                 sfd.FileName = "测试导出";
                 if (sfd.ShowDialog() == DialogResult.OK)
                 {
                     filename = sfd.FileName;
                     DataToExcel(table, filename, "话单", false);
                 }
             }
             catch (Exception ex)
             {
                 MessageBox.Show(ex.Message);
             }

导出标记后的列

做完运行的效果是这样的：

aaarticlea/png;base64,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" alt="" />

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAY0AAAGOCAIAAADkUcgoAAAgAElEQVR4nO2dTZIct5WA80yz7KtMhJd9Dh+h917PDUZNS6KGLVJNUhQpSnaMZbvlUIR/RHk3oQtgFtWsRAEPD0gABbzu/L7AopiJvy5UfXwAsx+XH35+T5lbbm9vp8+B8gMLYabc3t7+3ynLf/7Xf1AoFIq1gqcoFIr1cuuBpygUisXiPBYHAGAGPAUA1sFTAGAdPAUA1sFTAGAdPAUA1sFTAGAdPAUA1sFTAGAdPAUA1sFTkOf6clkuru5y1e6uLpZFr3l9uSzL5bXYMLoMcA+eggLuDRSb5P5GQNZUp10dOylwIewSPAVFnMZK97JZluXi6vrqYptiPjb+qKrDn4mmIA2egjIyIdWWUOikxd3VBYEUZMBT0Eihp9YQLAfSghA8BY1s89Qajx0ueO22B2awF/AUbEM+ORcIdojRvhFPQTF4CtIIToo1UqiXWr8B4CkoJG2jbZ7KxlN4CmLwFBSBp2AieAqKaPZU8b/34SmIwFNQRGgjVTuStPj3PqgHT0ERsqfEf9MrNE3kqZMbRFXggaegiFpPlT/eyQ4QkuApKGJV0N3VxbJcXp4vngIIwVNQxMnjTxdXd2fc9wGE4CkoYt2/Hdyk7OfwFPQGT0EZQQAlWmbTE1B4CorBU1BFct9XLB7STkExeAoArIOnAMA6eAoArIOnAMA6eAoArIOnAMA6eAoAHgC3t7fBFTwFAFY4BlNBSLUENygUCmVKwVMUCsV6WZZQR7cfwVMUCsVE0eKpgXtPkFkWVsEELMR0jHrKzxGytVVLhcb++2L561GSizOuH79+EBiZba+Pd/mqWSOe3oTptr9fYsPUN0Sp7PO73/3uWHPwQlr+0OhvRaGnHsqXxMjESt6iljrZttO9NsdTqR9Yfx/9+suy/OY3vylsKL7YVHnwwhj5eojob4W4oAH+XwDZDucyeNF99I+3+MaKxK1SQ+v9l/RzPuLhxnnKnb4d8fVUfZfzVOMqZudzbgZ/CDahvxX6Z1p8P8d/6MuZNbHDxzv7iT1WLpxn+Xch7nnuksXDTfDU4YWyzxLrl8RTTlqbkjpB/cELM/hDsAn9rYjvip/vuR/6cmZNrPzjnb3bOA08lfSU8lnf6imxYeotVirjqSN1ngpWVrxokMGLnvqwbX3P+84n/uP4JYuHm+Op4Hq2vu+p1Gc99c6Wj5Kd2Jkw+711ZXvquH7weu6Hvpzx30b/PVQ+kKlW+ipsWrut9c9KPNC08ynlXQjqu9MN/BdffJF6i7MTEK/odwcwcqyt1L2xwZrq77Ydxk8s/iQH/+yQbSJeKb/r14kXa2s/vYgHejDx1KbPevVKB1+wMZj93rqu51NT3ttNzPKU/4719VT5u42nwo9pcL2k/nKGf++LR+zz027H7PfWdfVUSYdzGTyx1CdTeYvEW4XfI/27ECxWQNaefRGmN2bU+PMa/zFbP9vQv1tep3Ahz8fIsbZS8jYGf9Tfz8Hv7SYGT2zr9yJ1a+tbqndS96XrizC9MQOLVP/khQtZ3v/cL4/Z763rd/axqcksqif244c//fD37/1SMlbqg7rVFB09Ffyl0jJKC4/ZU+JbrLzvXWbSBbPfW7c98Ay+fql/9Bj6MxSzaWI/fviTXwJP6c7S3wTl411eX0HvH0+dzKPQIErzuLfscPHo5d/A82H2e+uq9n2pCuPf2K2UTyyQlO6pkvDqOAHxLdLdUT7tuvd//KrFYxn9xOwKs9/bvVGyELGhSjy1yVYgeAoACrl5dZMqTz65Limzf4IHw+0p/E0+n+W3i19mT2e/6AuhSKrcU08+uZ7yoz0sFvZ9BkFSRqiW1CZPFarqxSmbfpCnnz8Nyqbm07HoqXhOja30DpfohLJi9L4gKSNUS6qLp15sIW4euylV6t6ckeKz6CmXloW/Xw2qPT5PjR717uri/q29uLo7Xr2+vL94GX2Zri/9mseK2ebiQPHFtcMl7mMMqYXo7qknn1wHP/8mSR3w37xySR1K/D6vC/Lxkt7DzbMbv2xY+pKFsOmpFMfp6p4KP98R2T7jaiOZEUldXx4/UKcvDx8o79paf/203V1dHG9nmosv5fsrd1cXGz/ZXaiWVIWnnnxyfeecu7t68sl1haSObDXUSUzkvc/XlyfLkG0beOrm2U3Z0pcthB1PlWil0FNxz/q4QZ9x54OZMPRJbOTrRTDR4S/Fi8vLhDvU5uJA8uhHJllKWohCSdV5yjl3eDHLU08/f+ot2P3Lwoaxp+4DK33paxfCRDyV+qJWeEqMoYJbvqGCIaYwcWjn3PoZ8qMk74N1d33/N79oj7urC2/nIDQXBtIvbvy7tyODPXUsEz318aTp+nK5uLhYylulPHXz7KZ46TcsxKPyVLCVU/qMw6jdeur68uN+ThdN7Kn70wdpMyh9LteBtIvTgikXLUS5pB60p44bwE1NFE/dPLspWfryhXC79VRcbZ+euru6KBVNWzx1MpBycaamduyp7Sfxuqdunt0c30Zx6TcthHug51Pizi42juIyF0lth54KP0BVnspuG4WB0hc37g86s1tPVZRCT1VIKl4IZz+eSp0oBU1SoVZWZ7PPhtaZDEb6AMnn6F6D7efomyQ182zKOTzV1VM3z27qJBUvhLPvKf+FLqNUaBYbLWu6wUwYOiGdoyYEX/hNvNvi5fW+OFBSebEdh+IvxCZJ4anCg6qKhbi/0rKuvaj4oipN9OgsVW1Xnko/U5l+zvNULt5jgX7NsLk4kD46nnpMnpJWedtC3F/ptcabEGOfIA7K9lBxS59G6ex7M3Fo8MFT3T3VvhD3V+pXFTqBp4yAp/AUJMFTRsBTdj0FADF4qoungiOqcsiTZw7y5BnBXwU81ctTNQvBvs8gSMoIeApPJYnn1NhK73Ax8zjCOgckZQN/Ib75/ptN5dMnT6rLm9evq8uLF7fV5fnN8+pye/uqsNQshEFPuS3Po2eb6Lfiu3Y8NXpU8uRF+AuBp7p4Kv1xUhfCpqdSHKereyp3JCeLye8zrjYS8uQZzJOHp7p4KvFxyi2EHU+VaKXQU3HP+rhBn3Hng5kwNHnyJPyFwFNdPJX8ddHihbi/0mN9W0l9USs8JcZQwS3fUMEQU5g4tHOOPHlH8FR3T6mfh6KFuL/SYXmb6eWpYCun9BmHUbv1FHnyjuApPKUx3lNxtX16ijx5Pniqr6dy8XXRQtxf6bC8VbScT4k7u9g4istcJLUdeoo8eQHHhdgqKTz1aD3lkz1sik+UgiapUCurs9lnQ+tMBkOevBg81ddT2sepbCHWK52WuInGfV9gsdhuQZ9Z0w1mwtDkyZPAU309pX2cyhZivdJrjVuo+KIqTfToLFVtV54iT54InurrKfWx4aKFWK90WuJtiLFPEAdle6i4pU+jdPa9mTg0+OCp3p5qXYj1Sv2qQifwlBHwFJ6CJHjKCHjKrqcAIABPdfFUyxKQJ88c5MkzwnEJ8JS5eKptZaEDSMoIeApPJYnn1NhK73Ax8zjCOgckZQM8hac0UrLw96tBtcfnqdGjkicvojqZJ556nM9PFXKcru6p7Jlcts+42kjIk2ctTx6e6uKp9McptxB2PFWilUJPxT3r4wZ9xp0PZsLQ5MmTOC7E2+/ebi0t/4/D65cvq8vNzfPq8uyLZ9Xl1cvX2cLv9+W3isot31DBEFOYOLRzjjx5R/BUX0/tKF+C/yLrqWArp/QZh1G79RR58o7gKTylMd5TcbV9eoo8eT54Ck+FtJxPiTu72DiKy1wktR16ijx5AXgKT2lkD5viE6WgSSrUyups9tnQOpPBkCcvBk9xjq7RuO8LLBbbLegza7rBTBiaPHkSeKqvp8iTV/NcQmpTWT2HXowfmjx5Iniqr6ce/HOeYuwTxEHZHipu6dMonX1vJg4NPniqt6daF2K9Ur+q0Ak8ZQQ8hacgCZ4yAp6y6ykACMBTXTzVsgTkyTMHefKMcFwCPGUunmpbWegAkjICnsJTSeI5NbbSO1zMPI6wzgFJ2QBP4SmNlCz8/WpQ7fF5avSo5MmLqJYUnnqcz08Vcpyu7in9QC4lJr/PuNpIyJNnKk8enurlKfLkdYinAkPN9NT4ocmTJ3FYCDzVy1P8fl9+q6jc8g0VDDGFiUM758iTdwRP9fXUjvIl+C+yngq2ckqfcRi1W0+RJ+8InsJTGuM9FVfbp6fIk+fT4qnf//cn1eXrBkr+P4VU+fLZl9Xl5e2rbHkMnmo5nxJ3drFxFJe5SGo79BR58gLwFJ7SyB42xSdKQZNUqJXV2eyzoXUmgyFPXgye6uspztGF16nQLDZa1nSDmTA0efIk8FRfT5Enr+a5hNSmsnoOvRg/NHnyRHblqWVZzu2pB/+cpxj7BHFQtoeKW/o0Smffm4lDg8+uPOWcO7+nmhbi5ErLukIX8JQR8BSegiR4ygh4yq6nAMBnJ55azn8+1bIK5MkzB3nyjNCSL+HBeco9rHiqaWGhB0jKCLvy1O35n0uoXwiDnorn1NhK73Ax8zjCOgckZQM8hac0UrLw96tBtcfnqdGjNubJk5uX1yweaCB46rznU8UPURn1VIrjdHVPZc/ksn3G1Uby8PLkaYnuimoWDzSUljx5eEqLpzb+erkhT5VopdBTcc/6uEGfceeDmTB0Y568RKK74pp1CfnOzrKn5xIGempzEgxDnvJJfVErPCXGUMEt31DBEFOYOLRzrjFPXk3NyoHODp46i6e2/zbUI/dUsJVT+ozDqN16qj5PXtC8vGZlApmzg6fO4Kma5cRTyT736anGPHlyepZsTcOeqpMUnkp6qmo1DXmq5XxK3NnFxlFc5iKp7dBTjXnyUjmk8jXx1H48VfWPt4Y85ZM9bIpPlIImqVArq7PZZ0PrTAbTmCcvKamimnUJ+c4OnuruqbpMPQ/PU/4LXUap0Cw2WtZ0g5kwdGOePF0lBTVLBxrLsizvvn9XVz578vvq8vL2trq8evW6urT8HxCvX73OlurEhw/MU3VN9OgsVW1XnmrMk5f5r4uLapYm5BsJnurtqcrEh1Y8JcY+QRyU7aHilj6N0tn3ZuLQ4IOnenuqfiHCK20rCx3AU0bAU3gKkuApI+Apu54CgCN4qqOnWhaCPHnmIE+eEZbf4imr8VTbykIHkJQR8BSeShLPqbGV3uFi5nGEdQ5IygZ4Ck9ppGTh71eDao/PU6NHNZgnb33aalr+KTx1xvMp8uTpZPuMq42EPHnB7buriyn/LzKeOlc8RZ48sWd93KDPuPPBTBjaYJ68E9/NST288O99Z/EUefKkJqngKFBhUHNfnjrBSJ6803hqxs4PT53FU+TJE+vr8VEqjNqtpyzlyft4QDXneApPncNT5MlL1C/xVFxtn56ylCfPM17lr6+2gqf6e4o8eXGHqRdKtSC8msKsoW3lyQsvThAVnurvKfLkpXrQwy4lRpvFlDmYy5N3MmJl3qJG8FR3T5EnL3ydCs1io2VNN5gJQ1vMkxekrWLf9wg8RZ687c8lpDaV1XPoxfihrebJO14kT97j8BR58mqfn1KmUTr73kwcGnzw1Bn+va9yIcIrbSsLHcBTRliW5Y9//mNd+erLL6vLk99/Wl2ePv2f6lLf8unT//3TD9nSshDhlbaVhQ7gKSPgKbueAoAjeKqjp1oWgjx55iBPnhGW3+Ipq/FU28pCB5CUEfAUngqJp5K6WN68pJPFzOMI6xyQlA3wFJ4SEGYjPZN5ILj7+Dw1etRhefKK+1y7lCufnWpJ4anH6alYQAHHav6LlKeyZ3LB0HGfcbWRPOo8eeV9uuvLGXLywFN4SiYQkPjH+LrrEU8FhprpqfFDD8uTV96nu7u6mJTP5SN4Ck8JpHyUqlDiKTGGCm4FQZze4QAmDu2cO2+evA19Xl8uFxf3O785wsJTeEogte/zK/gvsp4KtnKpQZ0URu3WU+fNk1fep/d6Vn50PIWnQuJYRpFRd0/F1fbpqbPnyaty36yECXgKTwnzCIKack+JO7vsLlLpM7VVHMOsoUfkyav01IT8U//617/wFJ4SKImnUidKwU+SCrWyOpt9NrTOZDCj8uRt6FOeySjwFJ6SyUZAhfs+8ZBLMVrWdIOZMPSwPHnlfQaPOgw/ST+3p5xzeKoQi56qC3CUasrJlBJq7cpTw/LklffpTp7znHCIjqfwlIwvDn2zJratuCVOwA++pmBh7wl4Ck+BBp6yAJ7CU6CBpyyAp0x7CgCWZTm3p5Zl2ZunWpaDPHnmIE+eBX799de//v2v1eUvf/6LXpxzqVuvv7qtLm/evK0ub7+pL7/88u9sqV6LhX2fQZCUBfAUnhKIp5K6WN68pJPFzOMI6xyQlAHwFJ6SEWYjPZN5wBU/u/BAPTV61MY8eeszVLnmhTUzD2WdnXN7alku8VQhVjwVCyjgWM1/kfJU3FzsTekzrjaSh5cnz/8NGL15eU0f/Xn383BuT11fLniqECueWodXH0kv9JTYZ/ZuYKiZnho/dGOePLkv9Vf5NtScYanze0opeCrAlqdSPkpVKPGUGEMFt4IgTu9wABOHds415slbc0XpqRHKa87J6YKn8FSC1L7Pr+C/yHoq2MqlBnVSGLVbT9Xnybs/4SpI4VJec1Iw5fAUnhKJYxlFRt09FVfbp6ca8+S57vHUNE3hKTyVmEcQ1JR7StzZZXeRSp+preIYZg3dmCfPBTVzniqqOSHx1D14Ck/JlMRTqROl4CdJhVpZnc0+G1pnMpjGPHlSqw7n6JPOppzDU3gqRTYCKtz3iYdcitGyphvMhKEb8+R5t8XL6/3ymh+rzPov/PAUnpIRT4gKv7RKNeVkSgm1duWpxjx5LpnTTmheXnNqOIWn8FQCXxz6Zk1sW3FLnIAffE3Bwt4T8BSeAg08ZQE8hadAA09ZAE+Z9hQALMuCp7p7qmU5yJNnDvLkWQBPmY6n2hYXOoCkLICn8JRAPJXUxfLmJZ0sZh5HWOeApAyAp/CUjDAb6ZnMA6742YUH6qnRozbmyZObSzXFPsXmx4ozfnXm119//emfP1WXd2++qS6vb19Wl+cvvqoun3/6eXX58OGXbKleCyueigUUcKzmv0h5KnsmFwwd9xlXG8nDy5OXaC7VFPuUXq6/pjznl5HxFJ5KEghI/GN83fWIpwJDzfTU+KEb8+TJzcWMelKfYvNEn8PAU3hKJuWjVIUST4kxVHArCOL0DgcwcWjnXGOevEzN8iQKoadG/wINnsJTMql9n1/Bf5H1VLCVSw3qpDBqt56qz5MXNBdr5jx1Orq/GcRTeMq70ra49cSxjCKj7p6Kq+3TU4158qTkMBs8FTZfD9yvxidOwFN4Sp5HENSUe0rc2WV3kUqfqa3iGGYN3ZgnT5aUK/VUsvn9Tc6n8JR3pW1xmyiJp1InSsFPkgq1sjqbfTa0zmQwjXnyNMuc1FTO5tMmmpGHCk/hKZlsBFS47xMPuRSjZU03mAlDN+bJ0x8cOL0r9Ck29y5OSUOFp/CUjHhCVPilVaopJ1NKqLUrTzXmycv818WhhsI+U821R0fPD57CUzK+OPTNmti24pY4AT/4msLEoeEInsJToIGnLICn8BRo4CkL4CnTngKAZVnwVHdPtSwHefLMQZ48C+Ap0/FU2+JCB5CUBfAUnhKIp5K6WN68pJPFzOMI6xyQlAHwFJ6SEWYjPZN5wBU/u/BAPTV61Ll58tZnqLLNB4Gn8JQwj0BAAcdq/ouUp7JncsHQcZ9xtZHsLk+e/2sxuebDwFN4KkkgIPGP8XXXI54KDDXTU+OHnpsnLzEVqfk48BSekkn5KFWhxFNiDBXcCoI4vcMBTBzaOTc3T56fdSo30Hlp9NR3776tLm+/flNdXnx1W12efvp5dfn55w/ZUr0W5jwl7vv8Cv6LrKeCrVxqUCeFUbv11LQ8efcnXGr6qoHgKTwlEMcyioy6eyqutk9Pzc2T507jKWWgAeApPCXPIwhqyj0l7uyyu0ilz9RWcQyzhp6bJ8+lLuIpPGXEU/djF8RTqROl4CdJhVpZnc0+G1pnMpi5efLkQaWBhoGn8JRMNgIq3PeJh1yK0bKmG8yEoefmyfN6F3rCU3jKoKfqAhylmnIypYRau/LU3Dx5zn9KVB1oJHgKT8n44tA3a2LbilviBPzgawoW9p6Ap/AUaOApC+ApPAUaeMoCeMq0pwBgac6Th6fi0rIc5MkzB3nyLICnTMdTbYsLHUBSFsBTeEognkrqYnnzkk4WM48jrHNAUgbAU3hKRpiN9EzmAVf87MID9dToUcmTdwqewlPCPAIBBRyr+S9SnsqeyQVDx33G1UZCnrxHkCcPTz1CT63Dq4+kF3pK7DN7NzDUTE+NH5o8eRF4Ck/JpHyUqlDiKTGGCm4FQZze4QAmDu2cI0/eATyFp2RS+z6/gv8i66lgK5ca1Elh1G49RZ68A3gKTwnEsYwio+6eiqvt01PkyTuCp/CUPI8gqCn3lLizy+4ilT5TW8UxzBqaPHk+jZ56/+7b6tL0f0B8/aa6PP3saXXZ7//jIHoqdaIU/CSpUCurs9lnQ+tMBkOevAA8hadkshFQ4b5PPORSjJY13WAmDE2evAg8hadkxBOiwi+tUk05mVJCrV15ijx5MXgKT8n44tA3a2LbilviBPzgawoW9p6Ap/AUaOApC+ApPAUaeMoCeMq0pwBgac6Th6fi0rIc5MkzB3nyLICnTMdTbYsLHUBSFsBTeEojnlNjK73DxczjCOsckJQB8BSeypCShb9fdcXPLjxQT40elTx5p+ApPFXJcvp0VcpT2TO5bJ9xtZGQJ+8R5MnDU4/TUyVaKfRU3LM+btBn3PlgJgxNnrwIPIWnMqS+qBWeEmOo4JZvqGCIKUwc2jlHnrwDeApPZejlqWArp/QZh1G79RR58g7gKTyVYbyn4mr79BR58o7gKTwl0HI+Je7sYuMoLnOR1HboKfLk+eApPJUhe9gUnygFTVKhVlZns8+G1pkMhjx5AXgKT2Vo3PcFFovtFvSZNd1gJgxNnrwIPIWnMlR8UZUmenSWqrYrT5EnL6bRU9+/f19dWv4PiDffvK0uL758UV0+/PLvbKleCyueEmOfIA7K9lBxS59G6ex7M3FoOIKn8BRo4CkL4Ck8BRp4ygJ4yrSnAGBpzpOHp+LSshzkyTMHefIsgKdMx1NtiwsdQFIWwFN4SiCeSupiefOSThYzjyOsc0BSBsBTeEpGmI30TOaB4O7j89ToUcflyRMvSgNpfZ4dPIWnhHkEAgo4VvNfpDyVPZMLho77jKuN5HHnyRMvSgMpfY4AT+GpJIGAxD/G112PeCow1ExPjR96XJ684uR5iT6HgafwlEzKR6kKJZ4SY6jgVhDE6R0OYOLQzrnz5smrSp6Hp/BUeKVtcZtI7fv8Cv6LrKeCrVxqUCeFUbv11Hnz5IkXc54S+jw/eKqvp1rWwpCn4lhGkVF3T8XV9umps+fJEy+qA2kZY84JnsJT8jyCoKbcU+LOLruLVPpMbRXHMGvoEXnyxIvpgWZJyuEpPJWiJJ5KnSgFP0kq1MrqbPbZ0DqTwYzKkydeVA7s50jK4Sk8lSIbARXu+8RDLsVoWdMNZsLQA/PkiReFgSalnTqCp/CUjHhCVPilVaopJ1NKqLUrT43NkydeDAfK9Hl+8BSekvHFoW/WxLYVt8QJ+MHXFCzsPQFP4SnQwFMWwFN4CjTwlBG+/+H76vL169fV5dXtbXV5/uJFdfn8s8+ry48//k0vLQsheAoADuCpjp5qXAvy5JmDPHlGwFN246mW7qALSMoIeApPhcRTSV0sb17SyWLmcYR1DkjKBngKTwkIs5GeyTzgip9deKCeGj2qvTx53n8+Kk7g7OApPBXOIxBQwLGa/yLlqeyZXDB03GdcbSTkyTtenCAnDzyFp2QCAYl/jK+7HvFUYKiZnho/tME8ee7u6mLm7804PIWnRFI+SlUo8ZQYQwW3giBO73AAE4d2zpnJk3d9uVxc3O/85ggLT+EpgdS+z6/gv8h6KtjKpQZ1Uhi1W09ZyZPnVbi7uuB8Ck+dXGnproU4llFk1N1TcbV9espgnryPFyeICk/hKWEeQVBT7ilxZ5fdRSp9praKY5g1tME8eeJUhoGn8JRASTyVOlEKfpJUqJXV2eyzoXUmgzGYJ0+eyUDwFJ4SyEZAhfs+8ZBLMVrWdIOZMLTBPHnBow4zTtLxFJ4SEE+ICr+0SjXlZEoJtXblKYN58tzJc55znqPCU3hKwBeHvlkT21bcEifgB19TsLD3BIen8BQo4Ckj4Ck8BUnwlBHwlF1PAcABPNXRU41rQZ48c5Anzwh4ym481dIddAFJGeHuH3fV5Q/ffV9dvvv2fXVp+X8cnt88ry4fPvyil5aFMOSpeCqpi+XNSzpZzDyOsM4BSdkAT+EpAWE20jOZB1zxswsP1FOjRyVPXgSewlPhPAIBBRyr+S9SnsqeyQVDx33G1UZCnrzjxbl58vAUnpIJBCT+Mb7uesRTgaFmemr80OTJk8BTeEog5aNUhRJPiTFUcCsI4vQOBzBxaOccefKO4Ck8JZDa9/kV/BdZTwVbudSgTgqjdusp8uStc8RTeCocOIplFBl191RcbZ+eIk+eD57CU8I8gqCm3FPizi67i1T6TG0VxzBraPLkhaPiKTwVUxJPpU6Ugp8kFWpldTb7bGidyWDIkxeDp/CUQDYCKtz3iYdcitGyphvMhKHJkyeBp/CUgHhCVPilVaopJ1NKqLUrT5EnTwRP4SkBXxz6Zk1sW3FLnIAffE3Bwt4THJ7CU6CAp4yAp/AUJMFTRsBTdj0FAAfwVEdPNa4FefLMQZ48I+Apu/FUS3fQBSRlBDyFp0LiqaQuljcv6WQx8zjCOgckZQM8hacEhNlIz2QecMXPLjxQT40elTx5EXgKT4XzCAQUcKzmv0h5KnsmFwwd9xlXGwl58o4X5+bJ++mfP1WX92/fVZfXt7nZeGcAAAgBSURBVK+qy/MXX1WXLz5/Wl0+/PJvvbQshBVPrcOrj6QXekrsM3s3MNRMT40fmjx5EngKTwmkfJSqUOIpMYYKbgVBnN7hACYO7ZwjT94RPIWnBFL7Pr+C/yLrqWArlxrUSWHUbj1FnrwjeApPhcSxjCKj7p6Kq+3TU+TJ88FTeEqYRxDUlHtK3Nlld5FKn6mt4hhmDU2evAA8hacESuKp1IlS8JOkQq2szmafDa0zGQx58mLwFJ4SyEZAhfs+8ZBLMVrWdIOZMDR58iTwFJ4SEE+ICr+0SjXlZEoJtXblKfLkieApPCXgi0PfrIltK26JE/CDrylY2HuCw1N4ChTwlBHwFJ6CJHjKCHjKrqcA4ACe6uipxrUgT545yJNnBDxlN55q6Q66gKSMgKfwVEg8ldTF8uYlnSxmHkdY54CkbICn8JSAMBvpmcwDrvjZhQfqqdGjTs6TJ108Dj4pvwuewlPhPAIBBRyr+S9SnsqeyQVDx33G1Uaywzx5wkUvSYL+uPv5wFN4SiYQkPjH+LrrEU8FhprpqfFDT86Tt6HPkeApPCWQ8lGqQomnxBgquBUEcXqHA5g4tHNuQp488WLoKfIl4CnvSkt3jaT2fX4F/0XWU8FWLjWok8Ko3XpqQp488aKfHO/6cpnhqaXhEar3776tLu/efFNdXr56XV2++OyL6vLzh1/00rgQ4ZWW7lqIYxlFRt09FVfbp6fm5MlLXVwP8a+m5J/CU3hKmEcQ1JR7StzZZXeRSp+preIYZg09LU+efvH+xoTzKTyFpwRK4qnUiVLwk6RCrazOZp8NrTMZzNQ8eepFcfQh4Ck8JZCNgAr3feIhl2K0rOkGM2Ho2Xny9D7nnKLjKTwlIp4QFX5plWrKyZQSau3KUwby5AkXtUdHh4Cn8JSALw59sya2rbglTsAPvqZgYe8JDk/hKVDAU0bAU3gKkuApI+Apu54CgCN4qpenGheCPHnmIE+eEZbf4imr8VRLd9AFJGUEPIWnQuKppC6WNy/pZDHzOMI6ByRlAzyFpwSE2UjPZB4I7j4+T40edW6evM3NR4Cn8FQ4j0BAAcdq/ouUp7JncsHQcZ9xtZHsL0/e1uaDwFN4SiYQkPjH+LrrEU8FhprpqfFDz82Tt6X5SBb+vQ9PxaR8lKpQ4ikxhgpuBUGc3uEAJg7tnJuSJ6+8+UjwFJ4SiJURKGarp4KtXGpQJ4VRu/XUzDx55c2HgKfwVEgcyygy6u6puNo+PTU3T96G5kPAU3hKmEcQ1JR7StzZZXeRSp+preIYZg09N0/etuZDwFN4SqAknkqdKAU/SSrUyups9tnQOpPBzM2Tt7n5EFo89fbNm+ryzeuvq8vty1fV5bNPP6suP//8QS+NCxFeaemukWwEVLjvEw+5FKNlTTeYCUPPzZNX0XwIeApPCYgnRIVfWqWacjKlhFq78tTcPHk1zYeAp/CUgC8OfbMmtq24JU7AD76mYGHvCQ5P9fNU+0KEVxp7hHbwlBHwFJ6CJHjKCHjKrqcA4Aie6uKp9oUgT545yJNnhJbfQ8ZT7PseOUjKCHgKT4XEU0ldLG9e0sli5nGEdQ5IygZ4Ck8JCLORnsk8ENx9fJ4aPeqwPHnlA60PVk3LP1WtKjz1CD0VCyjgWM1/kfJU5kSu4Bn3uNpIHnWevOKB/N/UmfQftx8WAk/hqZBAQOIf4+uuRzwVGGqmp8YPPSxP3paBUvMbxmEh8BSeOh270+/3BU1SwVEqiNM7HMDEoZ1z586TVz7QkburiznxFJ7q4aleC3Fypb3TalL7Pr+C/yLrqWArlxrUSWHUbj01KE9e4UD3h1nTfr/P4Sk8dTJwFMsoMuruqbjaPj01LE/ehoGIp/CUEU+JQU25p8SdXXYXqfSZ2iqOYdbQw/LkbRsoefHs4Ck8JVAST6VOlIKfJBVqZXU2+2xonclghuXJ2zxQUGEgeApPCWQjoMJ9n3jIpRgta7rBTBh6WJ688oG8IWdloMJTeEpAPCEq/NIq1ZSTKSXU2pWnhuXJ2zTQ+kDojMMph6fwlIgvDn2zJratuCVOwA++pjBxaPA5LMTf/vG3ivKH776rLu/fvqsuX7/5pro8v3leXc70Pzj4C3Fypb1TaARPGQFP4SlIgqeMgKfsegoAfPBUo6e6rAJ58sxBnjwjHN5/PGUxnmrvFBpBUkbAU3gqJJ5K6mJ585JOFjOPI6xzQFI2wFN4SkCYjfRM5oHg7uPz1OhR5+bJK28+EDyFp8J5BAIKOFbzX6Q8lT2TC4aO+4yrjWR/efLKmw/lsBB4Ck+FBAIS/xhfdz3iqcBQMz01fui5efLKm49l4bkEPBWT8lGqQomnxBgquBUEcXqHA5g4tHNuQp68yuZnB0/hKYHUvs+v4L/IeirYyqUGdVIYtVtPTciTV9V8AGM85ZzDUyULcXKlvdM64lhGkVF3T8XV9umpOXnytjcfwzBPuVNV4SlxIU6utHdaPY8gqCn3lLizy+4ilT5TW8UxzBp6Wp68jc2HMdJTd1cXeEpfiJMr7Z1WUxJPpU6Ugp8kFWpldTb7bGidyWCm5snb0Hwkwzzl//iPzFMdF+LkSpd+68hGQIX7PvGQSzFa1nSDmTD03Dx55c3HMshT0Q+Ip8SFOLnSpd86xBOiwi+tUk05mVJCrV15am6evPLmgxnjqeyP72soyB2Ipybgi0MxSKptxS1xAn7wNYWJQ4PPoHiqDcue6rEIzknfiP8HrFFAPIm1G/YAAAAASUVORK5CYII=" alt="" />

---

到这里基本结束了，运行后没什么大问题，可能有的bug还没有测出来。第一次写博客，写的不好大家见谅，欢迎提出各种意见和建议。谢谢支持！