RE: b h n 8 c A m 8 A Capfish 6 I Y C

l k N 0 s K ◇ M e X p L

Fellow,

During my visit in China,� ����� i find a company which sell cheap
and good quality products.

so i bring some products to my country and i agree with them to
promote their products.
53
if you need to buy some products,

you can look at this ＝∫∮∝ ∞ [web si te : www.eletoo.com ]

If you are interested in their products,

you can contact their online service workers to get the detail information.

fG9K55

U capfish 55

举例说明C#自定义配置文件app.config及如何读取配置内容(在app.config加入自定义的XML节点)?

http://www.cnblogs.com/anny-1980/articles/1421554.html

App.config文件如下:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<configSections>
<section name="Companies" type="ConvertCV.ConvertCfgHandler,ConvertCV"/>
</configSections>
<Companies>
<Company Enabled="false">
<ID>563</ID>
<Name>公司AA</Name>
<SourceFolder>E:\test\PubResume\aa</SourceFolder>
<TargetFolder>E:\test\PubResume\aa_cvt</TargetFolder>
</Company>
<Company Enabled="false">
<ID>234</ID>
<Name>公司BB</Name>
<SourceFolder>E:\test\PubResume\bb</SourceFolder>
<TargetFolder>E:\test\PubResume\bb_cvt</TargetFolder>
</Company>
<Company Enabled="true">
<ID>384</ID>
<Name>公司CC</Name>
<SourceFolder>E:\test\PubResume\cc</SourceFolder>
<TargetFolder>E:\test\PubResume\cc_cvt</TargetFolder>
</Company>
</Companies>
<appSettings>
<!--要处理哪天的数据,如果为空,则处理当天的数据-->
<add key="PubDate" value="2009-3-22"/>
<!--基础数据目录-->
<add key="BaseDataPath" value="E:\Batch\test\bin\Debug\BaseData"/>
</appSettings>
</configuration>

读取自定义配置文件:

第一步,先创建configuration section类

public class CompanySection
{
public CompanySection()
{

}

public CompanySection(XmlNode company)
{
XmlElement c = (XmlElement)company;
_enabled = Convert.ToBoolean(c.Attributes["Enabled"].Value);
_id = c.SelectSingleNode("ID").InnerText;
_name = c.SelectSingleNode("Name").InnerText;

_sourceFolder = c.SelectSingleNode("SourceFolder").InnerText;
if (_sourceFolder.Substring(_sourceFolder.Length - 1) != @"\")
_sourceFolder += @"\";

_targetFolder = c.SelectSingleNode("TargetFolder").InnerText;
if (_targetFolder.Substring(_targetFolder.Length - 1) != @"\")
_targetFolder += @"\";
}

#region 属性
private string _id = "";
private string _name = "";
private string _sourceFolder = "";
private string _targetFolder = "";
private bool _enabled = true;

public string ID
{
get { return _id; }
set { _id = value; }
}

public string Name
{
get { return _name; }
set { _name = value; }
}

public string SourceFolder
{
get { return _sourceFolder; }
set { _sourceFolder = value; }
}

public string TargetFolder
{
get { return _targetFolder; }
set { _targetFolder = value; }
}

public bool Enabled
{
get { return _enabled; }
set { _enabled = value; }
}

C# Lambda Expression概念浅析

C# Lambda Expressions是我们在开发过程中使用在数据删除操作时用到的，那么如果你是在学习LINQ to SQL的时候，那么建议你对C# Lambda Expressions还是要了解一下，以便操作的时候正确使用。

C# Lambda Expressions是什么呢？我们在处理数据库数据删除的操作的时候会碰到它，那么具体的C# Lambda Expressions是什么以及含义和使用是什么情况呢？那么下面我来看看具体的内容。

1.关于C# Lambda Expressions：

一个Lambda Expression  (译为Lambda式) 就是一个包含若干表达式和语句的匿名函数。可以被用作创建委托对象或表达式树类型。所有的Lambda式都使用操作符“=>“，表示“goes to (转变为)”。操作符左边部分是输入参数表，右边部分是表达式或语句块。x => x * x 读成“x转变为x 乘x”。Lambda式可以被赋值给一个委托类型：

C# Lambda实例1：

delegate int del(int i);  
 
 
del myDelegate = x => x * x;  
 
int j = myDelegate(5); //j = 25  
 

也可以被用于创建一个表达式树类型：

C# Lambda实例2：

using System.Linq.Expressions;  
 
 
//…  
 
Expression<del> = x => x *x;  

操作符“=>”具有和“=”一样的运算优先级，且为右相关（右边先执行）。

在例1中，我们注意到委托的定义中有一个int类型的输入参数以及int类型的返回值。例子中的Lambda式中并没有任何类型的声明。是编译器为我们做了相应的隐式数据类型转换：输入参数类型能够从委托的输入参数类型隐式转换，返回类型能够被隐式转换为委托的返回类型。

Lambda式不允许作为“is”和“as”操作符的左操作数出现。也就是

del myDelegate = x => x * x as string;  //error 
 

所有对于匿名方法的约束也同样适用于Lambda式。请参阅Anonymous Methods (C# Programming Guide).

2.从表达式理解C# Lambda Expressions

由一个计算表达式组成的一个Lambda式称之为表达式Lambda。表达式Lambda常被用于构造表达式树。一个表达式Lambda返回计算表达式运算的结果。基本结构如下：

(input parameters) => expression  
 
//如果只有一个输入参数时，括号可以省略。  
 
 
//如果具有一个以上的输入参数，必需加上括号。  
 
(x) => x * x 等于 x => x * x  
 
(x, y) => x == y  
 
 
//可以显式指定输入参数的类型  
 
(int x, string s) => s.Length > x  
 
 
//也可以没有任何输入参数  
 
() => SomeMethod1()  

上面这段代码在Lambda式中调用了一个方法。需要注意的是，如果在创建会被其他方使用的表达式树的时候，不宜在Lambda式中执行方法调用。比如：在SQL Server内执行。

一般来说，让一个方法在原先设计的上下文环境以外执行没有意义，也不能真正工作。

3.从语句理解C# Lambda Expressions

语句Lambda和表达式Lambda非常相似，只是语句被包含在大括号内：

(input parameters) => {statement;} 
 

大括号中的语句可以是任意多条，也可以写成多行（定义一个Lambda式也就是在定义一个匿名方法）：

TestDelegate myDel = n => { string s = n + " " + "World";   
 
 
Console.WriteLine(s); };  

当然语句Lambda跟匿名方法一样，无法用于创建表达式树。

4.C# Lambda Expressions之类型猜测

当编写一个Lambda式的时候，我们通常不需要明确指定输入参数的类型。因为编译器会根据Lambda体的实现，以及委托的定义来猜测类型。

举例：如果要从一个List<int>中删除小于100的元素

lst.RemoveAll(i => i < 100);   //i会被猜测为int 

通常的猜测规则如下：

◆Lambda式必须包含与委托定义中相等数量的输入参数；

◆每个Lambda式的输入参数必须能够隐式转换成委托定义中所要求的输入参数；

◆Lambda式的返回值必须能够隐式转换成委托定义中的返回值。

注意：由于目前在common type system中还没有一个“Lambda式类型”的类型。如果在有些场合提到“Lambda式的类型”，那通常表示委托的定义或者是Expression<>类型。

5.C# Lambda Expressions变量作用域

在Lambda式定义中可以引用外部变量。只要是在定义处能够访问到的变量，都可以在Lambda式中引用。

Lambda式的定义仅仅是定义一个匿名方法，最终会生成一个委托对象。外部变量的引用将被“捕获”到委托对象内部，将会伴随委托对象的整个生命周 期。在委托对象生命周期结束之前该变量都不会被垃圾回收。就算外部变量已经超过了原来的作用域，也还能继续在Lambda式中使用。所有会被引用的外部变 量必须在Lambda式定义之前被显式赋值。见下例

delegate bool D();  
delegate bool D2(int i);  
 
class Test  
{  
D del;  
D2 del2;  
public void TestMethod(int input)  
 
{  
int j = 0;  
// Initialize the delegates with lambda expressions.  
 // Note access to 2 outer variables.  
// del will be invoked within this method.  
del = () => { j = 10;  return j > input; };  
 
 
// del2 will be invoked after TestMethod goes out of scope.  
del2 = (x) => {return x == j; };  
 
// Demonstrate value of j:  
// Output: j = 0   
// The delegate has not been invoked yet.  
 
Console.WriteLine("j = {0}", j);  
// Invoke the delegate.  
bool boolResult = del();  
 
// Output: j = 10 b = True //注意j在del的执行过程中被修改  
Console.WriteLine("j = {0}. b = {1}", j, boolResult);  
 
}  
static void Main()  
{  
Test test = new Test();  
 
test.TestMethod(5);  
// Prove that del2 still has a copy of  
// local variable j from TestMethod.   
 
 
//j的引用超出了原先定义的作用域  
bool result = test.del2(10);  
// Output: True  
 
Console.WriteLine(result);  
Console.ReadKey();  
}  
}  
 

下面是关于变量作用域的规则：

◆被“捕获”的变量在委托的生命周期结束前都不会被垃圾回收；

◆在Lambda式内部定义的变量对外不可见；

◆Lambda式无法直接捕获一个具有ref或out描述的参数变量；

◆Lambda式中的return语句不会导致当前所在的方法返回；

◆Lambda式中不允许包含会导致跳当前执行范围的goto，break 或 continue语句。

6.C# Lambda Expressions学习的总结

Lambda式可以说就是另外一种形式的匿名方法。用在某些地方，会使代码更加简洁。定义一个Lambda式本质上就是定义一个委托的实现体。

原文来自博客园：http://www.cnblogs.com/smwikipedia/archive/2009/05/06/1450825.html

C# Lambda Expressions的相关内容就向你介绍到这里，希望对你了解和学习掌握C# Lambda Expressions有所帮助，之后我们会继续学习C# Lambda Expressions的一些应用。

C# Lambda Expressions 简介

1.          Lambda简介

一个Lambda Expression  (译为Lambda式) 就是一个包含若干表达式和语句的匿名函数。可以被用作创建委托对象或表达式树类型。

所有的Lambda式都使用操作符“=>“，表示“goes to (转变为)”。操作符左边部分是输入参数表，右边部分是表达式或语句块。x => x * x 读成“x转变为x 乘x”。

Lambda式可以被赋值给一个委托类型：

例1

delegate int del(int i);

del myDelegate = x => x * x;

int j = myDelegate(5); //j = 25

也可以被用于创建一个表达式树类型：

例2

using System.Linq.Expressions;

//…

Expression<del> = x => x *x;

操作符“=>”具有和“=”一样的运算优先级，且为右相关（右边先执行）。

在例1中，我们注意到委托的定义中有一个int类型的输入参数以及int类型的返回值。例子中的Lambda式中并没有任何类型的声明。是编译器为我们做了相应的隐式数据类型转换：输入参数类型能够从委托的输入参数类型隐式转换，返回类型能够被隐式转换为委托的返回类型。

Lambda式不允许作为“is”和“as”操作符的左操作数出现。也就是

del myDelegate = x => x * x as string;      //error

 

所有对于匿名方法的约束也同样适用于Lambda式。请参阅Anonymous Methods (C# Programming Guide).

2.  表达式Lambda

由一个计算表达式组成的一个Lambda式称之为表达式Lambda。表达式Lambda常被用于构造表达式树。一个表达式Lambda返回计算表达式运算的结果。

基本结构：

(input parameters) => expression

如果只有一个输入参数时，括号可以省略。如果具有一个以上的输入参数，必需加上括号。

(x) => x * x 等于 x => x * x

(x, y) => x == y

可以显式指定输入参数的类型

(int x, string s) => s.Length > x

也可以没有任何输入参数

() => SomeMethod1()

上面这段代码在Lambda式中调用了一个方法。需要注意的是，如果在创建会被其他方使用的表达式树的时候，不宜在Lambda式中执行方法调用。比如：在SQL Server内执行。

一般来说，让一个方法在原先设计的上下文环境以外执行没有意义，也不能真正工作。

3.  语句Lambda

语句Lambda和表达式Lambda非常相似，只是语句被包含在大括号内：

(input parameters) => {statement;}

大括号中的语句可以是任意多条，也可以写成多行（定义一个Lambda式也就是在定义一个匿名方法）：

TestDelegate myDel = n => { string s = n + " " + "World";

                          Console.WriteLine(s); };

当然语句Lambda跟匿名方法一样，无法用于创建表达式树。

4.  类型猜测

当编写一个Lambda式的时候，我们通常不需要明确指定输入参数的类型。因为编译器会根据Lambda体的实现，以及委托的定义来猜测类型。

举例：如果要从一个List<int>中删除小于100的元素

lst.RemoveAll(i => i < 100);       //i会被猜测为int

通常的猜测规则如下：

・         Lambda式必须包含与委托定义中相等数量的输入参数；

・         每个Lambda式的输入参数必须能够隐式转换成委托定义中所要求的输入参数；

・         Lambda式的返回值必须能够隐式转换成委托定义中的返回值。

注意：由于目前在common type system中还没有一个“Lambda式类型”的类型。如果在有些场合提到“Lambda式的类型”，那通常表示委托的定义或者是Expression<>类型。

 

5.  Lambda式中的变量作用域

在Lambda式定义中可以引用外部变量。只要是在定义处能够访问到的变量，都可以在Lambda式中引用。

Lambda 式的定义仅仅是定义一个匿名方法，最终会生成一个委托对象。外部变量的引用将被“捕获”到委托对象内部，将会伴随委托对象的整个生命周期。在委托对象生命 周期结束之前该变量都不会被垃圾回收。就算外部变量已经超过了原来的作用域，也还能继续在Lambda式中使用。所有会被引用的外部变量必须在 Lambda式定义之前被显式赋值。见下例

    delegate bool D();

    delegate bool D2(int i);

 

    class Test

    {

        D del;

        D2 del2;

        public void TestMethod(int input)

        {

            int j = 0;

            // Initialize the delegates with lambda expressions.

            // Note access to 2 outer variables.

            // del will be invoked within this method.

            del = () => { j = 10;  return j > input; };

 

            // del2 will be invoked after TestMethod goes out of scope.

            del2 = (x) => {return x == j; };

           

            // Demonstrate value of j:

            // Output: j = 0

            // The delegate has not been invoked yet.

            Console.WriteLine("j = {0}", j);

 

            // Invoke the delegate.

            bool boolResult = del();

 

            // Output: j = 10 b = True //注意j在del的执行过程中被修改

            Console.WriteLine("j = {0}. b = {1}", j, boolResult);

        }

 

        static void Main()

        {

            Test test = new Test();

            test.TestMethod(5);

 

            // Prove that del2 still has a copy of

            // local variable j from TestMethod. //j的引用超出了原先定义的作用域

            bool result = test.del2(10);

 

            // Output: True

            Console.WriteLine(result);

           

            Console.ReadKey();

        }

    }

下面是关于变量作用域的规则：

・         被“捕获”的变量在委托的生命周期结束前都不会被垃圾回收；

・         在Lambda式内部定义的变量对外不可见；

・         Lambda式无法直接捕获一个具有ref或out描述的参数变量；

・         Lambda式中的return语句不会导致当前所在的方法返回；

・         Lambda式中不允许包含会导致跳当前执行范围的goto，break 或 continue语句。

6.  总结

Lambda式可以说就是另外一种形式的匿名方法。用在某些地方，会使代码更加简洁。

定义一个Lambda式本质上就是定义一个委托的实现体。

利用委托和对象处理窗体间传值

http://blog.csdn.net/simonllf/archive/2007/03/01/1517934.aspx

今天在网上找关于窗体间传值的方法,看了好几个,但感觉两个比较好用,现转过来以便以后方便使用

1.窗体间以对象的形式传递

假设有两个form，form1、form2和一个Class1.cs的类文件。form1是程序的开始窗体，通过form1 来调用form2 。程序如下：
Class1.cs文件的内容是

public class Class1
 {
  public int i;
  public Class1()
  {
   //
   // TODO: 
   i = 9;
  }
  public void modify( int u )
  {
   i = u;
  }
 }

Form1中的内容是

private Class1 ttt;

private void Form1_Load(object sender, System.EventArgs e)
  {
   ttt = new Class1();
   Form2 temp = new Form2();
   temp.Change = ttt;
   temp.Show();
  }

  private void button1_Click(object sender, System.EventArgs e)
  {
   textBox1.Text = ttt.i.ToString();
  }

  private void button2_Click(object sender, System.EventArgs e)
  {
   ttt.modify( 44);
  }

form2中的内容是：

private Class1 change;
  public Class1 Change
  {
   get { return change ;}
   set
   { 
    change= value;
   }
  }

private void button1_Click(object sender, System.EventArgs e)
  {
   textBox1.Text = change.i.ToString();
  }

  private void button2_Click(object sender, System.EventArgs e)
  {
   change.modify( 98 );
  }

运行程序你会发现，改form1 中的textbox值，那么form2 中change中的i 的值也会相应的变，同样form2中change的 i 值变了，那么form1 中的 ttt 中的 i 也相应的变了。就好像两个form在使用同一个数据变量一样，为什么呢？

经过思考，其实很简单，原因就在于我们在使用property传递数据时使用了同一块内存空间。(牛牛注:我想就是值传递,因为把对象作为参数就是值传递)

在传递class类型的数据时（如上），由于我们没有new一个新的实例，而是直接赋值，所以就相当于使用了引用，把上面的赋值过程改成下面这样，

private Class1 change;
  public Class1 Change
  {
   get { return change ;}
   set
   { 
    change = new Class1();
    change.i  = value.i ;
   }
  }

那么两个form中的值相互之间就不再有什么关联了，也就是说，改其中一个，不会影响另外一个。这也给了我们一个启示，当我们想在form之间传值时，而且还想让值之间有一定的联系，那么就把这些值用class来包起来，再传。这样又清楚又省事。
如 果你传的不是类而是一般数据（int , string )等，那么这些数据在form之间是没有联系的，因为C#在定义这些数据类型时，就默认new了他们，例如：int i ; 和int i = new int() ; 是一样的，所以我以前经常在form之间传递简单的变量时，没有发现数据之间的关系，直到今天传 class 时才发现。像下面这样的 class ：
class temp
{   
      int i ;
      int[]   mm;
      public temp ()
      { mm = new int [10] ; }
}

在form之间传递时，变量  i  是两个窗体共用的，但是mm 却不是，其原因就是我上面讲的那样，所以利用property的这个特性，我们可以灵活的在form之间传递我们想变和不想变的值。

     在这里我要加几句,这个方法其实还有一种本质上和他一样的方法,就是把窗体作为对象进行转递来达到相同的效果,只是这样的方法比较适用于两个窗体间的互动,多个窗体就不是很好用了:

(This article describes a simplified approach to allowing communication between forms without the use of events and delegates. The approach demonstrated is adequate if the application uses a single instance of a form and allows the creation of a single instance of a dialog used to pass data to the main calling form. If you need to broadcast the data generated by a dialog to multiple form listeners, you will still need to work with events and delegates; this approach is only valid if there is a one on one relationship between the two interactive forms.)这是这个方法的一点说明:

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Text;

using System.Windows.Forms;

namespace LimitedDataXfer

{

    public partial class Form1 : Form

    {

        public Form1()

        {

            InitializeComponent();

        }

        private void btnOpenForm_Click(object sender, EventArgs e)

        {

            Form2 f = new Form2(this);

            f.Show();

        }

    }

}

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Text;

using System.Windows.Forms;

namespace LimitedDataXfer

{

    public partial class Form2 : Form

    {

        Form1 f;

        public Form2()

        {

            InitializeComponent();

        }

        public Form2(Form1 fr1)

        {

            InitializeComponent();

            f = new Form1();

            f = fr1;

        }

        private void Form2_Load(object sender, EventArgs e)

        {

          

        }

        private void textBox1_TextChanged(object sender, EventArgs e)

        {

            f.lblName.Text = textBox1.Text;

        }

        private void textBox2_TextChanged(object sender, EventArgs e)

        {

            f.lblStreet.Text = textBox2.Text;

        }

        private void textBox3_TextChanged(object sender, EventArgs e)

        {

            f.lblCity.Text = textBox3.Text;

        }

        private void textBox4_TextChanged(object sender, EventArgs e)

        {

            f.lblState.Text = textBox4.Text;

        }

        private void textBox5_TextChanged(object sender, EventArgs e)

        {

            f.lblZip.Text = textBox5.Text;

        }

    }

}

具体可以参考这个地址:http://www.c-sharpcorner.com/UploadFile/scottlysle /LimitedDataXfer01302007012304AM/LimitedDataXfer.aspx?ArticleID=98b894ff-2a4d-42b6-8aa7-7c0b210e001f

2. 用委托的方式传递

ＦＲＯＭ２中

  public delegate void changelabel(string s);
  public event changelabel change;

  private void button1_Click(object sender, System.EventArgs e)
  {
   if(change != null)
   {
    change(this.textBox1.Text);
   }
  
  }

ＦＲＯＭ　１中

  private void button2_Click(object sender, System.EventArgs e)
  {
   frmlabel frm = new frmlabel();
   frm.change += new frmlabel.changelabel(myevent);
   frm.Show();

  }
  private void myevent(string s)
  {
   this.label2.Text = s;
  }

C# 窗体间利用属性(property)来传递值时应注意的问题

http://blog.csdn.net/tjvictor/archive/2006/06/04/772711.aspx

这也许是个老话题了，但是今天我在用property 时却有了新的发现。那就是如果传递的是类的话，那么是按地址（引用）来传递的。例如如下两个程序。假设有两个form，form1、form2和一个 Class1.cs的类文件。form1是程序的开始窗体，通过form1 来调用form2 。程序如下：
Class1.cs文件的内容是

public class Class1
 {
  public int i;
  public Class1()
  {
   //
   // TODO: 
   i = 9;
  }
  public void modify( int u )
  {
   i = u;
  }
 }

Form1中的内容是

private Class1 ttt;

private void Form1_Load(object sender, System.EventArgs e)
  {
   ttt = new Class1();
   Form2 temp = new Form2();
   temp.Change = ttt;
   temp.Show();
  }

  private void button1_Click(object sender, System.EventArgs e)
  {
   textBox1.Text = ttt.i.ToString();
  }

  private void button2_Click(object sender, System.EventArgs e)
  {
   ttt.modify( 44);
  }

form2中的内容是：

private Class1 change;
  public Class1 Change
  {
   get { return change ;}
   set
   { 
    change= value;
   }
  }

private void button1_Click(object sender, System.EventArgs e)
  {
   textBox1.Text = change.i.ToString();
  }

  private void button2_Click(object sender, System.EventArgs e)
  {
   change.modify( 98 );
  }

运行程序你会发现，改form1 中的textbox值，那么form2 中change中的i 的值也会相应的变，同样form2中change的 i 值变了，那么form1 中的 ttt 中的 i 也相应的变了。就好像两个form在使用同一个数据变量一样，为什么呢？

经过思考，其实很简单，原因就在于我们在使用property传递数据时使用了同一块内存空间。

在传递class类型的数据时（如上），由于我们没有new一个新的实例，而是直接赋值，所以就相当于使用了引用，把上面的赋值过程改成下面这样，

private Class1 change;
  public Class1 Change
  {
   get { return change ;}
   set
   { 
    change = new Class1();
    change.i  = value.i ;
   }
  }

那么两个form中的值相互之间就不再有什么关联了，也就是说，改其中一个，不会影响另外一个。这也给了我们一个启示，当我们想在form之间传值时，而且还想让值之间有一定的联系，那么就把这些值用class来包起来，再传。这样又清楚又省事。
如 果你传的不是类而是一般数据（int , string )等，那么这些数据在form之间是没有联系的，因为C#在定义这些数据类型时，就默认new了他们，例如：int i ; 和int i = new int() ; 是一样的，所以我以前经常在form之间传递简单的变量时，没有发现数据之间的关系，直到今天传 class 时才发现。像下面这样的 class ：
class temp
{   
      int i ;
      int[]   mm;
      public temp ()
      { mm = new int [10] ; }
}

在form之间传递时，变量  i  是两个窗体共用的，但是mm 却不是，其原因就是我上面讲的那样，所以利用property的这个特性，我们可以灵活的在form之间传递我们想变和不想变的值。

推荐一款DataGridView的打印解决方案 [转载]

今天有朋友请教在CS的WinForm中如何打印DataGridView中的内容。
网上搜索一番之后，还是在藏宝库CodeProject中找到一篇好文章《DataGridView Printing by Selecting Columns and Rows》（http://www.codeproject.com/csharp/PrintDataGridView.asp）

效果图
【打印设置画面】

【打印预览画面】


解决方案构成
这个打印解决方案由一个打印设置的窗体，及一个打印类组成。
可用于以下场景：
1、显示的数据量较大，但又没有必要打印全部数据的时候
2、希望打印出的列宽能自动适应页面宽度

打印类主要方法
Print_DataGridView（共有）: 被外部类调用的主方法.
PrintDoc_BeginPrint（私有）: 初始化一些打印变量
PrintDoc_PrintPage（私有）: 执行打印工作
DrawFooter（私有）: 页脚的处理部分

打印类代码

/**//* ***************************************************
 * DataGridView打印类
 * 原作者：Afrasiab Cheraghi. 
 * 修改者：何奎
 * 
 * **************************************************/

using System;
using System.Collections.Generic;
using System.Windows.Forms;
using System.Drawing;
using System.Collections;
using System.Data;
using System.Text;

namespace testPrint
{
    class PrintDGV
    {
        private static StringFormat StrFormat;  // Holds content of a TextBox Cell to write by DrawString
        private static StringFormat StrFormatComboBox; // Holds content of a Boolean Cell to write by DrawImage
        private static Button CellButton;       // Holds the Contents of Button Cell
        private static CheckBox CellCheckBox;   // Holds the Contents of CheckBox Cell 
        private static ComboBox CellComboBox;   // Holds the Contents of ComboBox Cell

        private static int TotalWidth;          // Summation of Columns widths
        private static int RowPos;              // Position of currently printing row 
        private static bool NewPage;            // Indicates if a new page reached
        private static int PageNo;              // Number of pages to print
        private static ArrayList ColumnLefts = new ArrayList();  // Left Coordinate of Columns
        private static ArrayList ColumnWidths = new ArrayList(); // Width of Columns
        private static ArrayList ColumnTypes = new ArrayList();  // DataType of Columns
        private static int CellHeight;          // Height of DataGrid Cell
        private static int RowsPerPage;         // Number of Rows per Page
        private static System.Drawing.Printing.PrintDocument printDoc =
                       new System.Drawing.Printing.PrintDocument();  // PrintDocumnet Object used for printing

        private static string PrintTitle = "";  // Header of pages
        private static DataGridView dgv;        // Holds DataGridView Object to print its contents
        private static List<string> SelectedColumns = new List<string>();   // The Columns Selected by user to print.
        private static List<string> AvailableColumns = new List<string>();  // All Columns avaiable in DataGrid 
        private static bool PrintAllRows = true;   // True = print all rows,  False = print selected rows    
        private static bool FitToPageWidth = true; // True = Fits selected columns to page width ,  False = Print columns as showed    
        private static int HeaderHeight = 0;

        public static void Print_DataGridView(DataGridView dgv1)
        {
            PrintPreviewDialog ppvw;
            try 
            {    
                // Getting DataGridView object to print
                dgv = dgv1;

                // Getting all Coulmns Names in the DataGridView
                AvailableColumns.Clear();
                foreach (DataGridViewColumn c in dgv.Columns)
                {
                    if (!c.Visible) continue;
                    AvailableColumns.Add(c.HeaderText);
                }

                // Showing the PrintOption Form
                PrintOptions dlg = new PrintOptions(AvailableColumns);
                if (dlg.ShowDialog() != DialogResult.OK) return;

                PrintTitle = dlg.PrintTitle;
                PrintAllRows = dlg.PrintAllRows;
                FitToPageWidth = dlg.FitToPageWidth;
                SelectedColumns = dlg.GetSelectedColumns();

                RowsPerPage = 0;

                ppvw = new PrintPreviewDialog();
                ppvw.Document = printDoc;

                // Showing the Print Preview Page
                printDoc.BeginPrint +=new System.Drawing.Printing.PrintEventHandler(PrintDoc_BeginPrint);
                printDoc.PrintPage +=new System.Drawing.Printing.PrintPageEventHandler(PrintDoc_PrintPage);
                if (ppvw.ShowDialog() != DialogResult.OK)
                {
                    printDoc.BeginPrint -= new System.Drawing.Printing.PrintEventHandler(PrintDoc_BeginPrint);
                    printDoc.PrintPage -= new System.Drawing.Printing.PrintPageEventHandler(PrintDoc_PrintPage);
                    return;
                }

                // Printing the Documnet
                printDoc.Print();
                printDoc.BeginPrint -= new System.Drawing.Printing.PrintEventHandler(PrintDoc_BeginPrint);
                printDoc.PrintPage -= new System.Drawing.Printing.PrintPageEventHandler(PrintDoc_PrintPage);
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);                
            }
            finally
            {

            }
        }

        private static void PrintDoc_BeginPrint(object sender, 
                    System.Drawing.Printing.PrintEventArgs e) 
        {
            try
            {
                // Formatting the Content of Text Cell to print
                StrFormat = new StringFormat();
                StrFormat.Alignment = StringAlignment.Near;
                StrFormat.LineAlignment = StringAlignment.Center;
                StrFormat.Trimming = StringTrimming.EllipsisCharacter;

                // Formatting the Content of Combo Cells to print
                StrFormatComboBox = new StringFormat();
                StrFormatComboBox.LineAlignment = StringAlignment.Center;
                StrFormatComboBox.FormatFlags = StringFormatFlags.NoWrap;
                StrFormatComboBox.Trimming = StringTrimming.EllipsisCharacter;

                ColumnLefts.Clear();
                ColumnWidths.Clear();
                ColumnTypes.Clear();
                CellHeight = 0;
                RowsPerPage = 0;

                // For various column types
                CellButton = new Button();
                CellCheckBox = new CheckBox();
                CellComboBox = new ComboBox();

                // Calculating Total Widths
                TotalWidth = 0;
                foreach (DataGridViewColumn GridCol in dgv.Columns)
                {
                    if (!GridCol.Visible) continue;
                    if (!PrintDGV.SelectedColumns.Contains(GridCol.HeaderText)) continue;
                    TotalWidth += GridCol.Width;
                }
                PageNo = 1;
                NewPage = true;
                RowPos = 0;                
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);                
            }
        }

        private static void PrintDoc_PrintPage(object sender, 
                    System.Drawing.Printing.PrintPageEventArgs e) 
        {
            int tmpWidth, i;
            int tmpTop = e.MarginBounds.Top;
            int tmpLeft = e.MarginBounds.Left;

            try 
            {            
                // Before starting first page, it saves Width & Height of Headers and CoulmnType
                if (PageNo == 1) 
                {
                    foreach (DataGridViewColumn GridCol in dgv.Columns)
                    {
                        if (!GridCol.Visible) continue;
                        // Skip if the current column not selected
                        if (!PrintDGV.SelectedColumns.Contains(GridCol.HeaderText)) continue;

                        // Detemining whether the columns are fitted to page or not.
                        if (FitToPageWidth) 
                            tmpWidth = (int)(Math.Floor((double)((double)GridCol.Width / 
                                       (double)TotalWidth * (double)TotalWidth * 
                                       ((double)e.MarginBounds.Width / (double)TotalWidth))));
                        else
                            tmpWidth = GridCol.Width;

                        HeaderHeight = (int)(e.Graphics.MeasureString(GridCol.HeaderText,
                                    GridCol.InheritedStyle.Font, tmpWidth).Height) + 11;
                        
                        // Save width & height of headres and ColumnType
                        ColumnLefts.Add(tmpLeft);
                        ColumnWidths.Add(tmpWidth);
                        ColumnTypes.Add(GridCol.GetType());
                        tmpLeft += tmpWidth;
                    }
                }

                // Printing Current Page, Row by Row
                while (RowPos <= dgv.Rows.Count - 1)
                {
                    DataGridViewRow GridRow = dgv.Rows[RowPos];
                    if (GridRow.IsNewRow || (!PrintAllRows && !GridRow.Selected))
                    {
                        RowPos++;
                        continue;
                    }

                    CellHeight = GridRow.Height;

                    if (tmpTop + CellHeight >= e.MarginBounds.Height + e.MarginBounds.Top)
                    {
                        DrawFooter(e, RowsPerPage);
                        NewPage = true;
                        PageNo++;
                        e.HasMorePages = true;
                        return;
                    }
                    else
                    {
                        if (NewPage)
                        {
                            // Draw Header
                            e.Graphics.DrawString(PrintTitle, new Font(dgv.Font, FontStyle.Bold), 
                                    Brushes.Black, e.MarginBounds.Left, e.MarginBounds.Top -
                            e.Graphics.MeasureString(PrintTitle, new Font(dgv.Font, 
                                    FontStyle.Bold), e.MarginBounds.Width).Height - 13);

                            String s = DateTime.Now.ToLongDateString() + " " + DateTime.Now.ToShortTimeString();

                            e.Graphics.DrawString(s, new Font(dgv.Font, FontStyle.Bold), 
                                    Brushes.Black, e.MarginBounds.Left + (e.MarginBounds.Width - 
                                    e.Graphics.MeasureString(s, new Font(dgv.Font, 
                                    FontStyle.Bold), e.MarginBounds.Width).Width), e.MarginBounds.Top - 
                                    e.Graphics.MeasureString(PrintTitle, new Font(new Font(dgv.Font, 
                                    FontStyle.Bold), FontStyle.Bold), e.MarginBounds.Width).Height - 13);

                            // Draw Columns
                            tmpTop = e.MarginBounds.Top;
                            i = 0;
                            foreach (DataGridViewColumn GridCol in dgv.Columns)
                            {
                                if (!GridCol.Visible) continue;
                                if (!PrintDGV.SelectedColumns.Contains(GridCol.HeaderText)) 
                                    continue;

                                e.Graphics.FillRectangle(new SolidBrush(Color.LightGray), 
                                    new Rectangle((int) ColumnLefts[i], tmpTop,
                                    (int)ColumnWidths[i], HeaderHeight));

                                e.Graphics.DrawRectangle(Pens.Black, 
                                    new Rectangle((int) ColumnLefts[i], tmpTop,
                                    (int)ColumnWidths[i], HeaderHeight));

                                e.Graphics.DrawString(GridCol.HeaderText, GridCol.InheritedStyle.Font, 
                                    new SolidBrush(GridCol.InheritedStyle.ForeColor),
                                    new RectangleF((int)ColumnLefts[i], tmpTop, 
                                    (int)ColumnWidths[i], HeaderHeight), StrFormat);
                                i++;
                            }
                            NewPage = false;
                            tmpTop += HeaderHeight;
                        }

                        // Draw Columns Contents
                        i = 0;
                        foreach (DataGridViewCell Cel in GridRow.Cells)
                        {
                            if (!Cel.OwningColumn.Visible) continue;
                            if (!SelectedColumns.Contains(Cel.OwningColumn.HeaderText))
                                continue;

                            // For the TextBox Column
                            if (((Type) ColumnTypes[i]).Name == "DataGridViewTextBoxColumn" || 
                                ((Type) ColumnTypes[i]).Name == "DataGridViewLinkColumn")
                            {
                                e.Graphics.DrawString(Cel.Value.ToString(), Cel.InheritedStyle.Font, 
                                        new SolidBrush(Cel.InheritedStyle.ForeColor),
                                        new RectangleF((int)ColumnLefts[i], (float)tmpTop,
                                        (int)ColumnWidths[i], (float)CellHeight), StrFormat);
                            }
                            // For the Button Column
                            else if (((Type) ColumnTypes[i]).Name == "DataGridViewButtonColumn")
                            {
                                CellButton.Text = Cel.Value.ToString();
                                CellButton.Size = new Size((int)ColumnWidths[i], CellHeight);
                                Bitmap bmp =new Bitmap(CellButton.Width, CellButton.Height);
                                CellButton.DrawToBitmap(bmp, new Rectangle(0, 0, 
                                        bmp.Width, bmp.Height));
                                e.Graphics.DrawImage(bmp, new Point((int)ColumnLefts[i], tmpTop));
                            }
                            // For the CheckBox Column
                            else if (((Type) ColumnTypes[i]).Name == "DataGridViewCheckBoxColumn")
                            {
                                CellCheckBox.Size = new Size(14, 14);
                                CellCheckBox.Checked = (bool)Cel.Value;
                                Bitmap bmp = new Bitmap((int)ColumnWidths[i], CellHeight);
                                Graphics tmpGraphics = Graphics.FromImage(bmp);
                                tmpGraphics.FillRectangle(Brushes.White, new Rectangle(0, 0, 
                                        bmp.Width, bmp.Height));
                                CellCheckBox.DrawToBitmap(bmp, 
                                        new Rectangle((int)((bmp.Width - CellCheckBox.Width) / 2), 
                                        (int)((bmp.Height - CellCheckBox.Height) / 2), 
                                        CellCheckBox.Width, CellCheckBox.Height));
                                e.Graphics.DrawImage(bmp, new Point((int)ColumnLefts[i], tmpTop));
                            }
                            // For the ComboBox Column
                            else if (((Type) ColumnTypes[i]).Name == "DataGridViewComboBoxColumn")
                            {
                                CellComboBox.Size = new Size((int)ColumnWidths[i], CellHeight);
                                Bitmap bmp = new Bitmap(CellComboBox.Width, CellComboBox.Height);
                                CellComboBox.DrawToBitmap(bmp, new Rectangle(0, 0, 
                                        bmp.Width, bmp.Height));
                                e.Graphics.DrawImage(bmp, new Point((int)ColumnLefts[i], tmpTop));
                                e.Graphics.DrawString(Cel.Value.ToString(), Cel.InheritedStyle.Font, 
                                        new SolidBrush(Cel.InheritedStyle.ForeColor), 
                                        new RectangleF((int)ColumnLefts[i] + 1, tmpTop, (int)ColumnWidths[i]
                                        - 16, CellHeight), StrFormatComboBox);
                            }
                            // For the Image Column
                            else if (((Type) ColumnTypes[i]).Name == "DataGridViewImageColumn")
                            {
                                Rectangle CelSize = new Rectangle((int)ColumnLefts[i], 
                                        tmpTop, (int)ColumnWidths[i], CellHeight);
                                Size ImgSize = ((Image)(Cel.FormattedValue)).Size;
                                e.Graphics.DrawImage((Image)Cel.FormattedValue, 
                                        new Rectangle((int)ColumnLefts[i] + (int)((CelSize.Width - ImgSize.Width) / 2), 
                                        tmpTop + (int)((CelSize.Height - ImgSize.Height) / 2), 
                                        ((Image)(Cel.FormattedValue)).Width, ((Image)(Cel.FormattedValue)).Height));

                            }

                            // Drawing Cells Borders 
                            e.Graphics.DrawRectangle(Pens.Black, new Rectangle((int)ColumnLefts[i], 
                                    tmpTop, (int)ColumnWidths[i], CellHeight));

                            i++;

                        }
                        tmpTop += CellHeight;
                    }

                    RowPos++;
                    // For the first page it calculates Rows per Page
                    if (PageNo == 1) RowsPerPage++;
                }

                if (RowsPerPage == 0) return;

                // Write Footer (Page Number)
                DrawFooter(e, RowsPerPage);

                e.HasMorePages = false;
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);                
            }
        }

        private static void DrawFooter(System.Drawing.Printing.PrintPageEventArgs e, 
                    int RowsPerPage)
        {
            double cnt = 0; 

            // Detemining rows number to print
            if (PrintAllRows)
            {
                if (dgv.Rows[dgv.Rows.Count - 1].IsNewRow) 
                    cnt = dgv.Rows.Count - 2; // When the DataGridView doesn't allow adding rows
                else
                    cnt = dgv.Rows.Count - 1; // When the DataGridView allows adding rows
            }
            else
                cnt = dgv.SelectedRows.Count;

            // Writing the Page Number on the Bottom of Page
            string PageNum = " 第 " + PageNo.ToString()
                           + " 页，共 " + Math.Ceiling((double)(cnt / RowsPerPage)).ToString()
                           + " 页";

            e.Graphics.DrawString(PageNum, dgv.Font, Brushes.Black, 
                e.MarginBounds.Left + (e.MarginBounds.Width - 
                e.Graphics.MeasureString(PageNum, dgv.Font, 
                e.MarginBounds.Width).Width) / 2, e.MarginBounds.Top + 
                e.MarginBounds.Height + 31);
        }
    }
}

示例工程下载：
testPrint



原文地址：http://www.codeproject.com/KB/grid/PrintDataGridView.aspx