C#编程笔记（三）

实在睡不着，整理下以前项目的代码。

跟着项目代码来的，可能略琐碎，见谅。贴了较多代码，只为方便自己以后再用的时候查阅。

1、Excel与Datatable的互操作，相互导入导出。

简单地说，Excel的表结构与DataTable，以及包含了DataTable的DataGridView，格式上是一样的，相互导入导出，就是对齐格式，然后从源拷贝ElementItem的内容到目标Item。

>DataGridView中的数据导出至Excel

        // 公用函数 将选定的DataGridView中的内容，输出到Excel表中
        public void DateGridViewExportToExcel(DataGridView dataGridView1)
        {
            //导出到execl  
            try
            {
                //没有数据的话就不往下执行  
                if (dataGridView1.Rows.Count == 0)
                    return;
                //实例化一个Excel.Application对象  
                Microsoft.Office.Interop.Excel.Application excel = new Microsoft.Office.Interop.Excel.Application();

                //让后台执行设置为不可见，为true的话会看到打开一个Excel，然后数据在往里写  
                excel.Visible = false;

                //新增加一个工作簿，Workbook是直接保存，不会弹出保存对话框，加上Application会弹出保存对话框，值为false会报错  
                excel.Application.Workbooks.Add(true);
                //生成Excel中列头名称  
                for (int i = 0; i < dataGridView1.Columns.Count; i++)
                {
                    excel.Cells[1, i + 1] = dataGridView1.Columns[i].HeaderText;
                }
                //把DataGridView当前页的数据保存在Excel中  
                for (int i = 0; i < dataGridView1.Rows.Count - 1; i++)
                {
                    for (int j = 0; j < dataGridView1.Columns.Count; j++)
                    {
                        if (dataGridView1[j, i].ValueType == typeof(string))
                        {
                            excel.Cells[i + 2, j + 1] = "'" + dataGridView1[j, i].Value.ToString();
                        }
                        else
                        {
                            excel.Cells[i + 2, j + 1] = dataGridView1[j, i].Value.ToString();
                        }
                    }
                }

                //自动调整列宽
                excel.Columns.AutoFit();
                //设置禁止弹出保存和覆盖的询问提示框  
                excel.DisplayAlerts = false;
                excel.AlertBeforeOverwriting = false;

                //保存工作簿  
                //excel.Application.Workbooks.Add(true).Save();
                //保存excel文件  
                excel.Save(@".\temp.xls");

                //确保Excel进程关闭  
                excel.Quit();
                excel = null;

            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "错误提示");
            }
        }

>DataTable中的数据导出至Excel

        // 公用函数 将选定DataTable中的内容,输出到Excel表中
        private void DataTableExportToExcel(string msql)
        {
            System.Data.DataTable _table = GetDataTable(msql);
            //导出到execl  
            try
            {
                //没有数据的话就不往下执行  
                if (_table.Rows.Count == 0)
                {
                    MessageBox.Show("表中没有数据");
                    return;
                }
                //实例化一个Excel.Application对象  
                Microsoft.Office.Interop.Excel.Application excel = new Microsoft.Office.Interop.Excel.Application();

                //让后台执行设置为不可见，为true的话会看到打开一个Excel，然后数据在往里写  
                excel.Visible = false;

                //新增加一个工作簿，Workbook是直接保存，不会弹出保存对话框，加上Application会弹出保存对话框，值为false会报错  
                excel.Application.Workbooks.Add(true);
                //生成Excel中列头名称  
                for (int i = 0; i < _table.Columns.Count; i++)
                {
                    excel.Cells[1, i + 1] = _table.Columns[i].ColumnName;
                }
                //把DataGridView当前页的数据保存在Excel中  
                for (int i = 0; i < _table.Rows.Count; i++)
                {
                    for (int j = 0; j < _table.Columns.Count; j++)
                    {
                        if (_table.Columns[j].DataType == typeof(string))
                        {
                            excel.Cells[i + 2, j + 1] = "'" + _table.Rows[i].ItemArray[j].ToString();
                        }
                        else
                        {
                            excel.Cells[i + 2, j + 1] = _table.Rows[i].ItemArray[j].ToString();
                        }
                    }
                }

                //设置禁止弹出保存和覆盖的询问提示框  
                excel.DisplayAlerts = false;
                excel.AlertBeforeOverwriting = false;

                //保存工作簿  
                //excel.Application.Workbooks.Add(true).Save();

                //保存excel文件  
                excel.Save(@".\temp.xls");

                //确保Excel进程关闭  
                excel.Quit();
                excel = null;

                MessageBox.Show("备份完毕");

            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "错误提示");
            }
        }

>Excel中的数据导入至Datatable

        // 公用函数 把Excel数据读入DataTable
        private System.Data.DataTable ExcelToDataTable(string strExcelFileName, string strSheetName)
        {
            string strConn = "Provider=Microsoft.Jet.OLEDB.4.0;" + "Data Source=" + strExcelFileName + ";" + "Extended Properties=Excel 5.0;";
            string strExcel = string.Format("select * from [{0}$]", strSheetName);
            DataSet ds = new DataSet();

            using (OleDbConnection conn = new OleDbConnection(strConn))
            {
                conn.Open();
                OleDbDataAdapter adapter = new OleDbDataAdapter(strExcel, strConn);
                adapter.Fill(ds, strSheetName);
                conn.Close();
            }

            return ds.Tables[strSheetName];
        }

以上对于一般的数据库导入导出Excel表，差不多够用了。

2、ComboBox的数据绑定

            SqlDataAdapter dataAdapter2 = new SqlDataAdapter(msql2, ConfigurationManager.ConnectionStrings["OMHMS_Leader.Properties.Settings.OMHMSConnectionString"].ConnectionString);
            DataSet ds2 = new DataSet();
            dataAdapter2.Fill(ds2);
            this._cbLine.DataSource = ds2.Tables[0].DefaultView;
            this._cbLine.DisplayMember = "Line_Name";

3、数据绑定到DataGridView

自己在做这种报表数据显示的时候，用了较多的DataGridView，积累下来实现了，只传入SQL语句或者存储过程，即可显示指定的数据。以某一个获取员工信息的方法为例。

        // 公用函数 datagridview 数据填充函数
        private void GetData(string selectCommand, BindingSource bd)
        {
            try
            {
                // Specify a connection string. Replace the given value with a 
                // valid connection string for a Northwind SQL Server sample
                // database accessible to your system.

                // Create a new data adapter based on the specified query.
                SqlDataAdapter dataAdapter = new SqlDataAdapter(selectCommand, ConfigurationManager.ConnectionStrings["OMHMS_Leader.Properties.Settings.OMHMSConnectionString"].ConnectionString);

                // Create a command builder to generate SQL update, insert, and
                // delete commands based on selectCommand. These are used to
                // update the database.
                SqlCommandBuilder commandBuilder = new SqlCommandBuilder(dataAdapter);

                // Populate a new data table and bind it to the BindingSource.
                System.Data.DataTable table = new System.Data.DataTable();
                table.Locale = System.Globalization.CultureInfo.InvariantCulture;
                dataAdapter.Fill(table);
                bd.DataSource = table;

            }
            catch (Exception ex)
            {
                MessageBox.Show("出现错误,错误原因为" + ex.Message,
                    "系统提示：", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        private void dGVStaffRefresh()
        {
            string msql = "select Staff_Cid,Staff_Sid,Staff_Name,Staff_Department,Staff_Line,Staff_Process from OMHMS_Staffs";
            BindingSource bs8 = new BindingSource();
            this._dGVStaff.DataSource = bs8;
            GetData(msql, bs8);

            this._dGVStaff.Columns[0].Width = (int)(this._dGVStaff.Width * 0.1);
            this._dGVStaff.Columns[1].Width = (int)(this._dGVStaff.Width * 0.1);
            this._dGVStaff.Columns[2].Width = (int)(this._dGVStaff.Width * 0.2);
            this._dGVStaff.Columns[3].Width = (int)(this._dGVStaff.Width * 0.2);
            this._dGVStaff.Columns[4].Width = (int)(this._dGVStaff.Width * 0.2);
            this._dGVStaff.Columns[5].Width = (int)(this._dGVStaff.Width * 0.2);

            this._dGVStaff.Columns[0].HeaderText = "卡号";
            this._dGVStaff.Columns[1].HeaderText = "工号";
            this._dGVStaff.Columns[2].HeaderText = "姓名";
            this._dGVStaff.Columns[3].HeaderText = "部门";
            this._dGVStaff.Columns[4].HeaderText = "生产线";
            this._dGVStaff.Columns[5].HeaderText = "工序";
        }

4、DataGridView选定后打印数据，可打印到文件或打印机。好久之前的活儿了，不记得从哪里K来的，有见过的劳驾M我，一定附上源链接，先谢过了。

核心的是一个DataGridViewPrinter的类：

    class DataGridViewPrinter
    {
        private DataGridView TheDataGridView; // The DataGridView Control which will be printed
        private PrintDocument ThePrintDocument; // The PrintDocument to be used for printing
        private bool IsCenterOnPage; // Determine if the report will be printed in the Top-Center of the page
        private bool IsWithTitle; // Determine if the page contain title text
        private string TheTitleText; // The title text to be printed in each page (if IsWithTitle is set to true)
        private Font TheTitleFont; // The font to be used with the title text (if IsWithTitle is set to true)
        private Color TheTitleColor; // The color to be used with the title text (if IsWithTitle is set to true)
        private bool IsWithPaging; // Determine if paging is used

        static int CurrentRow; // A static parameter that keep track on which Row (in the DataGridView control) that should be printed

        static int PageNumber;

        private int PageWidth;
        private int PageHeight;
        private int LeftMargin;
        private int TopMargin;
        private int RightMargin;
        private int BottomMargin;

        private float CurrentY; // A parameter that keep track on the y coordinate of the page, so the next object to be printed will start from this y coordinate

        private float RowHeaderHeight;
        private List<float> RowsHeight;
        private List<float> ColumnsWidth;
        private float TheDataGridViewWidth;

        // Maintain a generic list to hold start/stop points for the column printing
        // This will be used for wrapping in situations where the DataGridView will not fit on a single page
        private List<int[]> mColumnPoints;
        private List<float> mColumnPointsWidth;
        private int mColumnPoint;

        // The class constructor
        public DataGridViewPrinter(DataGridView aDataGridView, PrintDocument aPrintDocument, bool CenterOnPage, bool WithTitle, string aTitleText, Font aTitleFont, Color aTitleColor, bool WithPaging)
        {
            TheDataGridView = aDataGridView;
            ThePrintDocument = aPrintDocument;
            IsCenterOnPage = CenterOnPage;
            IsWithTitle = WithTitle;
            TheTitleText = aTitleText;
            TheTitleFont = aTitleFont;
            TheTitleColor = aTitleColor;
            IsWithPaging = WithPaging;

            PageNumber = 0;

            RowsHeight = new List<float>();
            ColumnsWidth = new List<float>();

            mColumnPoints = new List<int[]>();
            mColumnPointsWidth = new List<float>();

            // Claculating the PageWidth and the PageHeight
            if (!ThePrintDocument.DefaultPageSettings.Landscape)
            {
                PageWidth = ThePrintDocument.DefaultPageSettings.PaperSize.Width;
                PageHeight = ThePrintDocument.DefaultPageSettings.PaperSize.Height;
            }
            else
            {
                PageHeight = ThePrintDocument.DefaultPageSettings.PaperSize.Width;
                PageWidth = ThePrintDocument.DefaultPageSettings.PaperSize.Height;
            }

            // Claculating the page margins
            LeftMargin = ThePrintDocument.DefaultPageSettings.Margins.Left;
            TopMargin = ThePrintDocument.DefaultPageSettings.Margins.Top;
            RightMargin = ThePrintDocument.DefaultPageSettings.Margins.Right;
            BottomMargin = ThePrintDocument.DefaultPageSettings.Margins.Bottom;

            // First, the current row to be printed is the first row in the DataGridView control
            CurrentRow = 0;
        }

        // The function that calculate the height of each row (including the header row), the width of each column (according to the longest text in all its cells including the header cell), and the whole DataGridView width
        private void Calculate(Graphics g)
        {
            if (PageNumber == 0) // Just calculate once
            {
                SizeF tmpSize = new SizeF();
                Font tmpFont;
                float tmpWidth;

                TheDataGridViewWidth = 0;
                for (int i = 0; i < TheDataGridView.Columns.Count; i++)
                {
                    tmpFont = TheDataGridView.ColumnHeadersDefaultCellStyle.Font;
                    if (tmpFont == null) // If there is no special HeaderFont style, then use the default DataGridView font style
                        tmpFont = TheDataGridView.DefaultCellStyle.Font;

                    tmpSize = g.MeasureString(TheDataGridView.Columns[i].HeaderText, tmpFont);
                    tmpWidth = tmpSize.Width;
                    RowHeaderHeight = tmpSize.Height;

                    for (int j = 0; j < TheDataGridView.Rows.Count; j++)
                    {
                        tmpFont = TheDataGridView.Rows[j].DefaultCellStyle.Font;
                        if (tmpFont == null) // If the there is no special font style of the CurrentRow, then use the default one associated with the DataGridView control
                            tmpFont = TheDataGridView.DefaultCellStyle.Font;

                        tmpSize = g.MeasureString("Anything", tmpFont);
                        RowsHeight.Add(tmpSize.Height);

                        tmpSize = g.MeasureString(TheDataGridView.Rows[j].Cells[i].EditedFormattedValue.ToString(), tmpFont);
                        if (tmpSize.Width > tmpWidth)
                            tmpWidth = tmpSize.Width;
                    }
                    if (TheDataGridView.Columns[i].Visible)
                        TheDataGridViewWidth += tmpWidth;
                    ColumnsWidth.Add(tmpWidth);
                }

                // Define the start/stop column points based on the page width and the DataGridView Width
                // We will use this to determine the columns which are drawn on each page and how wrapping will be handled
                // By default, the wrapping will occurr such that the maximum number of columns for a page will be determine
                int k;

                int mStartPoint = 0;
                for (k = 0; k < TheDataGridView.Columns.Count; k++)
                    if (TheDataGridView.Columns[k].Visible)
                    {
                        mStartPoint = k;
                        break;
                    }

                int mEndPoint = TheDataGridView.Columns.Count;
                for (k = TheDataGridView.Columns.Count - 1; k >= 0; k--)
                    if (TheDataGridView.Columns[k].Visible)
                    {
                        mEndPoint = k + 1;
                        break;
                    }

                float mTempWidth = TheDataGridViewWidth;
                float mTempPrintArea = (float)PageWidth - (float)LeftMargin - (float)RightMargin;

                // We only care about handling where the total datagridview width is bigger then the print area
                if (TheDataGridViewWidth > mTempPrintArea)
                {
                    mTempWidth = 0.0F;
                    for (k = 0; k < TheDataGridView.Columns.Count; k++)
                    {
                        if (TheDataGridView.Columns[k].Visible)
                        {
                            mTempWidth += ColumnsWidth[k];
                            // If the width is bigger than the page area, then define a new column print range
                            if (mTempWidth > mTempPrintArea)
                            {
                                mTempWidth -= ColumnsWidth[k];
                                mColumnPoints.Add(new int[] { mStartPoint, mEndPoint });
                                mColumnPointsWidth.Add(mTempWidth);
                                mStartPoint = k;
                                mTempWidth = ColumnsWidth[k];
                            }
                        }
                        // Our end point is actually one index above the current index
                        mEndPoint = k + 1;
                    }
                }
                // Add the last set of columns
                mColumnPoints.Add(new int[] { mStartPoint, mEndPoint });
                mColumnPointsWidth.Add(mTempWidth);
                mColumnPoint = 0;
            }
        }

        // The funtion that print the title, page number, and the header row
        private void DrawHeader(Graphics g)
        {
            CurrentY = (float)TopMargin;

            // Printing the page number (if isWithPaging is set to true)
            if (IsWithPaging)
            {
                PageNumber++;
                string PageString = "Page " + PageNumber.ToString();

                StringFormat PageStringFormat = new StringFormat();
                PageStringFormat.Trimming = StringTrimming.Word;
                PageStringFormat.FormatFlags = StringFormatFlags.NoWrap | StringFormatFlags.LineLimit | StringFormatFlags.NoClip;
                PageStringFormat.Alignment = StringAlignment.Far;

                Font PageStringFont = new Font("Tahoma", 8, FontStyle.Regular, GraphicsUnit.Point);

                RectangleF PageStringRectangle = new RectangleF((float)LeftMargin, CurrentY, (float)PageWidth - (float)RightMargin - (float)LeftMargin, g.MeasureString(PageString, PageStringFont).Height);

                g.DrawString(PageString, PageStringFont, new SolidBrush(Color.Black), PageStringRectangle, PageStringFormat);

                CurrentY += g.MeasureString(PageString, PageStringFont).Height;
            }

            // Printing the title (if IsWithTitle is set to true)
            if (IsWithTitle)
            {
                StringFormat TitleFormat = new StringFormat();
                TitleFormat.Trimming = StringTrimming.Word;
                TitleFormat.FormatFlags = StringFormatFlags.NoWrap | StringFormatFlags.LineLimit | StringFormatFlags.NoClip;
                if (IsCenterOnPage)
                    TitleFormat.Alignment = StringAlignment.Center;
                else
                    TitleFormat.Alignment = StringAlignment.Near;

                RectangleF TitleRectangle = new RectangleF((float)LeftMargin, CurrentY, (float)PageWidth - (float)RightMargin - (float)LeftMargin, g.MeasureString(TheTitleText, TheTitleFont).Height);

                g.DrawString(TheTitleText, TheTitleFont, new SolidBrush(TheTitleColor), TitleRectangle, TitleFormat);

                CurrentY += g.MeasureString(TheTitleText, TheTitleFont).Height;
            }

            // Calculating the starting x coordinate that the printing process will start from
            float CurrentX = (float)LeftMargin;
            if (IsCenterOnPage)
                CurrentX += (((float)PageWidth - (float)RightMargin - (float)LeftMargin) - mColumnPointsWidth[mColumnPoint]) / 2.0F;

            // Setting the HeaderFore style
            Color HeaderForeColor = TheDataGridView.ColumnHeadersDefaultCellStyle.ForeColor;
            if (HeaderForeColor.IsEmpty) // If there is no special HeaderFore style, then use the default DataGridView style
                HeaderForeColor = TheDataGridView.DefaultCellStyle.ForeColor;
            SolidBrush HeaderForeBrush = new SolidBrush(HeaderForeColor);

            // Setting the HeaderBack style
            Color HeaderBackColor = TheDataGridView.ColumnHeadersDefaultCellStyle.BackColor;
            if (HeaderBackColor.IsEmpty) // If there is no special HeaderBack style, then use the default DataGridView style
                HeaderBackColor = TheDataGridView.DefaultCellStyle.BackColor;
            SolidBrush HeaderBackBrush = new SolidBrush(HeaderBackColor);

            // Setting the LinePen that will be used to draw lines and rectangles (derived from the GridColor property of the DataGridView control)
            Pen TheLinePen = new Pen(TheDataGridView.GridColor, 1);

            // Setting the HeaderFont style
            Font HeaderFont = TheDataGridView.ColumnHeadersDefaultCellStyle.Font;
            if (HeaderFont == null) // If there is no special HeaderFont style, then use the default DataGridView font style
                HeaderFont = TheDataGridView.DefaultCellStyle.Font;

            // Calculating and drawing the HeaderBounds        
            RectangleF HeaderBounds = new RectangleF(CurrentX, CurrentY, mColumnPointsWidth[mColumnPoint], RowHeaderHeight);
            g.FillRectangle(HeaderBackBrush, HeaderBounds);

            // Setting the format that will be used to print each cell of the header row
            StringFormat CellFormat = new StringFormat();
            CellFormat.Trimming = StringTrimming.Word;
            CellFormat.FormatFlags = StringFormatFlags.NoWrap | StringFormatFlags.LineLimit | StringFormatFlags.NoClip;

            // Printing each visible cell of the header row
            RectangleF CellBounds;
            float ColumnWidth;
            for (int i = (int)mColumnPoints[mColumnPoint].GetValue(0); i < (int)mColumnPoints[mColumnPoint].GetValue(1); i++)
            {
                if (!TheDataGridView.Columns[i].Visible) continue; // If the column is not visible then ignore this iteration

                ColumnWidth = ColumnsWidth[i];

                // Check the CurrentCell alignment and apply it to the CellFormat
                if (TheDataGridView.ColumnHeadersDefaultCellStyle.Alignment.ToString().Contains("Right"))
                    CellFormat.Alignment = StringAlignment.Far;
                else if (TheDataGridView.ColumnHeadersDefaultCellStyle.Alignment.ToString().Contains("Center"))
                    CellFormat.Alignment = StringAlignment.Center;
                else
                    CellFormat.Alignment = StringAlignment.Near;

                CellBounds = new RectangleF(CurrentX, CurrentY, ColumnWidth, RowHeaderHeight);

                // Printing the cell text
                g.DrawString(TheDataGridView.Columns[i].HeaderText, HeaderFont, HeaderForeBrush, CellBounds, CellFormat);

                // Drawing the cell bounds
                if (TheDataGridView.RowHeadersBorderStyle != DataGridViewHeaderBorderStyle.None) // Draw the cell border only if the HeaderBorderStyle is not None
                    g.DrawRectangle(TheLinePen, CurrentX, CurrentY, ColumnWidth, RowHeaderHeight);

                CurrentX += ColumnWidth;
            }

            CurrentY += RowHeaderHeight;
        }

        // The function that print a bunch of rows that fit in one page
        // When it returns true, meaning that there are more rows still not printed, so another PagePrint action is required
        // When it returns false, meaning that all rows are printed (the CureentRow parameter reaches the last row of the DataGridView control) and no further PagePrint action is required
        private bool DrawRows(Graphics g)
        {
            // Setting the LinePen that will be used to draw lines and rectangles (derived from the GridColor property of the DataGridView control)
            Pen TheLinePen = new Pen(TheDataGridView.GridColor, 1);

            // The style paramters that will be used to print each cell
            Font RowFont;
            Color RowForeColor;
            Color RowBackColor;
            SolidBrush RowForeBrush;
            SolidBrush RowBackBrush;
            SolidBrush RowAlternatingBackBrush;

            // Setting the format that will be used to print each cell
            StringFormat CellFormat = new StringFormat();
            CellFormat.Trimming = StringTrimming.Word;
            CellFormat.FormatFlags = StringFormatFlags.NoWrap | StringFormatFlags.LineLimit;

            // Printing each visible cell
            RectangleF RowBounds;
            float CurrentX;
            float ColumnWidth;
            while (CurrentRow < TheDataGridView.Rows.Count)
            {
                if (TheDataGridView.Rows[CurrentRow].Visible) // Print the cells of the CurrentRow only if that row is visible
                {
                    // Setting the row font style
                    RowFont = TheDataGridView.Rows[CurrentRow].DefaultCellStyle.Font;
                    if (RowFont == null) // If the there is no special font style of the CurrentRow, then use the default one associated with the DataGridView control
                        RowFont = TheDataGridView.DefaultCellStyle.Font;

                    // Setting the RowFore style
                    RowForeColor = TheDataGridView.Rows[CurrentRow].DefaultCellStyle.ForeColor;
                    if (RowForeColor.IsEmpty) // If the there is no special RowFore style of the CurrentRow, then use the default one associated with the DataGridView control
                        RowForeColor = TheDataGridView.DefaultCellStyle.ForeColor;
                    RowForeBrush = new SolidBrush(RowForeColor);

                    // Setting the RowBack (for even rows) and the RowAlternatingBack (for odd rows) styles
                    RowBackColor = TheDataGridView.Rows[CurrentRow].DefaultCellStyle.BackColor;
                    if (RowBackColor.IsEmpty) // If the there is no special RowBack style of the CurrentRow, then use the default one associated with the DataGridView control
                    {
                        RowBackBrush = new SolidBrush(TheDataGridView.DefaultCellStyle.BackColor);
                        RowAlternatingBackBrush = new SolidBrush(TheDataGridView.AlternatingRowsDefaultCellStyle.BackColor);
                    }
                    else // If the there is a special RowBack style of the CurrentRow, then use it for both the RowBack and the RowAlternatingBack styles
                    {
                        RowBackBrush = new SolidBrush(RowBackColor);
                        RowAlternatingBackBrush = new SolidBrush(RowBackColor);
                    }

                    // Calculating the starting x coordinate that the printing process will start from
                    CurrentX = (float)LeftMargin;
                    if (IsCenterOnPage)
                        CurrentX += (((float)PageWidth - (float)RightMargin - (float)LeftMargin) - mColumnPointsWidth[mColumnPoint]) / 2.0F;

                    // Calculating the entire CurrentRow bounds                
                    RowBounds = new RectangleF(CurrentX, CurrentY, mColumnPointsWidth[mColumnPoint], RowsHeight[CurrentRow]);

                    // Filling the back of the CurrentRow
                    if (CurrentRow % 2 == 0)
                        g.FillRectangle(RowBackBrush, RowBounds);
                    else
                        g.FillRectangle(RowAlternatingBackBrush, RowBounds);

                    // Printing each visible cell of the CurrentRow                
                    for (int CurrentCell = (int)mColumnPoints[mColumnPoint].GetValue(0); CurrentCell < (int)mColumnPoints[mColumnPoint].GetValue(1); CurrentCell++)
                    {
                        if (!TheDataGridView.Columns[CurrentCell].Visible) continue; // If the cell is belong to invisible column, then ignore this iteration

                        // Check the CurrentCell alignment and apply it to the CellFormat
                        if (TheDataGridView.Columns[CurrentCell].DefaultCellStyle.Alignment.ToString().Contains("Right"))
                            CellFormat.Alignment = StringAlignment.Far;
                        else if (TheDataGridView.Columns[CurrentCell].DefaultCellStyle.Alignment.ToString().Contains("Center"))
                            CellFormat.Alignment = StringAlignment.Center;
                        else
                            CellFormat.Alignment = StringAlignment.Near;

                        ColumnWidth = ColumnsWidth[CurrentCell];
                        RectangleF CellBounds = new RectangleF(CurrentX, CurrentY, ColumnWidth, RowsHeight[CurrentRow]);

                        // Printing the cell text
                        g.DrawString(TheDataGridView.Rows[CurrentRow].Cells[CurrentCell].EditedFormattedValue.ToString(), RowFont, RowForeBrush, CellBounds, CellFormat);

                        // Drawing the cell bounds
                        if (TheDataGridView.CellBorderStyle != DataGridViewCellBorderStyle.None) // Draw the cell border only if the CellBorderStyle is not None
                            g.DrawRectangle(TheLinePen, CurrentX, CurrentY, ColumnWidth, RowsHeight[CurrentRow]);

                        CurrentX += ColumnWidth;
                    }
                    CurrentY += RowsHeight[CurrentRow];

                    // Checking if the CurrentY is exceeds the page boundries
                    // If so then exit the function and returning true meaning another PagePrint action is required
                    if ((int)CurrentY > (PageHeight - TopMargin - BottomMargin))
                    {
                        CurrentRow++;
                        return true;
                    }
                }
                CurrentRow++;
            }

            CurrentRow = 0;
            mColumnPoint++; // Continue to print the next group of columns

            if (mColumnPoint == mColumnPoints.Count) // Which means all columns are printed
            {
                mColumnPoint = 0;
                return false;
            }
            else
                return true;
        }

        // The method that calls all other functions
        public bool DrawDataGridView(Graphics g)
        {
            try
            {
                Calculate(g);
                DrawHeader(g);
                bool bContinue = DrawRows(g);
                return bContinue;
            }
            catch (Exception ex)
            {
                MessageBox.Show("Operation failed: " + ex.Message.ToString(), Application.ProductName + " - Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return false;
            }
        }
    }
}

在使用的时候，需要如下的几个方法：

        // 打印核心方法
        private bool SetupThePrinting(DataGridView _datagridview)
        {
            PrintDialog MyPrintDialog = new PrintDialog();
            MyPrintDialog.AllowCurrentPage = false;
            MyPrintDialog.AllowPrintToFile = false;
            MyPrintDialog.AllowSelection = false;
            MyPrintDialog.AllowSomePages = false;
            MyPrintDialog.PrintToFile = false;
            MyPrintDialog.ShowHelp = false;
            MyPrintDialog.ShowNetwork = false;

            if (MyPrintDialog.ShowDialog() != DialogResult.OK)
                return false;

            MyPrintDocument.DocumentName = "OMH报表";
            MyPrintDocument.PrinterSettings = MyPrintDialog.PrinterSettings;
            MyPrintDocument.DefaultPageSettings = MyPrintDialog.PrinterSettings.DefaultPageSettings;
            MyPrintDocument.DefaultPageSettings.Margins = new Margins(40, 40, 40, 40);

            if (MessageBox.Show("是否要居中打印", "打印设置 - 页面居中", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
                _dGVPrinter = new DataGridViewPrinter(_datagridview, MyPrintDocument, true, true, "OMH 详情", new System.Drawing.Font("宋体", 18, FontStyle.Bold, GraphicsUnit.Point), Color.Black, true);
            else
                _dGVPrinter = new DataGridViewPrinter(_datagridview, MyPrintDocument, false, true, "OMH 详情", new System.Drawing.Font("宋体", 18, FontStyle.Bold, GraphicsUnit.Point), Color.Black, true);

            return true;
        }

        // 打印点击
        private void 打印ToolStripMenuItem_Click(object sender, EventArgs e)
        {

            foreach (Control c in this.Controls)
            {
                if (c is DataGridView && c.Focused == true)
                {
                    // Setting the style of the DataGridView control
                    (c as DataGridView).ColumnHeadersDefaultCellStyle.Font = new System.Drawing.Font("Tahoma", 9, FontStyle.Bold, GraphicsUnit.Point);
                    (c as DataGridView).ColumnHeadersDefaultCellStyle.BackColor = SystemColors.ControlDark;
                    (c as DataGridView).ColumnHeadersBorderStyle = DataGridViewHeaderBorderStyle.Single;
                    (c as DataGridView).ColumnHeadersDefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleCenter;
                    (c as DataGridView).DefaultCellStyle.Font = new System.Drawing.Font("Tahoma", 8, FontStyle.Regular, GraphicsUnit.Point);
                    (c as DataGridView).DefaultCellStyle.BackColor = Color.Empty;
                    (c as DataGridView).AlternatingRowsDefaultCellStyle.BackColor = SystemColors.ControlLight;
                    (c as DataGridView).CellBorderStyle = DataGridViewCellBorderStyle.Single;
                    (c as DataGridView).GridColor = SystemColors.ControlDarkDark;

                    // Binding the DataGridViewControl to the DataSet generated above
                    //(c as DataGridView).DataSource = ds;
                    //(c as DataGridView).DataMember = "dt";

                    // Changing the last column alignment to be in the Right alignment            
                    (c as DataGridView).Columns[(c as DataGridView).Columns.Count - 1].DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleRight;

                    // Adjusting each column to be fit as the content of all its cells, including the header cell
                    (c as DataGridView).AutoResizeColumns(DataGridViewAutoSizeColumnsMode.AllCells);


                    if (SetupThePrinting(c as DataGridView))
                        MyPrintDocument.Print();
                }
            }
        }

        // MyPrintDocument 打印页事件
        private void MyPrintDocument_PrintPage(object sender, System.Drawing.Printing.PrintPageEventArgs e)
        {
            bool more = this._dGVPrinter.DrawDataGridView(e.Graphics);
            if (more == true)
                e.HasMorePages = true;
        }

打印预览的方法：

            foreach (Control c in this.Controls)
            {
                if (c is DataGridView && c.Focused == true)
                {
                    // Setting the style of the DataGridView control
                    (c as DataGridView).ColumnHeadersDefaultCellStyle.Font = new System.Drawing.Font("Tahoma", 9, FontStyle.Bold, GraphicsUnit.Point);
                    (c as DataGridView).ColumnHeadersDefaultCellStyle.BackColor = SystemColors.ControlDark;
                    (c as DataGridView).ColumnHeadersBorderStyle = DataGridViewHeaderBorderStyle.Single;
                    (c as DataGridView).ColumnHeadersDefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleCenter;
                    (c as DataGridView).DefaultCellStyle.Font = new System.Drawing.Font("Tahoma", 8, FontStyle.Regular, GraphicsUnit.Point);
                    (c as DataGridView).DefaultCellStyle.BackColor = Color.Empty;
                    (c as DataGridView).AlternatingRowsDefaultCellStyle.BackColor = SystemColors.ControlLight;
                    (c as DataGridView).CellBorderStyle = DataGridViewCellBorderStyle.Single;
                    (c as DataGridView).GridColor = SystemColors.ControlDarkDark;

                    // Binding the DataGridViewControl to the DataSet generated above
                    //(c as DataGridView).DataSource = ds;
                    //(c as DataGridView).DataMember = "dt";

                    // Changing the last column alignment to be in the Right alignment            
                    (c as DataGridView).Columns[(c as DataGridView).Columns.Count - 1].DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleRight;

                    // Adjusting each column to be fit as the content of all its cells, including the header cell
                    (c as DataGridView).AutoResizeColumns(DataGridViewAutoSizeColumnsMode.AllCells);

                    if (SetupThePrinting(c as DataGridView))
                    {
                        PrintPreviewDialog MyPrintPreviewDialog = new PrintPreviewDialog();
                        MyPrintPreviewDialog.Document = this.MyPrintDocument;
                        MyPrintPreviewDialog.ShowDialog();
                    }
                }
            }

5、ZedGraph实现饼图、柱状图、折线图，这个貌似资料很多了，不贴代码了。

只有一点，一种特殊的柱状图：每个BarItem上再分段的情况，实际是将柱状图的属性设定为Stack，然后分几段，就绑定几个数组。当时为了给客户显示这种，费心不少，后来才发现蛮简单的。

6、C#中DateTime与String的转化。

这个实在项目中遇到的比较头疼的一个问题，DateTime支持各种模式的输出，但是有些时候，计算时间的话，又不要从string转回DateTime，以前写了这样的一个类。现在看来，简直弱爆了。。。唉，纪念下吧，不过从string到DateTime，那些个模式串还是很烦人人，应该还会用到。

    static class DatetimeNString
    {
        // 将表示时间的字符串，转化成DateTime类对象
        public static DateTime ToDateTime(string date)
        {
            string[] DateTimeList = {    
                "yyyy-M-d tt hh:mm:ss",    
                "yyyy-MM-dd tt hh:mm:ss",    
                "yyyy-MM-dd HH:mm:ss",  
                "yyyy-MM-dd HH:m:ss",  
                "yyyy-MM-dd H:mm:ss",  
                "yyyy-M-dd HH:mm:ss",
                "yyyy-M-dd H:mm:ss",
                "yyyy-M-dd HH:m:ss",
                "yyyy-MM-d HH:mm:ss",
                "yyyy-MM-d H:mm:ss",
                "yyyy-MM-d HH:m:ss",
                "yyyy-M-d HH:mm:ss",
                "yyyy-M-d H:mm:ss",
                "yyyy-M-d HH:m:ss",
                "yyyy-MM-dd HH:mm",  
                "yyyy-MM-dd H:mm",
                "yyyy-MM-dd HH:m",
                "yyyy-M-dd HH:mm",
                "yyyy-M-dd H:mm",
                "yyyy-M-dd HH:m",
                "yyyy-MM-d HH:mm",
                "yyyy-MM-d H:mm",
                "yyyy-MM-d HH:m",
                "yyyy-M-d HH:mm",  
                "yyyy-M-d H:mm",
                "yyyy-M-d HH:m",
                "yyyy-M-d",    
                "yyyy-MM-dd",
                "HH:mm:ss",
                "HH:mm;s",
                "HH:m:ss",
                "HH:m:s",
                "H:mm:ss",
                "H:mm;s",
                "H:m:ss",
                "H:m:s",
                "HH:mm",
                "HH:m",
                "H:mm",
                "H:m"
                };
            DateTime dt = DateTime.ParseExact(date, DateTimeList, System.Globalization.CultureInfo.InvariantCulture, System.Globalization.DateTimeStyles.AllowWhiteSpaces);
            return dt;
        }

        // 从DateTime对象中抽取日期
        public static string GetDate(DateTime datetime)
        {
            string date = datetime.Year + "-" + datetime.Month + "-" + datetime.Day;
            return date;
        }

        // 从DateTime对象中抽取时间
        public static string GetTime(DateTime datetime)
        {
            string time = datetime.Hour + ":" + datetime.Minute + ":" + datetime.Second;
            return time;
        }

        public static int TimeCompare(string start, string end)
        {
            return DateTime.Compare(DatetimeNString.ToDateTime(start), DatetimeNString.ToDateTime(end));
        }
    }

写着写着天亮了，就这些吧。

虽然，曾经费心苦熬出来的代码，现在看起来多少有些naive，但是，人总是这样吧，在不断的自我肯定中成长，在不断的自我否定中再进一步。